, can achieve state-of-the-art performance in many visual classification, retrieval and recognition tasks. Although these very high-dimensional representations lead to better results, with the emergence of massive-scale datasets, e.g., ImageNet with around 15M images, the computational and storage costs of these long data have become very expensive and even unfeasible. For instance, if we represent 15M samples using 51200-dimensional FVs, the storage requirement of these data is approximately 5.6TB and it will need about
arithmetic operations measuring the Euclidean distance for image retrieval on these data. Considering the trade-off between computational efficiency and performance, it is desirable to embed the high-dimensional data into a reduced feature space. However, traditional dimensionality reduction methods such as PCA
are not suitable for large-scale/high-dimensional cases. The main reasons are: (1) Most dimensionality reduction methods are based on full-matrix linear projections, which need massive computational complexity and memory storage in high-dimensional reduction circumstances; (2) The reduced representations are usually real-valued vectors. When both dimensionality and the number of samples are large, real-valued codes severely limit the efficiency for retrieval and classification tasks compared with the binary codes. Thus, recent binarization approaches[7, 8, 25, 26, 34, 19, 14, 3, 2, 36, 23, 27, 6, 17] have been proposed to embed the original data into binary codes with a reduced dimension. The codes generated by these methods can be roughly divided into two groups, i.e., the short binary codes and the long binary codes.
Hashing short codes: Most hashing-based approaches designed for fast searching always embed relatively low-dimensional representations like GIST  into short binary codes (usually under 500 bits) without too much loss of information. However, recent sophisticated and state-of-the-art representations are always over ten thousand dimensions. Therefore, these hashing methods become not so effective and appropriate for the embedding of very high-dimensional data, since they cannot preserve the sufficient discriminative properties to maintain high performance if the length of the obtained binary codes is short according to [23, 27]. Although some of hashing methods can theoretically generate long binary codes for high-dimensional data, the enormous computational load and memory usage make them unpractical. For instance, one of the state-of-the-art hashing methods, Iterative Quantization (ITQ) , leads to unacceptable loss of retrieval accuracy compared with long codes over 1000 bits, meanwhile its computational cost becomes extremely high when the number of bits increases as shown in Fig. 1(a). Long binary codes: Opposite to hashing short codes, a few methods [6, 36] have been specially introduced to convert the high-dimensional data to long binary codes. Among them, one representative binary coding method is Bilinear Projection-based Binary Codes (BPBC) , which can learn two rotate matrices for efficient binary coding. However, to minimize the loss of accuracies and achieve state-of-the-art performance, the left of Fig. 1(a) shows the length of binary codes generated by BPBC have to be long enough (i.e., over 10000 bits). Such long binary codes are still not fast enough for large-scale applications. Thus, how to learn medium-length binary codes (i.e., between 1000 bits and 10000 bits) and still maintain the high accuracies becomes a challenging research topic.
Many existing binary code learning methods are based on a single linear projection matrix (e.g., random projection) to map the data from the high-dimensional space to a reduced space. No matter the training or the coding phase, the storage requirement for the single linear projection matrix remains a burden. Taking ITQ (PCA is involved as its first step) for an example, to reduce the 170400-dimensional FVs to 10000-dimension, the size of the given single projection matrix should be about 12.7GB and the number of multiplications for coding a new data sample is . Apparently, this kind of memory requirements and coding complexity of the linear projection is unrealistic for large-scale applications. To alleviate this weakness, a bilinear projection method  has been proposed to effectively reduce the complexity of code learning compared with the linear one. The middle and right of Fig. 1(a) illustrate the memory usage and multiplications of coding respectively for the linear projection based ITQ and the bilinear projection based BPBC. Although the size of the projection matrix for the bilinear method is dramatically reduced, the coding complexity is still relatively high, especially when the dimensionality of original data goes high. Therefore, our target is to further reduce the coding complexity and produce medium-length codes without sacrificing the accuracy.
In this paper, we propose a novel binarization method for high-dimensional data. The proposed method first de-aggregates the original very high-dimensional representations into several groups of short representations according to their intrinsic data properties along the dimensions. After that, for each group of short representations, a small projection will be learned via the max-margin constraint to optimally preserve the data similarity. We denote our method as Binary Projection Bank (BPB), since a bank of small projections will be finally generated in our method instead of learning conventional linear or bilinear projections as illustrated in Fig. 1(b). The contributions of this paper include: (1) We propose a medium-length binary code learning method, which outperforms state-of-the-art linear and bilinear methods; (2) In spite of the reduced code length, our method only requires low and constant memory usage and coding complexity; (3) A kernelized version (KBPB) has also been proposed for better performance.
2 Related Work
There are a few works specifically focusing on high-dimensional data reduction. One of popular methods is Product Quantization (PQ) 
. Prior to PQ, however, a random rotation is always needed to balance the variance of high-dimensional data according to. As we discussed before, such rotation requires high computational complexity. Recently, an efficient high-dimensional reduction method based on feature merging [5, 9, 16], termed Pseudo-supervised Kernel Alignment (PKA) , has achieved good performance but with cheaper computation. Besides, aiming for large-scale tasks, some binary reduction techniques for high-dimensional data have also been introduced. Perronnin et al.  proposed the “” binarization scheme and compared with Locality Sensitive Hashing (LSH)  and Spectral Hashing (SpH)  on the compressed FVs. Hashing Kernel (HK)  is utilized for high-dimensional signature compression as well in . Most recently, the Bilinear Projection-based Binary Codes (BPBC)  is proposed to achieve more efficient binary coding. However, experiments in [23, 27, 6] manifest these methods require very long codes to yield acceptable performance.
3 Binary Projection Bank
3.1 Notation and Motivation
We are given training data in a -dimensional space: . The goal of this paper is to generate binary codes for each data point, for which the similarity and structure in the original data is preserved.
Traditional algorithms take -dimensional data as input and use a single projection to form the linear prediction function . Actually it can be regarded that projection matrix consists of
linear classifiers (binary output:) over the original feature space. However, for realistic high-dimensional data with noise and redundancy of dimension, learning single projections across the entire high-dimensional feature space is unwise and costs very high computational complexity. To tackle this problem, we aim to split the original high-dimensional feature space into subspaces by merging the similar dimensions together similar to . In this way, linear classifiers (i.e., projection vectors) will be explored since a subspace spanned by the dimensions with the similar property should only require one linear classifier. Hence, for each of subspace, only one small projection vector will be learned in our architecture. Table 1 summarizes the resource requirements for different projection schemes.
In this paper, we propose a Binary Projection Bank (BPB) algorithm. To effectively decompose the original data space into subspaces, we first employ a K-means clustering scheme along dimensions. Particularly, we takeas K-means input, which is the rows of matrix , and divide them into clusters consisting of as illustrated:
As mentioned in , the decomposition via K-means can successfully preserve the intrinsic data structure and simultaneously group the dimension with the similar property together. We denote the number of the dimensions in the -th cluster by , where . Then the subspace spanned by the dimensions in the -th cluster is . In each subspace, a linear classifier is learned to generate one bit for the data. Hence, and is the reduced dimension. In the following, we give the detailed formulations and learning steps of BPB.
3.2 Formulation of BPB
To preserve the data similarity, we first construct a pseudo label for each data pair according to their k-nearest neighbors in original data space as follows:
where is the set of k-nearest neighbors of . Besides, we also define for . In BPB learning phase, our goal is to minimize the distances of positive pairs and maximize the distances of the negative pairs in each subspace generated by K-means clustering.
For the -th subspace, we use
to represent the data in this subspace. We tactfully transfer learning projections to learning linear classifiers via pair-wise labels generated from unlabeled data. By adopting linear classifier
similar to the SVM framework, positive pairs are positioned in the same side of the hyperplane while negative pairs are expected to be placed at different sides of the hyperplane.
In fact, we can denote , then the classifier becomes . Therefore, it is equivalent to the linear classifier without the bias . In the following computation, we omit and the binary code for each data in the -th subspace can be acquired as follows:
where is the coefficient of the classifier for the -th subspace. With the above requirement and the maximum margin criterion for the positive and negative pairs, we have the following optimization problem:
where is for the margin regularization. It is noticeable that if , the constraint becomes , which strictly constrains that every point is out of the margin. Using the hinge loss term, we can rewrite the optimization problem in (4) as the following objective function:
where is the balance parameter to control the importance of the two terms. Since we cannot directly obtain the optimal in our objective function, a gradient descent scheme has to be applied here. Let us denote
Taking the derivative of with respect to , we can easily obtain the gradient of :
Therefore, we utilize the gradient descent method and have the following update rule to optimize :
where is the step length.
We repeat the optimization problem in (4) for all the subspaces and concatenate the binary bits together to form the final binary code. The final binary code for high-dimensional data can be illustrated as:
Adaptive gradient descent (AGD):
Furthermore, for fast convergence, we also associate the optimization procedure with an adaptive step length. We first initialize . For the -th iteration, if , we enlarge the step length in the next iteration to accelerate the convergence, otherwise, we decrease to its half size: . In the experiments, we also set an upper bound for the number of iteration for the gradient descent. Thus, we stop the iteration when the number of iteration reaches a maximum or the difference is less than a small threshold.
Average pairwise error of subspaces vs. pairwise error of uncompressed data:
We also analyze the empirical error rate of pairwise data in the projected space. Suppose is the solution of minimizing in Eq.(5) acquired by AGD for the -th subspace, . Then the average error rate on pair-wise data for all the subspaces is defined as , where represents the cardinality of the set. On the other hand, we also compute the solution of minimizing , for the original -dimensional data . Finally, we compare with the error rate in Fig. 2. It is observed that is lower than at the medium code length (under 10000 bits), which indicates that the data distribution in subspaces has much better separability than the one in the original space. However, when , the number of dimensions in each subspace will shrink to a very small value. In this case, data in subspaces are difficult to be linearly separated by classifiers for the current BPB. Thus, we will extend BPB to the version with non-linear kernels for better performance.
3.3 Kernel BPB
In this section, we introduce our algorithm with kernel functions, i.e., kernel BPB (KBPB), since the kernel method can theoretically and empirically be able to solve the linear inseparability problem mentioned in above. Although the kernel method would cost high computational complexity for high-dimensional data, in our method, the kernel function will only be performed in small subspaces which are spanned by the dimensions in each cluster.
In the -th subspace, suppose data are mapped to a Hilbert space by a mapping function and the kernel function is the inner product function in the Hilbert space. As defined in the Kernelized Locality-Sensitive Hashing (KLSH)  and Kernel-Based Supervised Hashing (KSH) , we uniformly select samples from the training data (we call them basis samples) to reduce the coding complexity of the kernel trick from to (the effect on selection of will be discussed in experiments). Then we establish the prediction function with the kernel as follows (without loss of generality, suppose the choices of basis samples are the first samples for all the subspaces):
where , are the coefficients and is the bias. It is actually the linear classifier for the data in the Hilbert space. The binary codes with sufficient information should be zero-centered [18, 12, 7], which renders that . To satisfy this condition, we set . Introducing in Eq. (10), the prediction function becomes:
where , . It is easy to observe that is the coefficient vector of the hyperplane for the data in the Hilbert space. With the similar constraints, we have the following optimization problem for KBPB:
where . Naturally, the corresponding objective function will be:
where is the balance parameter as in BPB. Let us denote and Then their derivatives with respect to can be computed as:
where and , Similar to BPB, if , we can set , where is a small nonzero random vector. Therefore, we have the update rule for KBPB as follows:
where is the step length, which is also adaptively tuned by AGD.
Finally, having calculated the coefficients of the kernelized prediction function for all the subspaces, the binary codes for the original data can be expressed as:
4.1 Large-scale image retrieval
The proposed BPB and KBPB algorithms are first evaluated for the image similarity search task. Two realistic large-scale image datasets are used in our experiments: Flickr 1M and ILSVR2010. For Flickr 1M, we downloaded close to one million web images with 55 groups from Flickr inspired by [30, 27]. For each image in Flickr 1M, we extract -d SIFT features in patches of around interest points detected by . The ILSVR2010111http://www.imagenet.org/challenges/LSVRC/2010/index dataset is a subset of the ImageNet  dataset and contains 1.2 million images from categories. The publicly available dense -d SIFT features  are used.
We represent each image in both datasets using two high-dimensional representations: Fisher Vector (FV) and VLAD. In respect to FV, the Gaussian Mixture Model is implemented on SIFT features withGaussians for both datasets. In this way, the dimension of the final FV for each image is . While, for VLAD representations, the K-means clustering has been used to cluster the SIFT features into centers and aggregate them into VLAD vectors of dimensions. These VLAD vectors are also power and normalized . In terms of both datasets, we randomly select images as the query and the remaining images are regarded as the gallery database. For evaluation, we first report the semantic precision at and retrieved images (according to the ground-truth) for both Flickr 1M and ILSVR2010, and then the precision-recall curves are illustrated as well. Additionally, we report the size of projection storage and the coding time (the average time used for each data) for some state-of-the-art methods. Our experiments are completed using Matlab 2014a on a server configured with a 6-core processor and 64GB of RAM running the Linux OS.
Compared methods and settings:
In our experiments, we compare the proposed method with nine coding methods including four real-valued dimensionality reduction methods: Principal Component Analysis (PCA), the projection via Gaussian random rotation (RR), Product Quantization (PQ) and Pseudo-supervised Kernel Alignment (PKA) , and five binary coding methods: the sign function binarization, “” binarization , Locality Sensitive Hashing (LSH) , Spectral Hashing (SpH) , Bilinear Projection-based Binary Codes (BPBC)  and Circulant Binary Embedding (CBE) . We use the publicly available codes of LSH, SpH, PQ , CBE and PCA, and implement RR, PKA and BPBC ourselves. Additionally, two natural baselines: randomly sampling the dimensions to form subspaces without replacement (RandST+BPB) and learning multiple bits with ITQ in each subspace (Kmeans+ITQ) are also included in our experiments. All of the above methods are then evaluated for compressing FV and VLAD representations into three different medium-lengthed codes: . Considering the feasibility on the training phase of all the methods, in this experiment, 150K data are randomly selected from the gallery database of Flickr 1M and ILSVR2010 respectively to form the training set. Besides, we also randomly choose another 50K data samples from each of the datasets as a cross-validation set for parameter tuning. Under the same experimental setting, all the parameters used in the compared methods have been strictly chosen according to their original papers.
For the proposed BPB/KBPB, the pairwise label of each data pair is determined by their nearest neighbors. The balance parameter for each dataset is selected from one of the values in the range of , which yields the best performance on the cross-validation set. The maximum number of the iteration of AGD is fixed at , which has been proved to converge well for the objective function. For KBPB, we adopt as the number of basis samples for both Flickr 1M and ILSVR2010. We use the polynomial kernel and the RBF kernel to implement KBPB and KBPB, respectively. The best value of for KBPB is selected via cross-validation and the value of for KBPB is determined adaptively based on the method in . In fact, any kernel function satisfying the Mercer’s condition can be used in KBPB. In BPB/KBPB, since the coding procedure in each subspace is independent, we implement the parallel computation scheme to speed up the training time. Considering the uncertainty of the K-means clustering, all the reported results by our methods are the averages of 50 runs.
|Methods||Fisher Vector (64000-d)||VLAD (32000-d)|
|Precision@top 50||Precision@top 100||Precision@top 50||Precision@top 100|
|8000 bit||6400 bit||4000 bit||8000 bit||6400 bit||4000 bit||4000 bit||3200 bit||2000 bit||4000 bit||3200 bit||2000 bit|
The “Original” indicates uncompressed FV/VLAD. The “Sign” refers to directly using the sign function on original vectors. “”  scheme is specifically designed for FV and the dimension of reduced codes via “” is fixed at =. KBPB indicates KBPB with the polynomial kernel and KBPB indicates KBPB with the RBF kernel. The results of BPB and KBPB are mean accuracies of 50 runs. For Original, PCA, PKA and RR, the Euclidean distance is used to measure the retrieval. For RR+PQ, the asymmetric distance (ASD)  is adopted and Hamming distance is used for the rest of compared methods. Kmeans+ITQ(20bits) indicates using Kmeans to split the dimensions into subspaces and then apply ITQ to learning 20 bits codes for each subspace. RandST+BPB denotes randomly split the dimensions into subspaces without replacement and adopt BPB optimization scheme to learn codes.
|Methods||Fisher Vector (64000-d)||VLAD (32000-d)|
|Precision@top 50||Precision@top 100||Precision@top 50||Precision@top 100|
|8000 bit||6400 bit||4000 bit||8000 bit||6400 bit||4000 bit||4000 bit||3200 bit||2000 bit||4000 bit||3200 bit||2000 bit|
We list the retrieval results comparison of different methods at top 50 and 100 retrieval results on the Flickr 1M and ILSVR2010 datasets in Table 2 and Table 3, respectively. Generally, FV gains slightly better results than VLAD on both datasets. Meanwhile, the accuracies on the ILSVR2010 dataset are lower than those on the Flickr 1M dataset, since there are more categories and larger intra-class variations in ILSVR2010. It is noticeable that PQ achieves the low precision on Flickr 1M, while RR+PQ can lead to more reasonable results. The reason is that for high-dimensional representations, there may exist unbalanced variance that influences the performance. Thus, randomly rotating the high-dimensional data prior to PQ222In , PQ can achieve competitive results without random rotation. However, they focus on relatively low-dimensional SIFT/GIST features whose variance already tends to be roughly balanced. is recommended in . Nevertheless, due to that the images in ILSVR2010 are textured with the dominant object which leads to relatively balanced variance, the basic PQ can achieve modest results on ILSVR2010. PCA and PKA have remarkable accuracies as real-valued compression techniques on both datasets and CBE is regarded as the strongest baseline of binary coding methods according to its performance. LSH, SpH and the “” scheme can obtain similar results on both datasets and using sign function directly on uncompressed FV/VLAD is proved to be the worst binarization method. Additionally, Kmeans+ITQ(20bits) can achieve slightly better performance than RandST+BPB, but both significantly lower than BPB.
From Table 2 and Table 3, our BPB algorithm consistently outperforms all the compared methods at every code length and leads to competitive accuracies with CBE and original FV/VLAD. Moreover, KBPB can achieve better performance than BPB since the kernel method can theoretically and empirically solve the problem of linear inseparability of subspaces with relatively lower dimensions (average dimension of each subspace is ). Thus, KBPB gives significantly better performance when is large, i.e., on relatively long binary codes. The best performance on both datasets has been achieved by KBPB with the RBF kernel. Especially, when the code length decreases, the retrieval accuracies from all compared methods (expect SpH) dramatically drop, but the accuracies of our methods only slightly change showing the robustness of the proposed methods on medium-dimensional binary coding. Currently, we use hard-assignment K-means for our work. In Fig. 3, we have also evaluated the possibility to use soft-assignment clustering for our methods. The results illustrate that for the medium-dimensional codes (i.e., between 1000 bits and 10000 bits), soft-assignment clustering based BPB and RBF-KBPB can achieve competitive results with hard-assignment BPB and KBPB. However, in the extreme condition (i.e., code dimfeature dim), the soft-clustering based methods can still produce the reasonable results without lossing much of accuracy, while the current hard-clustering methods fail, since the feature dimensions can be re-used during soft-clustering. Thus, from Fig. 3, Table 2 and Table 3, we can observe our current version of projection bank can indeed achieve better performance for the medium-dimensional codes compared with other methods. Besides, Fig. 4 presents the precision-recall curves of all compared methods on both datasets with 8000 bits for FV and 4000 bits for VLAD, respectively. From all these figures, we can further discover that, for both datasets, BPB/KBPB outperform other high-dimensional compression methods with the medium-lengthed codes by comparing the retrieval precision and the Area Under the Curve (AUC).
The training and coding time in this table are both 50-run averaged runtime. Parallel computation is adopted to speed up our training phase.
|(a) Flickr 1M (FV)||(b) Flickr 1M (VLAD)||(c) ILSVR2010 (FV)||(d) ILSVR2010 (VLAD)|
|(a) Flickr 1M (FV)||(b) Flickr 1M (FV)||(c) ILSVR2010 (VLAD)||(d) ILSVR2010 (VLAD)|
Complexity and parameter sensitivity analysis:
Table 4 illustrates the comparison of the memory usage for projections, the training time and the coding time on ILSVR2010. RR+PQ costs the largest memory space and more time for coding since the full-matrix projection (i.e., RR) is involved. Compared with RR+PQ, BPBC and CBE need much lower memory costs and time complexity for training and coding. Our BPB is slightly time-consuming than CBE in the training phase but the most efficient one for coding. Meanwhile, KBPB costs more memory space than BPBC and BPB but is still more efficient for coding than BPBC. In addition, Fig. 5 reports the effect of performance by varying two essential parameters and . In terms of the number of basis samples used in KBPB with the RBF kernel, when , the retrieval accuracy curves become approximately stable on both datasets with FV and VLAD, respectively. It indicates that our KBPB can lead to relatively robust results with . As we can see, for balance parameter , our methods (both BPB and KBPB) can achieve the good performance when and on Flick 1M and ILSVR2010, respectively.
4.2 Large-scale action recognition
Finally, we evaluate our methods for action recognition on the UCF101 dataset  which contains 13320 videos from 101 action categories. We strictly follow the 3-split train/test setting in  and report the average accuracies as the overall results. The 426-dimensional default Dense Trajectory Features (DTF)  are extracted from each video, and GMM and K-means are used to cluster them into 200 visual words for FV and VLAD respectively. Thus, the length of FV is and the length of VLAD is . For our methods, we fix and , which are both selected via cross-validation set, and other parameters are the same as the previous retrieval experiments. In this experiment, we apply the linear SVM333According to [27, 6], hashing kernel [28, 33] renders to an unbiased estimation of the dot-product in the original space. Thus, binary codes can also be directly fed into a linear SVM.
renders to an unbiased estimation of the dot-product in the original space. Thus, binary codes can also be directly fed into a linear SVM.for action recognition. From the relevant results shown in Table 5, it can be observed that the recognition accuracies computed by all methods have generally smaller differences compared with the diversity of performance in retrieval tasks. The reason is that the supervised SVM training can compensate the discriminative power between different methods, whereas the unsupervised retrieval cannot. Our BPB and KBPB can not only achieve competitive results with original features, but also perform better than other compression methods on medium-lengthed codes with FV and VLAD. Moreover, KBPB consistently gives the best performance.
|Methods||Fisher Vector (170400-d)||VLAD (85200-d)|
|17040 bit||11360 bit||8520 bit||8520 bit||5680 bit||4260 bit|
5 Conclusion and Future Work
In this paper, we have presented a novel binarization approach called Binary Projection Bank (BPB) for high-dimensional data, which exploits a group of small projections via the max-margin constraint to optimally preserve the intrinsic data similarity. Different from the conventional linear or bilinear projections, the proposed method can effectively map very high-dimensional representations to medium-dimensional binary codes with a low memory requirement and a more efficient coding procedure. BPB and the kernelized version KBPB have achieved better results compared with state-of-the-art methods for image retrieval and action recognition applications. In the future, we will focus more on using soft-assignment clustering based projection bank methods.
-  X. Bai, X. Yang, L. J. Latecki, W. Liu, and Z. Tu. Learning context-sensitive shape similarity by graph transduction. T-PAMI, 32(5):861–874, 2010.
-  Z. Cai, L. Liu, M. Yu, and L. Shao. Latent structure preserving hashing. In BMVC, 2015.
-  M. S. Charikar. Similarity estimation techniques from rounding algorithms. In STOC, 2002.
-  J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.
-  B. Fulkerson, A. Vedaldi, and S. Soatto. Localizing objects with smart dictionaries. In ECCV. 2008.
-  Y. Gong, S. Kumar, H. A. Rowley, and S. Lazebnik. Learning binary codes for high-dimensional data using bilinear projections. In CVPR, 2013.
-  Y. Gong and S. Lazebnik. Iterative quantization: A procrustean approach to learning binary codes. In CVPR, 2011.
-  J.-P. Heo, Y. Lee, J. He, S.-F. Chang, and S.-E. Yoon. Spherical hashing. In CVPR, 2012.
-  H. Jegou, M. Douze, and C. Schmid. Hamming embedding and weak geometric consistency for large scale image search. In ECCV. 2008.
-  H. Jegou, M. Douze, and C. Schmid. Product quantization for nearest neighbor search. PAMI, 33(1):117–128, 2011.
-  H. Jégou, M. Douze, C. Schmid, and P. Pérez. Aggregating local descriptors into a compact image representation. In CVPR, 2010.
-  B. Kulis and K. Grauman. Kernelized locality-sensitive hashing. T-PAMI, 34(6):1092–1104, 2012.
-  N. Kwak. Principal component analysis based on l1-norm maximization. T-PAMI, 30(9):1672–1680, 2008.
-  Y. Lin, R. Jin, D. Cai, S. Yan, and X. Li. Compressed hashing. In CVPR, 2013.
-  L. Liu and L. Wang. A scalable unsupervised feature merging approach to efficient dimensionality reduction of high-dimensional visual data. In ICCV, 2013.
-  L. Liu, L. Wang, and C. Shen. A generalized probabilistic framework for compact codebook creation. In CVPR, 2011.
-  L. Liu, M. Yu, and L. Shao. Multiview alignment hashing for efficient image search. IEEE Transactions on Image Processing, 24(3):956–966, 2015.
-  W. Liu, J. Wang, R. Ji, Y.-G. Jiang, and S.-F. Chang. Supervised hashing with kernels. In CVPR, 2012.
-  W. Liu, J. Wang, S. Kumar, and S.-F. Chang. Hashing with graphs. In ICML, 2011.
-  D. G. Lowe. Object recognition from local scale-invariant features. In ICCV, 1999.
A. Oliva and A. Torralba.
Modeling the shape of the scene: A holistic representation of the
International journal of computer vision, 42(3):145–175, 2001.
-  F. Perronnin and C. Dance. Fisher kernels on visual vocabularies for image categorization. In CVPR, 2007.
-  F. Perronnin, Y. Liu, J. Sánchez, and H. Poirier. Large-scale image retrieval with compressed fisher vectors. In CVPR, 2010.
-  F. Perronnin, J. Sánchez, and T. Mensink. Improving the fisher kernel for large-scale image classification. In ECCV. 2010.
-  J. Qin, L. Liu, M. Yu, Y. Wang, and L. Shao. Fast action retrieval from videos via feature disaggregation. In BMVC, 2015.
-  R. Salakhutdinov and G. Hinton. Semantic hashing. International Journal of Approximate Reasoning, 50(7):969–978, 2009.
-  J. Sánchez and F. Perronnin. High-dimensional signature compression for large-scale image classification. In CVPR, 2011.
-  Q. Shi, J. Petterson, G. Dror, J. Langford, A. Smola, and S. Vishwanathan. Hash kernels for structured data. JMLR, 10:2615–2637, 2009.
-  K. Soomro, A. R. Zamir, and M. Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild. arXiv preprint arXiv:1212.0402, 2012.
-  G. Wang, D. Hoiem, and D. Forsyth. Learning image similarity from flickr groups using fast kernel machines. T-PAMI, 34(11):2177–2188, 2012.
-  H. Wang, A. Klaser, C. Schmid, and C.-L. Liu. Action recognition by dense trajectories. In CVPR, 2011.
-  H. Wang, X. Lu, Z. Hu, and W. Zheng. Fisher discriminant analysis with l1-norm. IEEE Transactions on Cybernetics, 44(6):828–842, 2014.
-  K. Weinberger, A. Dasgupta, J. Langford, A. Smola, and J. Attenberg. Feature hashing for large scale multitask learning. In ICML, pages 1113–1120, 2009.
-  Y. Weiss, A. Torralba, and R. Fergus. Spectral hashing. In NIPS, 2008.
-  S. Wold, K. Esbensen, and P. Geladi. Principal component analysis. Chemometrics and intelligent laboratory systems, 2(1):37–52, 1987.
-  F. X. Yu, S. Kumar, Y. Gong, and S.-F. Chang. Circulant binary embedding. ICML, 2014.