1 Introduction
Visual object recognition is a major topic in computer vision and machine learning. In the past decade, people have realized that the central problem of object recognition is to learn meaningful representations (features) of the image/videos. A large amount of focus has been put on constructing effective learning architecture that combines modern machine learning methods and in the meanwhile considers the characteristics of image data and vision problems.
In this work, we combine the power of deep learning architecture and the bagofvisualwords (BoV) pipeline to construct a new unsupervised feature learning architecture for learning image representations. Compared to the singlelayer sparse coding (SC) framework, our method can extract feature hierarchies at the different levels of abstraction. The sparse codes at the same layer keeps the spatial smoothness across image patches and different SC hierarchies also capture different spatial scopes of the representation abstraction. As a result, the method has richer representation power and hence has better performance on object recognition tasks. Compared to deep learning methods, our method benefits from effective handcrafted features, such as SIFT features, as the input. Each module of our architecture has sound explanation and can be formulated as explicit optimization problems with promising computational performance. The method shows superior performance over the stateoftheart methods in multiple experiments.
In the rest of this section, we review the technical background of the new framework, including the pipeline of using bagofvisualwords for object recognition and a lowdimensional embedding method called DRLIM.
1.1 Bagofvisualwords pipeline for object recognition
We now review the bagofvisualwords pipeline consisting of handcrafted descriptor computing, bagofvisualwords representation learning, spatial pyramid pooling and finally a classifier.
The first step of the pipeline is to exact a set of overlapped image patches from each image with fixed patch size, while the spacing between the centers of two adjacent image patches is also fixed. Then a dimensional handcrafted feature descriptor (e.g. dimensional SIFT descriptor) is computed from each image patch. Now let denote the set of feature descriptors, which are converted from overlapped image patches extracted from the th image (e.g. size ), i.e.,
where is the feature descriptor of the th patch in the th image.
Let , where , denote the set of all feature descriptors from all training images. The second step of the pipeline consists of a dictionary learning process and a bagofvisualwords representation learning process. In the case of using sparse coding to learn the bagofvisualwords representation, the two processes can be unified as the following problem.
(1)  
where denotes the dictionary of visualwords, and columns of are the learned sparse codes, and
is the parameter that controls sparsity of the code. We should note, however, other sparse encoding methods such as vector quantization and LLC could be used to learn the sparse representations (see
[6] for review and comparisons). Moreover, the dictionary learning process of finding in (1) is often conducted in an online style [14] and then the feature descriptors of the th image stored in are encoded as the bagofvisualwords representations stored in in the dimensional space (). Intuitively speaking, the components of the bagofvisualwords representation are less correlated compared to the components of dense descriptors. Therefore, compared to the dense feature descriptors, the highdimensional sparse representations are more favorable for the classification tasks.In the third stage of the pipeline, the sparse bagofvisualwords representations of all image patches from each image are pooled together to obtain a single feature vector for the image based on the histogram statistics of the visualwords. To achieve this, each image is divided into three levels of pooling regions as suggested by the spatial pyramid matching (SPM) technique [13]
. The first level of pooling region is the whole image. The second level is consist of 4 pooling regions which are 4 quadrants of the whole image. The third level consist of 16 pool regions which are quadrants of the second level pooling regions. In this way, we obtain 21 overlapped pooling regions. Then for each pooling region, a maxpooling operator is applied to all the sparse codes whose associating image patch center locates in this pooling region, and we obtain a single feature vector as the result. The maxpooling operator maps any number of vectors that have the same dimensionality to a single vector, whose components are the maximum value of the corresponding components in the mapped vectors. Formally, given the descriptors
that are in the same pooling region, we calculate(2) 
where max is operated componentwisely. From the second stage of the framework, we know that the nonzero elements in a sparse code imply the appearance of corresponding visualwords in the image patch. Therefore, the maxpooling operator is actually equivalent to calculating the histogram statistics of the visualwords in a pooling region. Finally, the pooled bagofvisualwords representations from 21 pooling regions are concatenated to obtain a single feature vector, which is regarded as the representation for the image and linear SVM is then used for training and testing on top of this representation. Since the labels of the training images are not used until the final training of SVM, the whole pipeline is regarded as an unsupervised method. For the rest of this paper, we focus on the version of the pipeline where the feature (bagofvisualwords representation) learning part is performed by a sparse coding step as in (1).
1.2 Dimensionality reduction by learning an invariant mapping
We now review a method called dimensionality reduction by learning an invariant mapping (DRLIM, see [12]), which is the base model for our new method in Subsection 2.3. Different from traditional unsupervised dimensionality reduction methods, DRLIM relies not only on a set of training instances , but also on a set of binary labels , where is the set of index pairs such that if the label for the corresponding instance pair is available. The binary label if the pair of training instances and are similar instances, and if and are known to be dissimilar. Notice that the similarity indicated by is usually from extra resource instead of the knowledge that can be learned from data instances directly. DRLIM learns a parametric mapping
such that the embeddings of similar instances attract each other in the lowdimensional space while the embeddings of dissimilar instances push each other away in the lowdimensional space. In this spirit, the exact loss function of DRLIM is as follows:
(3)  
where is the parameter for the contrastive loss term which decides the extent to which we want to push the dissimilar pairs apart. Since the parametric mapping is assumed to be decided by some parameter. DRLIM learn the mapping by minimizing the loss function in (3) with respect to the parameters of . The mapping A could be either linear or nonlinear. For example, we can assume
is a twolayer fully connected neural network and then minimize the loss function (
3) with respect to the weight. Finally, for any new data instance , its lowdimensional embedding is represented by without knowing its relationship to the training instances.2 Deep sparse learning framework
2.1 Overview
Recent progress in deep learning [2]
has shown that the multilayer architecture of deep learning system, such as that of deep belief networks, is helpful for learning feature hierarchies from data, where different layers of feature extractors are able to learn feature representations of different scopes. This results in more effective representations of data and benefits a lot of further tasks. The rich representation power of deep learning methods motivate us to combine deep learning with the bagofvisualwords pipeline to achieve better performance on object recognition tasks. In this section, we introduce a new learning framework, named as deep sparse coding (DeepSC), which is built of multiple layers of sparse coding.
Before we introduce the details of the DeepSC framework, we first identify two difficulties in designing such a multilayer sparse coding architecture.

First of all, to build the feature hierarchies from bottomlevel features, it is important to take advantage of the spatial information of image patches such that a higherlevel feature is a composition of lowerlevel features. However, this issue is hardly addressed by simply stacking sparse encoders.

Second, it is wellknown (see [16, 10]) that sparse coding is not “smooth”, which means a small variation in the original space might lead to a huge difference in the code space. For instance, if two overlapped image patches have similar SIFT descriptors, their corresponding sparse codes can be very different. If another sparse encoder were applied to the two sparse codes, they would lost the affinity which was available in the SIFT descriptor stage. Therefore, stacking sparse encoders would only make the dimensionality of the feature higher and higher without gaining new informations.
Based on the two observations above, we propose the deep sparse coding (DeepSC) framework as follows. The first layer of DeepSC framework is exactly the same as the bagofvisualwords pipeline introduced in Subsection 1.1. Then in each of the following layer of the framework, there is a sparsetodense module which converts the sparse codes obtained from the last layer to dense codes, which is then followed by a sparse coding module. The output sparse code of the sparse coding module is the input of the next layer. Furthermore, the spatial pyramid pooling step is conducted at every layer such that the sparse codes of current layer are converted to a single feature vector for that layer. Finally, we concatenate the feature vectors from all layers as the input to the classifier. We summarize the DeepSC framework in Figure 2. It is important to emphasis that the whole framework is unsupervised until the final classifier.
The sparsetodense module is the key innovation of the DeepSC framework, where a “pooling function” is proposed to tackle the aforementioned two concerns. The pooling function is the composition of a local spatial pooling step and a lowdimensional embedding step, which are introduced in Subsection 2.2 and Subsection 2.3 respectively. On one hand, the local spatial pooling step ensures the higherlevel features are learned from a collection of nearby lowerlevel features and hence exhibit larger scopes. On the other hand, the lowdimensional embedding process is designed to take into account the spatial affinities between neighboring image patches such that the spatial smoothness information is not lost during the dimension reduction process. As the combination of the two steps, the pooling function fills the gaps between the sparse coding modules, such that the power of sparse coding and spatial pyramid pooling can be fully expressed in a multilayer fashion.
2.2 Learning the pooling function
In this subsection, we introduce the details of designing the local spatial pooling step, which performs as the first part of the pooling function. First of all, we define the pooling function as a map from a set of sparse codes on a sampling grid to a set of dense codes on a new sampling grid. Assume that is the sampling grid that includes sampling points on a image, where the any two adjacent sampling points have fixed spacing (number of pixels) between them. As introduced in Subsection 1.1, each sampling point corresponds to the center of a image patch. Let be the sparse codes on the sampling grid , where each is associated with a sampling point on according to its associated image patch. Mathematically, the pooling function is defined as the map:
where is the new sampling grid with sampling points and stores the dimensional dense codes ( ^{1}^{1}1For simplicity, we let be the same as the dimensionality of SIFT features.) associated with the sampling points on the new sampling grid .
As the feature representations learned in the new layer are expected have larger scope than those in the previous layer, we enforce each of the sampling points on new grid to cover a larger area in the image. To achieve this, we take the center of neighboring sampling points in and let it be the new sampling points in . By taking the center of every other neighboring sampling points, the spacing between neighboring sampling points in is twice of that in . As a result, we map to a coarser grid such that (see Figure 3).
Once the new sampling grid is determined, we finish the local spatial pooling step by applying the maxpooling operator (defined in (2)) to the subsets of sparse codes and obtain pooled sparse codes associated with the new sampling grid . More specifically, let denote the pooled sparse codes associated with the th sampling point in , where . We have
(4) 
where are the indices of the sampling points in that are most close to the th sampling point in .
2.3 Dimensionality reduction with spatial information
In this subsection, we introduce the details of combining the DRLIM method [12] with the spatial information of image patches to learn a lowdimensional embedding such that
(5) 
As the feature vector is transformed by to lowerdimensional space, part of its information is discarded while some is preserved. As introduced in Subsection 1.2, DRLIM is trained on a collection of data instance pairs , each of which is associated with a binary label indicating their relationship. Therefore, it provides the option to incorporate prior knowledge in the dimensionality reduction process by determining the binary labels of training pairs based on the prior knowledge.
In the case of object recognition, the prior knowledge that we want to impose on the system is that if a image patch is shifted by a few pixels, it still contains the same object. Therefore, we constructed the collection of training pairs for DRLIM as follows. We extract training pairs such that there always exist overlapped pixels between the two corresponding patches. Let and be the pooled sparse codes corresponding to two image patches that have overlapped pixels and be the distance (in terms of pixels) between them, which is calculated based on the coordinate of the image patch centers. Given a thresholding , we set
(6) 
Generated this way, indicates the two image patches are mostly overlapped, while indicates that the two image patch are only partially overlapped. This process of generating training pairs ensures that the training of the transformation is focused on the most difficult pairs. Experiments shows that if we instead take the pooled sparse codes of farapart image patches as the negative pairs (), DRLIM suffers downgrading in performance. The sensitivity of the system to the thresholding parameter is demonstrated in Table 7.
Let the linear transformation
be defined by the transformation matrix such thatand then the loss function with respect to the pair is
(7)  
Let be the set of index pairs for training pairs collected from all training images, is then obtained by minimizing the loss with respect to all training pairs, i.e., solving
3 Experiments
In this section, we evaluate the performance of DeepSC framework for image classification on three data sets: Caltech101 [7] , Caltech256 [11] and 15Scene. Caltech101 data set contains images belonging to classes, with about to images per class. Most images of Caltech101 are with medium resolution, i.e., about . Caltech256 data set contains images from 256 categories. The collection has higher intraclass variability and object location variability than Caltech101. The images are of similar size to Caltech101. 15Scene data set is compiled by several researchers [8, 13, 15], contains a total of 4485 images falling into 15 categories, with the number of images per category ranging from 200 to 400. The categories include living room, bedroom, kitchen, highway, mountain, street and et al.
For each data set, the average perclass recognition accuracy is reported. Each reported number is the average of 10 repeated evaluations with random selected training and testing images. For each image, following [4], we sample image patches with 4pixel spacing and use dimensional SIFT feature as the basic dense feature descriptors. The final step of classification is performed using onevsall SVM through LibSVM toolkit [5]. The parameters of DRLIM and the parameter to control sparsity in the sparse coding are selected layer by layer through crossvalidation. In the following, we present a comprehensive set of experimental results, and discuss the influence of each of the parameters independently. In the rest of this paper, DeepSC2 indicates twolayer DeepSC system; DeepSC3 represents threelayer DeepSC system, and SPMSC means the one layer baseline, i.e. the BoV pipeline with sparse coding plus spatial pyramid pooling.
3.1 Effects of Number of DeepSC Layers
As shown in Figure 2, the DeepSC framework utilizes multiplelayers of feature abstraction to get a better representation for images. Here we first check the effect of varying the number of layers utilized in our framework. Table 1 shows the average perclass recognition accuracy on three data sets when all using 1024 as dictionary size. The number of training images per class for the three data sets is set as for Caltech101, for Caltech256, and for 15Scene respectively. The second row shows the results when we have only one layer of the sparse coding, while the third row and the fourth row describe the results when we have two layers in DeepSC or three layers in DeepSC. Clearly the multilayer structured DeepSC framework has superior performance on all three data sets compared to the singlelayer SPMSC system. Moreover, the classification accuracy improves as the number of layers increases.
Caltech101  Caltech256  15Scene  

SPMSC  
DeepSC2  
DeepSC3 
3.2 Effects of SC Dictionary Size
We examine how performance of the proposed DeepSC framework changes when varying the dictionary size of the sparse coding. On each of the three data sets, we consider three settings where the dimension of the sparse codes is and . The number of training images per class for these experiments is set as for Caltech101, for Caltech256, and for 15Scene respectively. We report the results for the three data sets in Table 2, Table 3 and Table 4 respectively. Clearly, when increasing the dictionary size of sparse coding from 1024 to 4096, the accuracy of the system improves for all three data sets. We can observe that the performance of DeepSC is always improved with more layers, while in the case of
the performance boost in term of accuracy is not so significant. This probably is due to that the parameter space in this case is already very large for the limited training data size. Another observation we made from Table
2, Table 3 and Table 4 is that DeepSC2 (K=1024) always performs better than SPMSC (K=2048), and DeepSC2 (K=2048) always performs better than SPMSC (K=4096). These two comparisons demonstrate that simply increasing the dimension of sparse codes doesn’t give the same performance boost as increasing the number of layers, and therefore DeepSC framework indeed benefits from the feature hierarchies learned from the image.Caltech101  

SPMSC  
DeepSC2  
DeepSC3 
Caltech256  

SPMSC  
DeepSC2  
DeepSC3 
15Scene  

SPMSC  
DeepSC2  
DeepSC3 
3.3 Effects of Varying Training Set Size
Furthermore, we check the performance change when varying the number of training images per class on two Caltech data sets. Here we fix the dimension of the sparse codes as 2048. On Caltech101, we compare two cases: randomly select or images per category respectively as training images and test on the rest. On Caltech256, we randomly select , and images per category respectively as training images and test on the rest. Table 5 and Table 6 show that with the smaller set of training images, DeepSC framework still continues to improve the accuracy with more layers.
Caltech101  

SPMSC  
DeepSC2  
DeepSC3 
Caltech256  

SPMSC  
DeepSC2  
DeepSC3 
3.4 Effects of varying parameters of DRLIM
In table 7, we report the performance variations when tuning the parameters for DRLIM. The parameter is the threshold for selecting positive and negative training pairs (see (6)) and the parameter in the hinge loss (see (7)) of DRLIM model is for controlling penalization for negative pairs. We can see that it is important to choose the proper thresholding parameter such that the transformation learned by DRLIM can differentiate mostly overlapped image pairs and partially overlapped image pairs.
1  2  3  4  5  6  

8  76.5  77.41  77.07  76.71  76.24  75.81 
16  74.93  76.55  76.87  76.97  76.43  75.83 
24  73.95  75.43  76.18  76.42  76.53  76.45 
3.5 Comparison with other methods
We then compare our results with other algorithms in Table 8. The most direct baselines ^{2}^{2}2We are also aware of that some works achieve very high accuracy based on adaptive pooling step [9] or multiplepath system that utilizes image patches of multiple sizes [3]. for DeepSC to compare are the sparse coding plus SPM framework (ScSPM) [17], LLC[16], and SSC[1]. Table 8 shows the comparison of our DeepSC versus the ScSPM and SSC. We can see that our results are comparable to SSC, with a bit lower accuracy on the 15Scene data (the std of SSC is much higher than ours). For the LLC method proposed from [16], it reported to achieve 73.44% for Caltech101 when using and 47.68% when using . Our DeepSC3 has achieved 78.43% for Caltech101 when using and 49.91% when using . Overall our system achieves the stateoftheart performance on all the three data sets.
References
 [1] K. Balasubramanian, K. Yu, and G. Lebanon. Smooth sparse coding via marginal regression for learning sparse representations. In ICML, 2013.
 [2] Y. Bengio, A. Courville, and P. Vincent. Representation learning: A review and new perspectives. arXiv preprint arXiv:1206.5538, 2012.
 [3] L. Bo, X. Ren, and D. Fox. Multipath sparse coding using hierarchical matching pursuit. CVPR, 2013.
 [4] Y.L. Boureau, F. Bach, Y. LeCun, and J. Ponce. Learning midlevel features for recognition. In CVPR, pages 2559–2566. IEEE, 2010.

[5]
C.C. Chang and C.J. Lin.
Libsvm: a library for support vector machines.
ACM Transactions on Intelligent Systems and Technology (TIST), 2(3):27, 2011.  [6] A. Coates and A. Y. Ng. The importance of encoding versus training with sparse coding and vector quantization. In ICML, volume 8, page 10, 2011.
 [7] L. FeiFei, R. Fergus, and P. Perona. Learning generative visual models from few training examples: an incremental bayesian approach tested on 101 object categories. In CVPR, Workshop on GenerativeModel Based Vision., 2004.
 [8] L. FeiFei and P. Perona. A bayesian hierarchical model for learning natural scene categories. In CVPR, 2005.
 [9] J. Feng, B. Ni, Q. Tian, and S. Yan. Geometric ℓ pnorm feature pooling for image classification. In CVPR, pages 2609–2704. IEEE, 2011.
 [10] S. Gao, I. W. Tsang, L.T. Chia, and P. Zhao. Local features are not lonely–laplacian sparse coding for image classification. In CVPR, pages 3555–3561. IEEE, 2010.
 [11] G. Griffin, A. Holub, and P. Perona. Caltech256 object category dataset. 2007.
 [12] R. Hadsell, S. Chopra, and Y. LeCun. Dimensionality reduction by learning an invariant mapping. In CVPR, volume 2, pages 1735–1742. IEEE, 2006.
 [13] S. Lazebnik, C. Schmid, and J. Ponce. Beyond bags of features: Spatial pyramid matching for recognizing natural scene categories. In CVPR, volume 2, pages 2169–2178. IEEE, 2006.
 [14] J. Mairal, F. Bach, J. Ponce, and G. Sapiro. Online dictionary learning for sparse coding. In Proceedings of the 26th Annual International Conference on Machine Learning, pages 689–696. ACM, 2009.
 [15] A. Oliva and A. Torraba. Modeling the shape of the scene: A holistic representation of the spatial envelop. In IJCV, 2001.
 [16] J. Wang, J. Yang, K. Yu, F. Lv, T. Huang, and Y. Gong. Localityconstrained linear coding for image classification. In CVPR, pages 3360–3367. IEEE, 2010.
 [17] J. Yang, K. Yu, Y. Gong, and T. Huang. Linear spatial pyramid matching using sparse coding for image classification. In CVPR, pages 1794–1801. IEEE, 2009.
Comments
There are no comments yet.