Abstract:
An approach to computation of kernel descriptors is accelerated using precomputed tables. In one aspect, a fast algorithm for kernel descriptor computation that takes O(1) operations per pixel in each patch, based on pre-computed kernel values. This speeds up the kernel descriptor features under consideration, to levels that are comparable with D-SIFT and color SIFT, and two orders of magnitude faster than STIP and HoG3D. In some examples, kernel descriptors are applied to extract gradient, flow and texture based features for video analysis. In tests of the approach on a large database of internet videos used in the TRECVID MED 2011 evaluations, the flow based kernel descriptors are up to two orders of magnitude faster than STIP and HoG3D, and also produce significant performance improvements. Further, using features from multiple color planes produces small but consistent gains.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application claims the benefit of U.S. Provisional Application No. 61/710,355, filed on Oct. 5, 2012, which is incorporated herein by reference. 
     
    
     STATEMENT AS TO FEDERALLY SPONSORED RESEARCH 
       [0002]    This invention was made with government support under D11PC20071 awarded by IARPA. The government has certain rights in the invention. 
     
    
     BACKGROUND 
       [0003]    This invention relates to computation of kernel descriptors, and in particular to fast matching of image patches using fast computation of kernel descriptors. 
         [0004]    The widespread availability of cheap hand-held cameras and video sharing websites has resulted in massive amounts of video content online. The ability to rapidly analyze and summarize content from such videos entails a wide range of applications. Significant effort has been made in recent literature to develop such techniques. However, the sheer volume of such content as well as the challenges in analyzing videos introduce significant scalability challenges, for instance, in applying successful “bag-of-words” approaches used in image retrieval. 
         [0005]    Features such as STIP and HoG3D that extend image level features to the spatio-temporal domain have shown promise in recognizing actions from unstructured videos. These features discretize the gradient or optical flow orientations into a d-dimensional indicator vector δ(z)=[δ 1 (z), . . . , δ d (z)] with 
         [0000]    
       
         
           
             
               
                 δ 
                 i 
               
                
               
                 ( 
                 z 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     1 
                   
                   
                     
                       
                         if 
                          
                         
                             
                         
                          
                         
                           ⌊ 
                           
                             
                               d 
                                
                               
                                   
                               
                                
                               
                                 θ 
                                  
                                 
                                   ( 
                                   z 
                                   ) 
                                 
                               
                             
                             
                               2 
                                
                               π 
                             
                           
                           ⌋ 
                         
                       
                       = 
                       
                         i 
                         - 
                         1 
                       
                     
                   
                 
                 
                   
                     0 
                   
                   
                     otherwise 
                   
                 
               
             
           
         
       
     
         [0006]    Despite their success, these features are generally hand designed and do not generally utilize full information available in measuring patch similarity. In recent work, several efforts have been made to develop principled approaches to design and learn such low-level features. For example, a convolutional GRBM method has been proposed to extract spatio-temporal features using a multi-stage architecture. Also, a convolutional independent subspace analysis (ISA) network has been proposed to extract patch level features from pixel attributes. 
         [0007]    These deep learning approaches are in effect mapping pixel attributes into patch level features using a hierarchical architecture. A two layer hierarchical sparse coding scheme has been used for learning image representations at the pixel level. An orientation histogram in effect uses a pre-defined d-dimensional codebook that divides the θ space into uniform bins, and uses hard quantization for projecting pixel gradients. Another scheme allows data driven learning of pixel level dictionaries, and the pixel features are projected to the learnt dictionary using sparse coding to get a vector W(z)=(w 1 (z), . . . , w d (z)). After pooling such pixel level projections within local regions, the first layer codes are passed to the second layer for jointly encoding signals in the region. The orientation histograms and hierarchical sparse coding in effect define the following kernel for measuring the similarity between two patches P and Q: 
         [0000]    
       
         
           
             
               K 
                
               
                 ( 
                 
                   P 
                   , 
                   Q 
                 
                 ) 
               
             
             = 
             
               
                 
                   
                     
                       F 
                       h 
                     
                      
                     
                       ( 
                       P 
                       ) 
                     
                   
                   T 
                 
                  
                 
                   
                     F 
                     h 
                   
                    
                   
                     ( 
                     Q 
                     ) 
                   
                 
               
               = 
               
                 
                   ∑ 
                   
                     z 
                     ∈ 
                     P 
                   
                 
                  
                 
                   
                     ∑ 
                     
                       
                         z 
                         ′ 
                       
                       ∈ 
                       Q 
                     
                   
                    
                   
                     
                       
                         m 
                         ~ 
                       
                        
                       
                         ( 
                         z 
                         ) 
                       
                     
                      
                     
                       
                         m 
                         ~ 
                       
                        
                       
                         ( 
                         
                           z 
                           ′ 
                         
                         ) 
                       
                     
                      
                     
                       
                         Φ 
                          
                         
                           ( 
                           z 
                           ) 
                         
                       
                       T 
                     
                      
                     
                       Φ 
                        
                       
                         ( 
                         
                           z 
                           ′ 
                         
                         ) 
                       
                     
                   
                 
               
             
           
         
       
     
         [0000]    where 
         [0008]    F h (P)=Σ z∈P {tilde over (m)}(z)Φ(z) is the patch sum 
         [0009]    {tilde over (m)}(z)=m(z)/Σ z∈P m(z) 2 +ε g  is the normalized gradient magnitude with ε g  a small constant, and 
         [0010]    Φ(z)=δ(z) for HoG and Φ(z)=W(z) for hierarchical sparse coding. 
         [0011]    Kernel descriptors have been proposed to generalize these approaches by replacing the product Φ(z) T Φ(z′) above with a match kernel k(z, z′) and allows one to induce arbitrary feature spaces Φ(z) (including infinite dimensional) from pixel level attributes. This provides a powerful framework for designing rich low-level features and has shown state-of-the-art results for image and object recognition. 
         [0012]    A significant limitation of kernel descriptors is that kernel computations are generally costly and hence it is slow to extract them from densely sampled video patches. 
       SUMMARY 
       [0013]    In one aspect, in general, a fast algorithm for kernel descriptor computation that takes O(1) operations per pixel in each patch, based on pre-computed kernel values is used. This speeds up the kernel descriptor features under consideration, to levels that are comparable with D-SIFT and color SIFT, and two orders of magnitude faster than STIP and HoG3D. In some examples, kernel descriptors are applied to extract gradient, flow and texture based features for video analysis. In tests of the approach on a large database of internet videos, the flow based kernel descriptors are up to two orders of magnitude faster than STIP and HoG3D, and also produce significant performance improvements. Further, using features from multiple color planes produces small but consistent gains. 
         [0014]    In another aspect, in general, a method for image processing makes use of precomputed stored tables (e.g., “kernel sum tables”), which are read. Each kernel table represents a mapping from a corresponding pixel attribute to a vector of values. Images are accepted for processing, and patches are identified within said images. For each patch P, a feature vector is computed based summations of a product of terms over locations z in the patch. Each term within the product is obtained by a lookup in the kernel sum table corresponding to the location z of an attribute of the patch at the location z. The feature vectors thus obtained can then be used for several downstream image/video processing applications, such as similarity computation between two patches P and Q. 
         [0015]    In another aspect, in general, a method for image processing makes use of precomputed stored tables (e.g., “kernel sum tables”), which are read. Each kernel table represents a mapping from a corresponding feature to a vector of values. Images are accepted for processing, and patches are identified within said images. The processing includes repeatedly computing similarities between pairs of patches for images being processed. Computation of a similarity between a patch P and a patch Q comprises computing for patch P one or more summations over locations z in the patch P of terms, each term being a product of terms including a term obtained by a lookup in a corresponding kernel table according to the location z and/or an attribute of the patch P at the location z, computing for patch Q one or more summations over locations z in the patch Q of terms, each term being a product of terms including a term obtained by a lookup in a corresponding kernel table according to the location z and/or an attribute of the patch Q at the location z, and combining the sums of the one or more summations for P and one or more summations for Q to determine a kernel descriptor similarity between P and Q. A result of processing the images is determined using the computed similarities between the patches. In some examples, the kernel tables are precomputed prior to accepting the images for processing. 
         [0016]    An advantage of the approach is that the computational resources required are greatly reduced as compared to conventional approaches to image/video processing using kernel descriptors. 
         [0017]    Other features and advantages of the invention are apparent from the following description, and from the claims. 
     
    
     
       DESCRIPTION OF DRAWINGS 
         [0018]      FIG. 1  is a diagram of a video processing system. 
       
    
    
     DESCRIPTION 
       [0019]    Referring to  FIG. 1 , a computer implemented video processing system  100  includes a runtime processing system  130 , which accepts an input video  132  (e.g., a series of image frames acquired by a camera) and provides a video processor output  138 . A wide variety of well-known processing tasks may be performed by this system to produce the output  138 . A common feature of such tasks is repeated computation of comparison of patches (e.g., pixel regions) of images of the input video. For example, the input video  132  includes a large number of input images (e.g., video frames)  134 . Each input image may have a large number of patches  136 . In  FIG. 1 , a patch P is illustrated in one image and another patch Q is illustrated in another image. It should be understood that although illustrated in terms of patches that are formed as parts of single images, a single patch can also be defined to span multiple frames in a video, for example, to permit use of motion-based features. The runtime processing system  130  includes a computation module  140  that is configured to accept data representing two patches  136  (e.g., P and Q), and to provide a quantity K(P,Q)  142  representing a similarity between the two patches. It should be understood that this similarity computation is repeated a very large number of times, and therefore the computational resources required for this computation may represent a substantial portion of the total resources required to support the runtime system  130 . It should be understood that understood that the use of the similarity computation module  140  is presented in the context of a video processing system as an example and that such a module is applicable in other image or video processing systems, and more generally, in other applications in which a similar similarity computation may be used. 
         [0020]    One approach to similarity computation is based on a kernel representation approach. In the discussion below, an example with two kernels, one associated with orientation and one associated with position is presented. However, it should be understood that the approach is applicable to other kernel representations with two or more components. 
         [0021]    A detailed description including mathematical derivations of features one or more embodiments are presented in “Multi-Channel Shape-Flow Kernel Descriptors for Robust Video Event Detection or Retrieval”, published in  Proceedings, Part II, of the  12 th    European Conference on Computer Vision (ECCV)  2012, pages 301-314, (ISBN 978-3-642-33708-6), the contents of which are incorporated herein by reference. 
         [0022]    In this example, the similarity computation is specified by a set of kernels, in this example, two kernels are defined in terms of: 
         [0000]        k   p ( z, z ′)=exp(−γ p   ||z−z′||   2 )
 
         [0000]      and 
         [0000]        k   o ({tilde over (θ)} z , {tilde over (θ)} z′ )=exp(−γ O ||{tilde over (θ)}( z )−{tilde over (θ)}( z ′)|| 2 ).
 
         [0023]    A desired similarity between patches is computed as 
         [0000]    
       
         
           
             
               
                 K 
                 grad 
               
                
               
                 ( 
                 
                   P 
                   , 
                   Q 
                 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   z 
                   ∈ 
                   P 
                 
               
                
               
                 
                   ∑ 
                   
                     
                       z 
                       ′ 
                     
                     ∈ 
                     Q 
                   
                 
                  
                 
                   
                     
                       m 
                       ~ 
                     
                      
                     
                       ( 
                       z 
                       ) 
                     
                   
                    
                   
                     
                       m 
                       ~ 
                     
                      
                     
                       ( 
                       
                         z 
                         ′ 
                       
                       ) 
                     
                   
                    
                   
                     
                       k 
                       o 
                     
                      
                     
                       ( 
                       
                         
                           
                             θ 
                             ~ 
                           
                           z 
                         
                         , 
                         
                           
                             θ 
                             ~ 
                           
                           
                             z 
                             ′ 
                           
                         
                       
                       ) 
                     
                   
                    
                   
                     
                       k 
                       p 
                     
                      
                     
                       ( 
                       
                         z 
                         , 
                         
                           z 
                           ′ 
                         
                       
                       ) 
                     
                   
                 
               
             
           
         
       
     
         [0000]    where the sum over z ∈ P is a sum over the pixel locations z in the patch P and the sum over z′∈ Q is a sum over the pixel locations z′ in the patch Q. 
         [0024]    A desired property of K grad  is the ability to decompose it to a dot product of feature vectors F grad (P) and F grad (Q) computed independently on patches P and Q: 
         [0000]      K grad (P,Q)=F grad (P)·F grad (Q)
 
         [0000]    However, each of these vectors F grad  can potentially be infinite dimensional depending on the kernels (such as k p , k o ). This is addressed using an approximation that projects F grad  to rad an orthonormal basis with a limited number (e.g., 1≦t≦T) of basis vectors. Therefore, the finite dimensional approximation of the kernel similarity is then 
         [0000]    
       
         
           
             
               
                 K 
                 grad 
               
                
               
                 ( 
                 
                   P 
                   , 
                   Q 
                 
                 ) 
               
             
             = 
             
               
                 
                   ∑ 
                   
                     t 
                     = 
                     1 
                   
                   T 
                 
                  
                 
                     
                 
                  
                 
                   
                     
                       F 
                       grad 
                       t 
                     
                      
                     
                       ( 
                       P 
                       ) 
                     
                   
                    
                   
                     
                       F 
                       grad 
                       t 
                     
                      
                     
                       ( 
                       Q 
                       ) 
                     
                   
                    
                   
                     
                       K 
                       grad 
                     
                      
                     
                       ( 
                       
                         P 
                         , 
                         Q 
                       
                       ) 
                     
                   
                 
               
               ≈ 
               
                 
                   ∑ 
                   
                     t 
                     = 
                     1 
                   
                   T 
                 
                  
                 
                     
                 
                  
                 
                   
                     
                       F 
                       grad 
                       t 
                     
                      
                     
                       ( 
                       P 
                       ) 
                     
                   
                    
                   
                     
                       F 
                       grad 
                       t 
                     
                      
                     
                       ( 
                       Q 
                       ) 
                     
                   
                 
               
             
           
         
       
     
         [0025]    So an important computation is the computation of the T scalars F grad   t (P) for each patch P. 
         [0026]    One way to compute this scalar is as a doubly index sum 
         [0000]    
       
         
           
             
               
                 F 
                 grad 
                 t 
               
                
               
                 ( 
                 P 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 
                   d 
                   o 
                 
               
                
               
                   
               
                
               
                 
                   ∑ 
                   
                     j 
                     = 
                     1 
                   
                   
                     d 
                     p 
                   
                 
                  
                 
                     
                 
                  
                 
                   
                     α 
                     ij 
                     t 
                   
                    
                   
                     { 
                     
                       
                         ∑ 
                         
                           z 
                           ∈ 
                           P 
                         
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           
                             m 
                             ~ 
                           
                            
                           
                             ( 
                             z 
                             ) 
                           
                         
                          
                         
                           
                             k 
                             o 
                           
                            
                           
                             ( 
                             
                               
                                 
                                   θ 
                                   ~ 
                                 
                                  
                                 
                                   ( 
                                   z 
                                   ) 
                                 
                               
                               , 
                               
                                 x 
                                 i 
                               
                             
                             ) 
                           
                         
                          
                         
                           
                             k 
                             p 
                           
                            
                           
                             ( 
                             
                               z 
                               , 
                               
                                 y 
                                 j 
                               
                             
                             ) 
                           
                         
                       
                     
                     } 
                   
                 
               
             
           
         
       
     
         [0000]    where {x i } and {y j } are preselected basis sets for the arguments of the kernel functions. For example, the set {x i } may represent d o =25 angles between 0 and 2 π and the {y j } may represent d p =25 2D positions in a unit 5×5 square. In such an example, the double summation requires d o ×d p =625 evaluations of the innermost term for each pixel of P. 
         [0027]    The scalars α ij   t  can be represented as (column) vectors α t =[α ij   t ] of dimension d o ×d p =625. Furthermore, each α t  is an eigenvector of a matrix defined as the Kronecker product 
         [0000]    
       
      
       K 
       o,c 
       {circle around (×)}K 
       p,c  
      
     
         [0000]    where K o,c  and K p,c  denote the centered orientation and position kernel matrices corresponding to K o  and K p , respectively, and the elements of the kernel matrices are defined as 
         [0000]        K   o   =[K   o,ij ] and  K   p   =[K   p,ij ] 
         [0000]      where 
         [0000]        K   o,ij   =k   o ( x   i   ,x   j )  K   p,st   =k   p ( y   s   , y   t ). 
         [0028]    Recognizing that the α t  are eigenvectors of a Kronecker product, these eigenvectors can be computed from the eigenvectors of the matrices that make up the products such that 
         [0000]      α ij   t =α O,i   t α p,j 
 
         [0000]    where α o   t =[α o,i   t ] is a (d o  dimensional) eigenvenvector of K o =[K o,ij ] and α p   t =[α p,j   t ] is a (d p  dimensional) eigenvenvector of K p =[K p,st ], and the corresponding eigenvalue λ t =λ o   t λ p   t . 
         [0029]    Recognizing that the terms α ij   t  can be separated as shown above, computation of an entry of the F grad  (P) vector can be rewritten as 
         [0000]    
       
         
           
             
               
                 F 
                 grad 
                 t 
               
                
               
                 ( 
                 P 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 
                   d 
                   o 
                 
               
                
               
                   
               
                
               
                 
                   ∑ 
                   
                     j 
                     = 
                     1 
                   
                   
                     d 
                     p 
                   
                 
                  
                 
                     
                 
                  
                 
                   
                     α 
                     
                       o 
                       , 
                       i 
                     
                     t 
                   
                    
                   
                     α 
                     
                       p 
                       , 
                       j 
                     
                     t 
                   
                    
                   
                     { 
                     
                       
                         ∑ 
                         
                           z 
                           ∈ 
                           P 
                         
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           
                             m 
                             ~ 
                           
                            
                           
                             ( 
                             z 
                             ) 
                           
                         
                          
                         
                           
                             k 
                             o 
                           
                            
                           
                             ( 
                             
                               
                                 
                                   θ 
                                   ~ 
                                 
                                  
                                 
                                   ( 
                                   z 
                                   ) 
                                 
                               
                               , 
                               
                                 x 
                                 i 
                               
                             
                             ) 
                           
                         
                          
                         
                           
                             k 
                             p 
                           
                            
                           
                             ( 
                             
                               z 
                               , 
                               
                                 y 
                                 j 
                               
                             
                             ) 
                           
                         
                       
                     
                     } 
                   
                 
               
             
           
         
       
     
         [0000]    which can be rearranged as 
         [0000]    
       
         
           
             
               
                 F 
                 grad 
                 t 
               
                
               
                 ( 
                 P 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   z 
                   ∈ 
                   P 
                 
                 
                     
                 
               
                
               
                   
               
                
               
                 
                   
                     m 
                     ~ 
                   
                    
                   
                     ( 
                     z 
                     ) 
                   
                 
                  
                 
                   { 
                   
                     
                       
                         ∑ 
                         
                           d 
                           o 
                         
                       
                       
                         i 
                         = 
                         1 
                       
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         α 
                         
                           o 
                           , 
                           i 
                         
                         t 
                       
                        
                       
                         
                           k 
                           o 
                         
                          
                         
                           ( 
                           
                             
                               
                                 θ 
                                 ~ 
                               
                                
                               
                                 ( 
                                 z 
                                 ) 
                               
                             
                             , 
                             
                               x 
                               i 
                             
                           
                           ) 
                         
                       
                     
                   
                   } 
                 
                  
                 
                   { 
                   
                     
                       
                         ∑ 
                         
                           d 
                           p 
                         
                       
                       
                         j 
                         = 
                         1 
                       
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         α 
                         
                           p 
                           , 
                           j 
                         
                         t 
                       
                        
                       
                         
                           k 
                           p 
                         
                          
                         
                           ( 
                           
                             z 
                             , 
                             
                               y 
                               j 
                             
                           
                           ) 
                         
                       
                     
                   
                   } 
                 
               
             
           
         
       
     
         [0000]    and the terms in brackets can be replaced with precomputed functions 
         [0000]    
       
         
           
             
               
                 F 
                 grad 
                 t 
               
                
               
                 ( 
                 P 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   z 
                   ∈ 
                   P 
                 
                 
                     
                 
               
                
               
                   
               
                
               
                 
                   
                     m 
                     ~ 
                   
                    
                   
                     ( 
                     z 
                     ) 
                   
                 
                  
                 
                   
                     T 
                     o 
                     t 
                   
                    
                   
                     ( 
                     
                       θ 
                        
                       
                         ( 
                         z 
                         ) 
                       
                     
                     ) 
                   
                 
                  
                 
                   
                     T 
                     p 
                     t 
                   
                    
                   
                     ( 
                     z 
                     ) 
                   
                 
               
             
           
         
       
       
         
           where 
         
       
       
         
           
             
               
                 T 
                 o 
                 t 
               
                
               
                 ( 
                 
                   θ 
                    
                   
                     ( 
                     z 
                     ) 
                   
                 
                 ) 
               
             
             = 
             
               { 
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   
                     d 
                     o 
                   
                 
                  
                 
                     
                 
                  
                 
                   
                     α 
                     
                       o 
                       , 
                       i 
                     
                     t 
                   
                    
                   
                     
                       k 
                       o 
                     
                      
                     
                       ( 
                       
                         
                           
                             θ 
                             ~ 
                           
                            
                           
                             ( 
                             z 
                             ) 
                           
                         
                         , 
                         
                           x 
                           i 
                         
                       
                       ) 
                     
                   
                 
               
               } 
             
           
         
       
       
         
           and 
         
       
       
         
           
             
               
                 T 
                 p 
                 t 
               
                
               
                 ( 
                 z 
                 ) 
               
             
             = 
             
               
                 { 
                 
                   
                     ∑ 
                     
                       j 
                       = 
                       1 
                     
                     
                       d 
                       p 
                     
                   
                    
                   
                       
                   
                    
                   
                     
                       α 
                       
                         p 
                         , 
                         j 
                       
                       t 
                     
                      
                     
                       
                         k 
                         p 
                       
                        
                       
                         ( 
                         
                           z 
                           , 
                           
                             y 
                             j 
                           
                         
                         ) 
                       
                     
                   
                 
                 } 
               
               . 
             
           
         
       
     
         [0030]    Note that if the set of possible values z ∈ P and possible values {tilde over (θ)}(z) are known, the values of the precomputed functions could be enumerated in advance. Without knowing the set of possible values, a quantization of the possible values q o ({tilde over (θ)}(z)) into a finely space set {q o,i } i=1, . . . ,N     o    and q p (z) into a finely spaces set {q p,j } j=1, . . . ,N     p    is used such that 
         [0000]        T   o   t ({tilde over (θ)}( z ))˜ T   o   t ( q   o ({tilde over (θ)}( z )))
 
         [0000]      and 
         [0000]        T   p   t ( z )˜ T   p   t ( q   p ( z ))
 
         [0031]    A kernel preprocessor  120  is used to precompute a kernel table T o [θ] of size T×N o  and T p [z] of size T×N p  using the approach outlined above, generally before beginning processing of the input video. 
         [0032]    At runtime the kernel similarity computation element 140 reads the precomputed tables, and uses them to compute (i.e., approximate via the tables, either by direct lookup or an interpolation) the T dimensional vectors F grad  (P) and F grad  (Q) from which the similarity K grad  (P, Q)  142  is obtained by computing the inner product as described above. 
         [0033]    The description below provides an example of feature representation and early and late fusion techniques. In this example, a “bag-of-words” framework is used to represent the information from different feature descriptors. This is done in two steps—in the first coding step the descriptors are projected to a pre-trained codebook of descriptor vectors, and then in the pooling step the projections are aggregated to a fixed length feature vector. We use both spatial and spatio-temporal pooling. From these features, we further employ kernel based fusion and score level fusion to achieve more robust performance. 
         [0034]    Formally, we represent a video by a set of low-level descriptors, x i , where {1 . . . } is the set of locations. Let M denote the different spatial/spatio-temporal regions of interest, and N m  denote the number of descriptors extracted within region m. Let f and g denote the coding and pooling operators respectively. Then, the vector z representing the entire video is obtained by sequentially coding and pooling over all regions and concatenating: 
         [0000]      α i   =f ( x   i ),  i= 1  . . . N  
 
         [0000]      h   m   =g ({α i } i∈N     m   ),  m= 1 , . . . ,M    
         [0000]        z   T   =[h   1   T    . . . h   M   t ] 
         [0035]    For the coding step, we first learn a codebook using k-means or a similar unsupervised clustering algorithm from a sample set of feature vectors. In hard quantization, we assign each feature vector x i  to the nearest codeword from the codebook as 
         [0000]    
       
         
           
             
               
                 α 
                 i 
               
               ∈ 
               
                 
                   { 
                   
                     0 
                     , 
                     1 
                   
                   } 
                 
                 K 
               
             
             , 
             
               
 
             
              
             
               
                 α 
                 
                   i 
                   , 
                   j 
                 
               
               = 
               
                 
                   1 
                   ⇔ 
                   j 
                 
                 = 
                 
                   arg 
                    
                   
                       
                   
                    
                   
                     
                       min 
                       
                         k 
                         ≤ 
                         K 
                       
                     
                      
                     
                       
                          
                         
                           
                             x 
                             i 
                           
                           - 
                           
                             c 
                             k 
                           
                         
                          
                       
                       2 
                     
                   
                 
               
             
           
         
       
     
         [0000]    where c k  is the k th  codeword. In soft quantization, the assignment of the feature vectors to codewords is distributed as 
         [0000]    
       
         
           
             
               α 
               
                 i 
                 , 
                 j 
               
             
             = 
             
               
                 exp 
                  
                 
                   ( 
                   
                     
                       - 
                       β 
                     
                      
                     
                       
                          
                         
                           
                             x 
                             i 
                           
                           - 
                           
                             c 
                             j 
                           
                         
                          
                       
                       2 
                     
                   
                   ) 
                 
               
               
                 
                   ∑ 
                   
                     k 
                     = 
                     1 
                   
                   K 
                 
                  
                 
                     
                 
                  
                 
                   exp 
                    
                   
                     ( 
                     
                       
                         - 
                         β 
                       
                        
                       
                         
                            
                           
                             
                               x 
                               i 
                             
                             - 
                             
                               c 
                               k 
                             
                           
                            
                         
                         2 
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0000]    where β controls the soft assignment. In our experiments we find soft quantization to consistently outperform hard quantization. 
         [0036]    Two popular pooling strategies are average and max. In average pooling, we take the average of the α i  assigned to different codewords for different feature vectors as h=1/NΣ i=1   N α i . In max pooling, we take the maximum of the α i &#39;s as h=max i=1 . . . N     α     i . In this example, we find average pooling to consistently outperform max pooling for video retrieval. Further spatial pooling with 1×1+2×2+1×3 partition of the (x,y) space has consistently superior performance for all the features considered. 
         [0037]    We combine multiple features in an early fusion framework by using p-norm Multiple Kernel Learning (MKL), with p&gt;1. For each feature, we first compute exponential x 2  kernels, defined by 
         [0000]    
       
         
           
             
               K 
                
               
                 ( 
                 
                   x 
                   , 
                   y 
                 
                 ) 
               
             
             = 
             
                
               
                 
                   - 
                   ρ 
                 
                  
                 
                   
                     ∑ 
                     i 
                     
                         
                     
                   
                    
                   
                       
                   
                    
                   
                     
                       
                         ( 
                         
                           
                             x 
                             i 
                           
                           - 
                           
                             y 
                             i 
                           
                         
                         ) 
                       
                       2 
                     
                     
                       
                         x 
                         i 
                       
                       + 
                       
                         y 
                         i 
                       
                     
                   
                 
               
             
           
         
       
     
         [0000]    for each pair of samples x and y in the training set. Then, given a set of kernels {K k } for individual features, we learn a linear combination K=Σ k d k K k  of the base kernels. The primal of this problem can be formulated as 
         [0000]    
       
         
           
             
               
                 min 
                 
                   w 
                   , 
                   b 
                   , 
                   
                     ξ 
                     ≥ 
                     0 
                   
                   , 
                   
                     d 
                     ≥ 
                     0 
                   
                 
               
                
               
                 
                   1 
                   2 
                 
                  
                 
                   
                     ∑ 
                     k 
                     
                         
                     
                   
                    
                   
                       
                   
                    
                   
                     
                       w 
                       k 
                       t 
                     
                      
                     
                       w 
                       k 
                     
                   
                 
               
             
             + 
             
               C 
                
               
                 
                   ∑ 
                   
                       
                   
                 
                  
                 
                     
                 
                  
                 
                   ξ 
                   i 
                 
               
             
             + 
             
               
                 λ 
                 2 
               
                
               
                 
                   ( 
                   
                     
                       ∑ 
                       k 
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       d 
                       k 
                       p 
                     
                   
                   ) 
                 
                 
                   2 
                   p 
                 
               
             
           
         
       
       
         
           
             
               s 
               . 
               t 
               . 
               
                 
                   y 
                   i 
                 
                 ( 
                 
                   
                     
                       ∑ 
                       k 
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         
                           d 
                           k 
                         
                       
                        
                       
                         w 
                         k 
                         t 
                       
                        
                       
                         
                           φ 
                           k 
                         
                          
                         
                           ( 
                           
                             x 
                             i 
                           
                           ) 
                         
                       
                     
                   
                   + 
                   b 
                 
                 ) 
               
             
             ≥ 
             
               1 
               - 
               
                 ξ 
                 i 
               
             
           
         
       
     
         [0038]    The convex form of the above equation is obtained by substituting w k  for {square root over (d k  )} w k  . To solve this equation efficiently, we use Sequential Minimal Optimization (SMO). This is possible by first computing the Lagrangian 
         [0000]    
       
         
           
             L 
             = 
             
               
                 
                   1 
                   2 
                 
                  
                 
                   
                     ∑ 
                     k 
                     
                         
                     
                   
                    
                   
                       
                   
                    
                   
                     
                       w 
                       k 
                       t 
                     
                      
                     
                       w 
                       k 
                     
                      
                     
                       / 
                     
                      
                     
                       d 
                       k 
                     
                   
                 
               
               + 
               
                 
                   ∑ 
                   
                       
                   
                 
                  
                 
                     
                 
                  
                 
                   
                     ( 
                     
                       C 
                       - 
                       
                         β 
                         i 
                       
                     
                     ) 
                   
                    
                   
                     ξ 
                     i 
                   
                 
               
               + 
               
                 
                   λ 
                   2 
                 
                  
                 
                   
                     ( 
                     
                       
                         ∑ 
                         k 
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         d 
                         k 
                         p 
                       
                     
                     ) 
                   
                   
                     2 
                     p 
                   
                 
               
                
               
                 
 
               
               - 
               
                 
                   ∑ 
                   i 
                   
                       
                   
                 
                  
                 
                     
                 
                  
                 
                   
                     α 
                     i 
                   
                   [ 
                   
                     
                       
                         y 
                         i 
                       
                       ( 
                       
                         
                           
                             ∑ 
                             k 
                             
                                 
                             
                           
                            
                           
                               
                           
                            
                           
                             
                               w 
                               k 
                               t 
                             
                              
                             
                               
                                 φ 
                                 k 
                               
                                
                               
                                 ( 
                                 
                                   x 
                                   i 
                                 
                                 ) 
                               
                             
                           
                         
                         + 
                         b 
                       
                       ) 
                     
                     - 
                     1 
                     + 
                     
                       ξ 
                       i 
                     
                   
                   ] 
                 
               
             
           
         
       
     
         [0000]    and then computing the l p -MKL dual as 
         [0000]    
       
         
           
             D 
             = 
             
               
                 
                   max 
                   
                     α 
                     ∈ 
                     A 
                   
                 
                  
                 
                   
                     1 
                     t 
                   
                    
                   α 
                 
               
               - 
               
                 
                   1 
                   
                     8 
                      
                     λ 
                   
                 
                  
                 
                   
                     ( 
                     
                       
                         ∑ 
                         k 
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           ( 
                           
                             
                               α 
                               t 
                             
                              
                             
                               H 
                               k 
                             
                              
                             α 
                           
                           ) 
                         
                         q 
                       
                     
                     ) 
                   
                   
                     2 
                     q 
                   
                 
               
             
           
         
       
       
         
           where 
         
       
       
         
           
             
               
                 
                   1 
                   p 
                 
                 + 
                 
                   1 
                   q 
                 
               
               = 
               1 
             
             , 
           
         
       
     
         [0000]    A={α|0≦α≦C1,1 t Yα=0}, H k =YK k Y , and Y is a diagonal matrix with labels on the diagonal. The kernel weights can then be computed as 
         [0000]    
       
         
           
             
               d 
               k 
             
             = 
             
               
                 1 
                 
                   2 
                    
                   λ 
                 
               
                
               
                 
                   ( 
                   
                     
                       ∑ 
                       k 
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         ( 
                         
                           
                             α 
                             t 
                           
                            
                           
                             H 
                             k 
                           
                            
                           α 
                         
                         ) 
                       
                       q 
                     
                   
                   ) 
                 
                 
                   
                     1 
                     q 
                   
                   - 
                   
                     1 
                     p 
                   
                 
               
                
               
                 
                   ( 
                   
                     
                       α 
                       t 
                     
                      
                     
                       H 
                       k 
                     
                      
                     α 
                   
                   ) 
                 
                 
                   q 
                   p 
                 
               
             
           
         
       
     
         [0039]    Since the dual objective above is differentiable with respect to α, the SMO algorithm can be applied by selecting two variables at a time and optimizing until convergence. 
         [0040]    We adopted a weighted average fusion strategy that assigns video specific weights based on each system&#39;s detection threshold. This is based on the intuition that a system has low confidence when its score for a particular video is close to the detection threshold, and high confidence when the scores are significantly different from the threshold. Given the confidence score p i  from system i for a particular video, the weight for that system and video is computed as: 
         [0000]    
       
         
           
             
               w 
               i 
             
             = 
             
               { 
               
                 
                   
                     
                       
                         
                           Th 
                           i 
                         
                         - 
                         
                           p 
                           i 
                         
                       
                       
                         Th 
                         i 
                       
                     
                   
                   
                     
                       
                         ifp 
                         i 
                       
                       &lt; 
                       
                         Th 
                         i 
                       
                     
                   
                 
                 
                   
                     
                       
                         
                           p 
                           i 
                         
                         - 
                         
                           Th 
                           i 
                         
                       
                       
                         1 
                         - 
                         
                           Th 
                           i 
                         
                       
                     
                   
                   
                     else 
                   
                 
               
             
           
         
       
     
         [0000]    where Th i  is the detection threshold. The final score P for a video is computed as P=Σ i w i p i /Σ i w i . In our experiments, this approach consistently improved performance over any individual system. 
         [0041]    A number of different implementations of the runtime and preprocessing systems may be used, for example, using software, special-purpose hardware, or a combination of software and hardware. In some examples, computation of the kernel tables is performed using a general-purpose computer executing software stored on a tangible non-transitory medium (e.g., magnetic or optical disk). The software can include instructions (e.g., machine level instructions or higher level language statements). In some implementations, the kernel similarity computation is implemented using special-purpose hardware and/or using a co-processor to a general purpose computer. The kernel tables, which may be passed to the runtime system and/or stored on a tangible medium, should be considered to comprise software which imparts functionality to the kernel similarity computation (hardware and/or software-implemented) element. In some implementations, the kernel tables are integrated into a configured or configurable circuit, for example, being stored in a volatile or non-volatile memory of the circuit. 
         [0042]    It is to be understood that the foregoing description is intended to illustrate and not to limit the scope of the invention, which is defined by the scope of the appended claims. Other embodiments are within the scope of the following claims.