Sparse Factorization Layers for Neural Networks with Limited Supervision

Sparse Factorization Layers for Neural Networks with Limited Supervision

Parker Koch and Jason J. Corso
Electrical Engineering and Computer Science
University of Michigan
Ann Arbor, MI 48109
{pakoch|jjcorso}@umich.edu
Abstract

Whereas CNNs have demonstrated immense progress in many vision problems, they suffer from a dependence on monumental amounts of labeled training data. On the other hand, dictionary learning does not scale to the size of problems that CNNs can handle, despite being very effective at low-level vision tasks such as denoising and inpainting. Recently, interest has grown in adapting dictionary learning methods for supervised tasks such as classification and inverse problems. We propose two new network layers that are based on dictionary learning: a sparse factorization layer and a convolutional sparse factorization layer, analogous to fully-connected and convolutional layers, respectively. Using our derivations, these layers can be dropped in to existing CNNs, trained together in an end-to-end fashion with back-propagation, and leverage semisupervision in ways classical CNNs cannot. We experimentally compare networks with these two new layers against a baseline CNN. Our results demonstrate that networks with either of the sparse factorization layers are able to outperform classical CNNs when supervised data are few. They also show performance improvements in certain tasks when compared to the CNN with no sparse factorization layers with the same exact number of parameters.

1 Introduction

Artificial neural networks, especially convolutional neural networks (CNN) [18] have proven to be powerful, flexible models [10, 33, 16] for a variety of complex tasks, particularly in computer vision [31, 14, 29]. By composing sequences of simple operations (layers) into complex structures (networks) and then subsequently estimating all network parameters through gradient backpropagation [19], they are able to learn representations of complex phenomena, arguably, better than contemporary alternatives.

Despite their widespread adoption and success, these complex networks present two core challenges that often make them seem like a black-art to work with [30, 28]. First, they are indeed complex structures and hence resist theoretical analysis: the few known results [13, 22] do little to explain what is actually being learned or how to improve a certain network. Second, these complex networks have millions of parameters and hence require a large amount of supervised data to learn, such as COCO [20], ImageNet [5] or YouTube-8M [1] which take many person-years to build. This need limits the artificial neural network extensibility to situations without large-scale data. Although some efforts toward self-supervision [37], which have potential to mitigate this issue, have begun, abundant supervision remains a core limitation.

On the contrary, sparse representation models [7], like dictionary learning through elastic net problem [42], afford strong theoretical analysis, indeed often rigorous theoretical analysis resulting in analytical confidence when used. They are potentially better matched to computer vision, which has many inherently sparse problems. Furthermore, due to their structure, they tend to need significantly less training data than artificial neural networks. And, although they have seen success in vision, both in generative [40] discriminative [41] forms, at the low- [25] and high-levels [21], they have not been able to keep pace with CNNs in large-scale or high-dimensional problems [31].

This strong contrast between artificial networks and sparse representations is the foundation for our work. We seek to bridge between these two modeling approaches yielding a representation that remains as general as these two are, but has better scalability than classical sparse representation learning and, at the same time, requires less labeled data than modern artificial neural networks.

Indeed, forging this bridge has been considered by others already. For example, greedy deep dictionary learning [35] sequentially encodes the data through a series of sparse factorizations. While interesting, this approach is neither end-to-end, nor does it afford a supervised loss function, limiting its potential in many vision problems. Convolutional sparse coding [15] derives a convolution form of sparse representations, but it is not yet known how to embed these into artificial neural networks. On the other hand, rectified linear units [9] induce a sparsity in activation, and have improved performance. However, they provide no means for tuning the level of sparsity. Summarily, although there has been work in forging this bridge, no approach we are aware of successfully unifies sparse representation modeling and artificial neural networks with a controllable level of sparsity and a capability to move between supervised and unsupervised loss (see Section 2 for more discussion).

In this paper, we take a step toward bridging these two disparate fields. The core novelty in our work is two network layers that do sparse representation learning, or dictionary learning, directly within the network. We call them sparse factorization layers because they indeed factorize the input into its sparse reconstruction coefficients, which are then passed onward to later layers in the network—sparse activation.

We propose both a sparse factorization layer (SF) that learns the dictionary over all of its input terms, analogous to a fully connected layer, and a convolutional sparse factorization layer (CSF) that slides the dictionary over the input analogous (in spirit) to a convolutional layer in a CNN. We show how to compute the back-propagation gradients for the parameters (dictionaries) of both layers, leveraging theoretical results on the local linearity of dictionaries [23]. Hence the two layers can be incorporated and trained directly within modern networks. Furthermore, we propose a new semisupervised loss that leverages the generative nature of the sparse factorization layers.

The main contribution of our paper is these two sparse factorization layers that can be plugged into modern convolutional neural networks, trained in an end-to-end manner, and facilitate tunable activation sparsity. A secondary contribution of the paper is a semisupervised loss function that combines the generative nature of the sparse factorization layers into the discriminative convolutional network.

We demonstrate the empirical utility of the SF and CSF layers as replacements for traditional CNN layers. It is beyond the scope of this paper to evaluate all of our stated goals of bridging these two disparate fields. So, we focus on the use of these two sparse factorization layers with limited data in comparison to a classical convolutional neural network. On the digit classification problem with MNIST, comparable networks with SF and CSF layers replacing their analogs in the original CNN perform on par with the CNN.

However, when we reduce the amount of training data to of the original size (10 samples per class), the performance of our models are and higher than the CNN, for the sparse factorization and convolutional sparse factorization layers, respectively. As expected the relative performance improvement of our sparse factorization layers decreases with respect to CNN performance as the amount training data increases. We also show marked improvement ( absolute accuracy) in performance on one of the MNIST variations dataset. Section 5 has full results.

2 Related Work

We first focus our discussion on methods seeking to bridge between artificial neural networks and sparse representation modeling. Greedy deep dictionary learning [35] involves a layered, generative architecture that seeks to encode inputs through a series of sparse factorizations, which are trained individually to reconstruct the input faithfully. It, however, has no mechanism for end-to-end training and is unsupervised, limiting its potential in various tasks like classification, given modern performance statistics. Sparse autoencoders [26, 11] do the same using linear operations and sparsifying transforms in place of sparse factorization. Although these models can be trained in an end-to-end manner, we are not aware of any work that incorporates them into supervised or semisupervised tasks. In contrast, the SF layer that we propose subsumes these capabilities, can be trained end-to-end and can be embedded in supervised, semisupervised and unsupervised networks.

Recent work in truly convolutional sparse coding [15, 4] strives to produce a sparse representation of an image by encoding the image spatially as a whole, instead of in isolated patches, which has been the standard way of incorporating sparse representations into image analysis. This method is similar to our proposed convolutional sparse factorization layer: although they embed the sparse coding operation in the convolution, we are convolutional only in spirit, choosing to map the sparse factorization approach over every patch in the image. Although this work has promise and could potentially even be used to extend the ideas in our paper, we are not aware of a result indicating that they can be incorporating into artificial neural networks, like our methods.

Lastly, hierarchical and multi-layered sparse coding of images [40, 39, 2] has been performed both in a greedy fashion and end-to-end fashion. However, these typically involve heuristics and lack a principled calculus to embed them within the artificial neural network framework. They hence lack compatibility with traditional CNN components. In contrast, both of our new layers can be dropped-in to various artificial (and convolutional) neural networks and trained in the same architecture with back-propagation.

Sparsity in CNNs

We relate our work to past methods that directly induce sparsity into artificial neural networks. Various methods [32, 27, 3] have indirectly induced sparsity in the parameters or activations by incorporating sparsity-inducing penalties into network loss functions. Techniques like Dropout [34] and DropConnect [38] artificially simulate activation sparsity during inference to prevent redundancy and improve performance. Glorot et al. [9] argue for the use of the rectified linear unit (ReLU), a sparsifying activation function, to improve performance in CNNs. This works primarily by limiting the sensitivity of the activations to small changes in the input, thereby forming a more robust and error-tolerant network. However, these methods either lack theoretical basis, offer no means for controlling the activations’ sparsity, and/or require that all nonzero activations are positive, unlike our work.

The rest of the paper is organized as follows. In Section 3 we lay the notational and modeling foundation for the paper. Section 4 introduces sparse factorization and the sparse factorization network layers. Section 5 describes our experimental evaluation of our work, and finally, Section 6 summarizes our work and discusses its limitations and future directions.

3 Background

Notation

We have made an effort to maintain consistent notation throughout the paper, sometimes at the expense of deviating from the common notation in existing literature, especially that in dictionary learning. To that end, we use bold lower-case letters, such as and to represent tensors that are typically vectors—these are, e.g., inputs and outputs of neural network layers or sparse representation (coding) coefficients. We use bold upper-case symbols, such as , to denote tensors that act as operators, such as weight matrices in neural networks and dictionaries in sparse representations (these are generally the parameters we seek to learn). Greek letters, such as , are used for scalars.

Convolutional Neural Networks

Artificial neural networks are systems constructed by the composition of potentially many simple, differentiable operations. Let denote the input to the network, which is generally a tensor of some order, such as an image. The first operation, or layer, denoted , takes input and parameters to produce an output, or activation, , which serves as input to the second layer. The process repeats until we reach the activation of the th layer of the network, . For readability, we use the term activation to refer to the output of each layer in the network, not only those layers commonly called activation functions like the sigmoid or tanh layers.

Despite the enormous flexibility of such models, only a small variety of layers are commonly used; most notably, linear transform layers (, for vector and parameter (weight) matrix ), convolution layers (, for tensor , kernel bank , and offset ), and parameter-free transforms like local pooling, rectification, and sigmoid activation. CNNs are networks with one or more convolution layers.

For any such supervised network, a loss function compares the final activation to some supervision information about the input to measure, for example, classification correctness, or some other measure of output quality. The chain rule is then employed to calculate the gradient of this loss with respect to each intermediate activation:

(1)

At each step of the backward computation (the right column in (1)), the gradient is also computed:

(2)

With these calculated, gradient descent on the network parameters is used to shrink the overall loss. The denotes supervised loss; we will later incorporate an unsupervised loss into the formulation and denote it by .

It should be noted that networks are not limited to a single chain of operations, but we restrict our discussion to such for simplicity and without loss of generality. Additionally, our use of the notation is purely symbolic, as the parameters may be a scalar, vector, matrix, or a collection thereof—or missing altogether.

4 Sparse Factorization in Neural Networks

Sparse representation models like dictionary learning [7] decompose, or factorize, a signal into the linear combination of just a few elements from an overcomplete basis, commonly called a dictionary. In contrast, common layers in neural networks, such as the linear transform or fully-connected layer, compose the output from the parameter matrix and the input. Concretely, consider such a linear transform layer:

(3)

for input vector and parameters . The (forward) process of sparse factorization is significantly different, involving the solution to an unconstrained optimization problem:

(4)

where the -norm is a sparsity-inducing regularizer, and the (typically miniscule) penalty on is for numerical stability of the optimization algorithm and the terms are scalar weights on them. This formulation is referred to as the elastic-net problem [42] and is one variant of many sparse representation formulations; our consideration here is general.

Careful inspection indicates the linear transform takes a dense combination of columns of the parameter matrix weighted by the input and outputs the results. However, the sparse representation instead computes the best fit of the input with respect to a sparse combination of columns of the parameter matrix and then returns the weights of this sparse combination. In essence, it factorizes as a function of leading to sparse activations; hence the name of our methods. Figure 1 provides an illustration of this comparison. Sparse activations are fundamentally different than the common sparsity inducing regularization used in current neural network training (see Section 2 for more discussion on this relationship).

This difference leads to new neural network layers that are based in sparse representation modeling, yielding sparse activations, strong theoretical guarantees, and the promise of training with less labeled data. Indeed, this work builds on the large body of work in sparse representation modeling and dictionary learning that has been prevalent in computer vision [40, 41, 25, 21].

Figure 1: Visual comparison of linear transform operation (composition) and sparse factorization operation (decomposition). The new layers we propose in this paper are able to induce a sparse activation by leveraging ideas from sparse representation modeling and dictionary learning. denotes matrix multiplication.

We next show how to create two novel artificial neural network layers based on this core idea of sparse factorization as well as the strong theoretical foundation on which it is based (Section 4.3). Examples of the two new layers in comparison to a baseline network based off of LeNet [18] is included in Figure 2. We also describe a new semi-supervised loss that leverages the generative nature of sparse representations to regularize the classification loss (Section 4.4). In Section 5, we describe the results of our experiments using these novel sparse factorization layers, which demonstrate a large gain in performance for limited training data.

Figure 2: Illustrative comparison of the role our two new sparse factorization layers can provide in a classical network architecture (left) suitable for a digit classification problem like MNIST. The three networks show the data layer at the bottom and the final activation at the top; computations are drawn in black and activation tensors are drawn in blue. The sparse factorization layer replaces both the fully connected layer and the subsequent rectified linear unit layer (since this would conflict with the possible negative weights of the sparse activation), which is why the SF network has only 6 layers. The convolutional sparse factorization network replaces the first convolution layer with the CSF layer. All other things are equal and comparable.

4.1 Sparse Factorization Layer

The sparse factorization (SF) layer directly implements this sparse representation idea as a new layer that can be plugged into any artificial neural network. Parameter-for-parameter, the SF layer can replace a linear transform or fully-connected layer in current networks (indeed, we do this in our experiments to make a direct comparison, Section 5). Forward computation is straightforward, as we will explain, and backward computation leads to the estimation of the parameter matrix (the dictionary) within the gradient descent optimization regime.

Concretely, a SF layer is parameterized by a dictionary , which we assume is known for the forward pass. The dictionary, or parameter matrix, represents the overcomplete basis into which we will factorize the input

(5)

where the output activation is sparse for correctly chosen values of , due to the -regularizer. Again, this is an instance of the elastic-net problem and can be solved with Least-Angle Regression (LARS) [6], completing the forward pass of the layer.

During backpropagation, we need to compute the gradient of the loss, , with respect to the previous layer’s activation and the parameter matrix using the transferred gradient from layer . This is possible only if the forward computation procedure is differentiable; Mairal et al. [23] prove the differentiability of the optimization in under mild conditions and compute its gradients, albeit for the problem of task-specific dictionary learning. We present here the results of practical interest to the SF layer computation, with further details in Section 4.3.

Define to be the nonzero support of , i.e., the indices of the coefficients that are nonzero, and define auxiliary variable to have where is the complement of and the notation means indexing or slicing the vector. Then, let

(6)

where is the back-propagated supervised loss from the higher layer indexed at only the nonzero support of via .

The gradients of interest are computed directly with this auxiliary vector :

(7)
(8)

The gradient is backpropagated to lower layers in the network, and the gradient on the parameters, is used to update the dictionary at this sparse factorization layer. Note that after every gradient step, must be normalized so that each element has -norm no greater than 1; without this, we could scale up and down by a large constant, reducing the regularization penalties arbitrarily without improving the quality of the sparse representation.

4.2 Convolutional Sparse Factorization Layer

Sparse representations have had success in patch-based models [25]. Likewise, the convolution layer in artificial neural networks has achieved great success [10, 33, 16]. The translation invariance induced by these approaches is particularly well-suited to image-based problems. We hence generalize the SF layer to operate convolutionally on image patches. This new layer, the convolutional sparse factorization (CSF) layer, performs the factorization locally on rectangular input regions much like convolutional layers perform localized linear transforms.

Consider such a layer that takes in images as input and performs the sparse factorization on overlapping patches of size . Let be an input image to the CSF layer, and let be the layer dictionary. Denote patch into image as The CSF layer is defined as

(9)

For each patch , a sparse factorization is computed in forward inference. These sparse factorization activation vectors are analogous to the localized patch response to a bank of kernels in traditional CNNs. These are arranged into a output tensor–exactly the same size as a traditional convolution layer. However, note that while we call it a convolutional layer, it is convolutional only in spirit: at each patch location, it is solving a sparse factorization kernel and it uses the same parameter matrix everywhere. Defined in this way, the CSF layer is a drop-in replacement for convolutional layers.

During backpropagation, given the output gradients , is computed for each patch as in Eq. 6. This allows us to compute patch gradients, and , for the local dictionary and the current layer activation, respectively adapting Eqs. 7 and 8. Due to the linearity of convolution, we simply sum these gradients over all patches to yield the layer gradients that are used to update the parameter (the dictionary) and passed down to the lower layer.

4.3 Theoretical Basis

To incorporate the sparse factorization and convolutional sparse factorization layers within the end-to-end backpropagation-based training, their respective forward operations need to be differentiable and we need to compute the analytical derivatives. To that end, we review the pertinent results of Mairal et al. [23], which serve as the theoretical basis for our two new layers. They prove the differentiability of the sparse factorization operation that is used in both and , and outline an optimization framework that allows sparse coding to be used in a variety of tasks.

The framework in [23] contains three stages: a vector input is first multiplied by the linear transform matrix ; given dictionary , the sparse code of the resulting vector is computed through the elastic net, from Eq. 4, and a function is applied to the sparse output, with parameters . Mairal et al. [23] considered only the cases where is linear or bilinear, though their derivation holds for any differentiable , which is critical for our work as will become clear below.

This output, , is compared to supervision in a twice-differentiable loss function , and the task is defined by the minimization thereof. To this end, they prove that is differentiable for any input that has a probability distribution with compact support, which is expected to be satisfied in our operating conditions. Given this proof, they compute the gradients required to update and using a descent algorithm; we have similarly relied on this proof to derive our gradients in Eqs. 7 and 8.

Although originally developed for compressed sensing, we take a new view onto this framework: it is a shallow artificial neural network. We detail the forward pass of this shallow network below, using our established convention:

(10)

Relating this shallow network to the SF and CSF layers in larger networks, we map the last process as the remainder of the network above the inserted SF and CSF layers, noting that their proof holds for any differentiable . We drop the linear layer and replace it with whatever is below the inserted SF and CSF layers without impacting the gradient of the SF or CSF layers in any way. Also, we have separated the derivation of the backpropagation gradient after splitting the operations into three steps, resulting trivially in Eq 8.

4.4 Semisupervision

A fundamental difference between the sparse factorization layers and their traditional neural networks counterparts is the generative nature of sparse factorization. Consider the extended optimization to include the parameters (dictionary) in addition to the sparse factorization (code),

(11)
s.t.

where we use a underset-subscript to indicate sample index to avoid confusion over layer indices in earlier notation and add the regularization on the dictionary. We immediately notice this goal of a dictionary that facilitates high fidelity reconstruction of the training data. This goal is unsupervised, in contrast to the supervised goals commonly used to train convolutional neural networks. Note the relation to auto-encoders [12], which are also generative; however, their layer definitions follow the traditional linear transforms we have already discussed.

Of course, we do not directly solve this non-convex optimization, but solve it instead through backpropagation using the earlier derivations. However, we do incorporate this goal of seeking a dictionary that enables high fidelity reconstructions of our data, which is similar to multi-task regularization [17, 8]. We define the unsupervised loss that can be used to regularize the SF and CSF layer parameter (dictionary) as

(12)

where indicates the activation to the forward pass of SF or CSF layer after solving the or , respectively. This loss can be summed over all samples in a batch.

The gradient associated with this task, , is well known in the dictionary learning literature [7], though more sophisticated optimization methods are typically preferred for learning purely unsupervised dictionaries. The expression for is given by

(13)

We can incorporate it into our gradient descent method by defining an effective semisupervised gradient, as a convex combination of the two:

(14)

for . Note that the sample or activation used to calculate the unsupervised loss need not be the same sample or activation used for the supervised loss, nor does it need any corresponding supervision , allowing for the use of weakly annotated samples.

Finally, because we are layering the sparse factorization layers into larger neural network structures, we need to propagate the gradient from the unsupervised loss down past the dictionary learning for an end-to-end regime. This gradient,

(15)

is transferred directly or as part of the gradient which is trivially derived.

In practice, we use a step-down schedule for the semisupervision parameter , training for several iterations with , then several more with 0.5, 0.3, and finally 0.0. We observe that this improves performance when compared to purely supervised training This step-down schedule is similar to the one proposed in Mairal et al. [23] except that do not use the piecewise constant-inverse learning rate schedule, favoring instead stochastic gradient descent with a momentum of 0.9.

5 Experiments

We evaluate our new layers on a classic vision problem allowing us to thoroughly inspect various aspects of the layers in comparison to a well-studied baseline network. Although we do expect our new layers to positively impact other vision problems, especially those with limited training data, we restrict the scope of our study to classification at moderate scale. Recall that Figure 2 visualizes the three core networks that we will compare. Our baseline model is a curtailed version of LeNet-5 [18], comprising two convolution layers and two linear layers, and denoted LeNet. Our variants are as follows: CSF replaces the first convolution layer with a CSF layer; SF replaces the first linear layer with a SF layer and removes the rectified linear unit layer; and CSF+SF makes both modifications. All other things about these networks are equivalent, including the total number of parameters.

Implementation

All networks are implemented in MatConvNet  [36] and trained using stochastic gradient descent with momentum. Forward computation in SF and CSF layers is performed with the SPAMS sparse modeling library [24]. Please contact the authors for access to the source code.

5.1 Digit Classification Performance

We first compare the CSF and SF layers to traditional methods on the task of digit classification. Table 1 shows the networks’ classification accuracy on: MNIST [18], a handwritten digit classification dataset; MNIST-rot, a modified MNIST with each digit rotated randomly; MNIST-rand, which contains random noise in the background of every image; and MNIST-img, which superimposes the written digits on randomly selected image patches. The original MNIST has 60000 training images and 10000 for testing and its variants have 12000 for training and 50000 for testing.

We observe improved performance on most tasks through the use of the CSF layer. This is intuitive especially for the MNIST-rand and MNIST-img datasets—on which it outperformed the baseline the most—given the rich history of natural-image denoising and patch reconstruction with sparse representation models [7]. The performance of the SF layer is more volatile. This could be due to the unpredictable structure of the network’s intermediate activations, which may not readily admit a sparse representation, jeopardizing the stability of the SF layer’s output. Or it could be due to the constraint we imposed to maintain a consistent total number of parameters across the three models being compared; the dictionary underlying the SF layer may not be wide enough.

LeNet CSF SF CSF+SF
MNIST 99.14 99.20 98.31 98.40
MNIST-rot 91.84 91.76 78.63 75.49
MNIST-rand 95.11 95.34 93.33 90.83
MNIST-img 91.84 93.42 89.42 88.77
Table 1: Classification accuracy scores on the digit classification datasets, in percent. Boldface indicates the best score for each dataset.

5.2 Effect of Training Data Volume

To explore our original hypothesis that CNNs with sparse factorization layers will perform comparatively better than traditional CNNs in the face of limited supervised data, we also evaluate our layers’ performance on very small training data sets. By varying the number of training samples from 600 (1% of total training set) to 100 (0.167%), we observe how each network deals with severely limited available supervision. Each data point in Figure 3 is the mean of several trials of each method, where each trial is trained on a unique subset of the data.

The networks containing sparse factorization layers outperform the baseline on limited training data, with the accuracy gap widening as data becomes scarcer, suggesting they may be more resistant to overfitting. When supervision is most scarce (100 samples in this experiment), the SF and CSF networks outperform the LeNet network by and , respectively. Surprisingly, the SF layer outperforms both the baseline and CSF network despite underperforming them when trained on the full dataset, as shown in Table 1. This may be an artifact of our naïve network design, or an indication that the structure of the sparse factorization problem may be inherently amenable to learning in low-supervision settings.

Figure 3: Classification accuracy of the baseline LeNet, CSF, and SF networks for limited amounts of training images, averaged over several trials. Error bars indicate standard deviation.

6 Conclusions

In this paper, we have presented two novel CNN layers based on sparse representational modeling in contrast to–and in tandem with–more traditional, compositional layers. The two layers, sparse factorization and convolutional sparse factorization layers, analogous to fully-connected and convolutional layers in traditional CNNs, are similarly able to be dropped into existing networks. They are trained with end-to-end back-propagation as well, but they can also be trained with a semisupervised loss, given their origins in unsupervised learning. Our experiments clearly demonstrate potential in networks with these layers to train strong networks with limited labeled data.

Limitations and Future Work

Much remains to be explored with the SF and CSF layers. Solving an optimization problem in every forward pass is expensive compared to traditional CNN units, and our implementations typically exhibited training speeds 10 to 40 times slower than with the pure CNN (although they are implemented only on the multicore CPU and not GPU). We postulate that this can be offset by the use of pretraining; since both factorization layers are capable of producing and propagating an unsupervised loss, they (and layers prior to them) can be trained in a wholly unsupervised fashion to initialize the network parameters. The factorization layers also present unique challenges in designing the network that we hope to address in future work, such as choosing the placement, width (dictionary size), and sparsity hyperparameters for CSF and SF layers, all of which we observed have a non-negligible effect.

Acknowledgements

This work was partially support under ARO W911NF-15-1-0354.

References

  • [1] S. Abu-El-Haija, N. Kothari, J. Lee, A. P. Natsev, G. Toderici, B. Varadarajan, and S. Vijayanarasimhan. Youtube-8m: A large-scale video classification benchmark. In arXiv:1609.08675, 2016.
  • [2] L. Bo, X. Ren, and D. Fox. Hierarchical matching pursuit for image classification: Architecture and fast algorithms. In Advances in neural information processing systems, pages 2115–2123, 2011.
  • [3] Y.-l. Boureau, Y. L. Cun, et al. Sparse feature learning for deep belief networks. In Advances in neural information processing systems, pages 1185–1192, 2008.
  • [4] H. Bristow, A. Eriksson, and S. Lucey. Fast convolutional sparse coding. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 391–398, 2013.
  • [5] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A large-scale hierarchical image database. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition, 2009.
  • [6] B. Efron, T. Hastie, I. Johnstone, R. Tibshirani, et al. Least angle regression. The Annals of statistics, 32(2):407–499, 2004.
  • [7] M. Elad. Sparse and Redundant Representations. Springer, 2010.
  • [8] T. Evgeniou and M. Pontil. Regularized multi–task learning. In Proceedings of the tenth ACM SIGKDD international conference on Knowledge discovery and data mining, pages 109–117. ACM, 2004.
  • [9] X. Glorot, A. Bordes, and Y. Bengio. Deep sparse rectifier neural networks. In Aistats, volume 15, page 275, 2011.
  • [10] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.
  • [11] G. Hinton. A practical guide to training restricted boltzmann machines. Momentum, 9(1):926, 2010.
  • [12] G. E. Hinton and R. R. Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504–507, 2006.
  • [13] K. Hornik, M. Stinchcombe, and H. White. Multilayer feedforward networks are universal approximators. Neural networks, 2(5):359–366, 1989.
  • [14] J. Johnson, A. Karpathy, and L. Fei-Fei. Densecap: Fully convolutional localization networks for dense captioning. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.
  • [15] K. Kavukcuoglu, P. Sermanet, Y.-L. Boureau, K. Gregor, M. Mathieu, and Y. L. Cun. Learning convolutional feature hierarchies for visual recognition. In Advances in neural information processing systems, pages 1090–1098, 2010.
  • [16] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems, 2012.
  • [17] G. Larsson, M. Maire, and G. Shakhnarovich. Learning representations for automatic colorization. arXiv preprint arXiv:1603.06668, 2016.
  • [18] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
  • [19] Y. A. LeCun, L. Bottou, G. B. Orr, and K.-R. Müller. Efficient backprop. In Neural networks: Tricks of the trade, pages 9–48. Springer, 2012.
  • [20] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and L. Zitnick. Microsoft coco: Common objects in context. In Proceedings of European Conference on Computer Vision, 2014.
  • [21] J. Luo, W. Wang, and H. Qi. Group sparsity and geometry constrained dictionary learning for action recognition from depth maps. In Proceedings of the IEEE International Conference on Computer Vision, pages 1809–1816, 2013.
  • [22] W. Maass. Bounds for the computational power and learning complexity of analog neural nets. SIAM Journal on Computing, 26(3):708–732, 1997.
  • [23] J. Mairal, F. Bach, and J. Ponce. Task-driven dictionary learning. IEEE Transactions on Pattern Analysis and Machine Intelligence, 34(4):791–804, 2012.
  • [24] J. Mairal, F. Bach, J. Ponce, and G. Sapiro. Online learning for matrix factorization and sparse coding. Journal of Machine Learning Research, 11(Jan):19–60, 2010.
  • [25] J. Mairal, M. Elad, and G. Sapiro. Sparse representation for color image restoration. IEEE Transactions on image processing, 17(1):53–69, 2008.
  • [26] A. Makhzani and B. Frey. k-sparse autoencoders. arXiv preprint arXiv:1312.5663, 2013.
  • [27] A. Y. Ng. Feature selection, l 1 vs. l 2 regularization, and rotational invariance. In Proceedings of the twenty-first international conference on Machine learning, page 78. ACM, 2004.
  • [28] A. Nguyen, J. Yosinski, and J. Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 427–436, 2015.
  • [29] J. Oh, X. Guo, H. Lee, R. L. Lewis, and S. Singh. Action-conditional video prediction using deep networks in atari games. In Advances in Neural Information Processing Systems, 2015.
  • [30] G. B. Orr and K.-R. Müller. Neural networks: tricks of the trade. Springer, 2003.
  • [31] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
  • [32] R. Setiono. A penalty-function approach for pruning feedforward neural networks. Neural computation, 9(1):185–204, 1997.
  • [33] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations, 2015.
  • [34] N. Srivastava, G. E. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
  • [35] S. Tariyal, A. Majumdar, R. Singh, and M. Vatsa. Greedy deep dictionary learning. arXiv preprint arXiv:1602.00203, 2016.
  • [36] A. Vedaldi and K. Lenc. Matconvnet: Convolutional neural networks for matlab. In Proceedings of the 23rd ACM international conference on Multimedia, pages 689–692. ACM, 2015.
  • [37] C. Vondrick, H. Pirsiavash, and A. Torralba. Anticipating visual representations from unlabeled video. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.
  • [38] L. Wan, M. Zeiler, S. Zhang, Y. L. Cun, and R. Fergus. Regularization of neural networks using dropconnect. In Proceedings of the 30th International Conference on Machine Learning (ICML-13), pages 1058–1066, 2013.
  • [39] J. Yang, K. Yu, and T. Huang. Supervised translation-invariant sparse coding. In Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on, pages 3517–3524. IEEE, 2010.
  • [40] K. Yu, Y. Lin, and J. Lafferty. Learning image representations from the pixel level via hierarchical sparse coding. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pages 1713–1720. IEEE, 2011.
  • [41] Q. Zhang and B. Li. Discriminative k-svd for dictionary learning in face recognition. In Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on, pages 2691–2698. IEEE, 2010.
  • [42] H. Zou and T. Hastie. Regularization and variable selection via the elastic net. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 67(2):301–320, 2005.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
313679
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description