Abstract:
A principled, probabilistic approach to meta-learning acts as a go-between for a ‘black-box’ image annotation system and its users. Inspired by inductive transfer, the approach harnesses available information, including the black-box model&#39;s performance, the image representations, and a semantic lexicon ontology. Being computationally ‘lightweight.’ the meta-learner efficiently re-trains over time, to improve and/or adapt to changes. The black-box annotation model is not required to be re-trained, allowing computationally intensive algorithms to be used. Both batch and online annotation settings are accommodated. A “tagging over time” approach produces progressively better annotation, significantly outperforming the black-box as well as the static form of the meta-learner, on real-world data.

Description:
REFERENCE TO RELATED APPLICATION 
       [0001]    This application claims priority from U.S. Provisional Patent Application Ser. No. 60/974,286, filed Sep. 21, 2007, the entire content of which is incorporated herein by reference. 
     
    
     GOVERNMENT SUPPORT 
       [0002]    This invention was made with government support under Contract Nos. 0347148 and 0705210 awarded by the National Science Foundation. The government has certain rights in the invention. 
     
    
     FIELD OF THE INVENTION 
       [0003]    This invention relates generally to automated image annotation and, more particularly to a meta-learning framework for image tagging and an online environment whereby images and user tags enter the system as a temporal sequence to incrementally train the meta-learner over time to progressively improve annotation performance and adapt to changing user-system dynamics. 
       BACKGROUND OF THE INVENTION 
       [0004]    The scale of the World Wide Web makes it essential to have automated systems for content management. A significant fraction of this content exists in the form of images, often with meta-data unusable for meaningful search and organization. To this end, automatic image annotation or tagging is an important step toward achieving large-scale organization and retrieval. 
         [0005]    In the recent years, many new image annotation ideas have been proposed. Typical scenarios considered are those where batches of images, having visual semblance with training images, are statically tagged. However, incorporating automatic image tagging into real-world photo-sharing environments (e.g., Flickr, Riya, Photo.Net) poses unique challenges that have seldom been taken up in the past. 
         [0006]    In an online setting, where people upload images, automatic tagging needs to be performed as and when they are received, to make them searchable by text. On the other hand, people often collaboratively tag a subset of the images from time to time, which can be leveraged for automatic annotation. Moreover, time can lead to changes in user-focus/user-base, resulting in continued evolution of user tag vocabulary, tag distributions, or topical distribution of uploaded images. 
         [0007]    In online systems, e.g., Yahoo! and Flickr, collaborative image tagging, also referred to as folksonomic tagging, plays a key role in making the image collections organizable by semantics and searchable by text. This effort can go a long way if automated image annotation engines complement the human tagging process, taking advantage of these tags and addressing the inherent scalability issues associated with human-driven processes. 
         [0008]    Traditionally, annotation engines have considered the batch setting, whereby a fixed-size dataset is used for training, following which it is applied to a set of test images, in the hope of generalization. A realistic embedding of such an engine into an online setting must tackle three main issues: (1) Current state-of-the-art in annotation is a long way off from being reliable on real-world data. (2) Image collections in online systems are dynamic in nature—over time, new images are uploaded, old ones are tagged, etc. 
         [0009]    Annotation engines have traditionally been trained on fixed image collections tagged using fixed vocabularies, which severely constrain adaptability over time. (3) While a solution may be to re-train the annotation engine with newly acquired images, most proposed methods are too computationally intensive to re-train frequently. None of the questions associated with image annotation in an online setting, such as (a) how often to re-train, (b) with what performance gain, and (c) at what cost, have been answered in the annotation literature. A recently proposed system, Alipr, incorporates automatic tagging into its photo-sharing framework, but it still is limited by the above issues. 
         [0010]    From a machine-learning point of view, the main difference is in the nature by which ground-truth is made available ( FIG. 1 ). The batch setting (left) is what has traditionally been conceived in the annotation literature, whereby the entire ground-truth is available at once, with no intermittent user-feedback. The online setting (right) is an abstracted representation of how an automated annotation system can be incorporated into a public-domain photo-sharing environment. As discussed, this setting poses challenges which have largely not been previously dealt with. 
       SUMMARY OF THE INVENTION 
       [0011]    One aspect of this invention is directed to a principled, lightweight, meta-learning framework for image tagging. With very few simplifying assumptions, the framework can be built atop any available annotation engine that we refer to as the ‘black-box’. Experimentally, we find that such an approach can dramatically improve annotation performance over the black-box system in a batch setting (and thus make it more viable for real-world implementation), incurring insignificant computational overhead for training and annotation. 
         [0012]    A second aspect of the invention resides in an online setting, whereby images and user tags enter the system as a temporal sequence, as in the case of Flickr and Alipr. Here, a tagging over time (T/T) approach is used that incrementally trains the meta-learner over time to progressively improve annotation performance and adapt to changing user-system dynamics, without the need to re-train the (computationally intensive) annotation engine. Some advantages include the following:
       A meta-learning framework for annotation, based on inductive transfer, is disclosed, and shown to dramatically boost performance in batch and online settings.   The meta-learning framework is designed in a way that makes it lightweight for re-training and inferencing in an online setting, by making the training process deterministic in time and space consumption.   Appropriate smoothing steps are introduced to deal with sparsity in the meta-learner training data.   Two different re-training models, persistent memory and transient memory, are disclosed.       
 
         [0017]    They are realized through simple incremental/decremental learning steps, and the intuitions behind them are experimentally validated. 
         [0018]    Experiments are conducted by building the meta-learner atop two annotation engines, using the popular Corel dataset, and two real-world image traces and user-feedback obtained from the Alipr system. Empirically, various intuitions about the meta-learner and the T/T framework are tested. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0019]      FIG. 1  shows batch and online image annotation settings; 
           [0020]      FIG. 2  shows meta-learner training framework for annotation; 
           [0021]      FIG. 3  shows a visualization of Pr(G w     i   =g i |A w     j   =1, G w     j   =0); 
           [0022]      FIG. 4  shows a schematic overview of ‘tagging over time’; 
           [0023]      FIGS. 5A to 5D  show the precision and F 1 -score comparisons for traces # 1  and # 2 ; 
           [0024]      FIGS. 6A and 6B  show the precision &amp; F 1 -score for mem. model comparison; 
           [0025]      FIGS. 7A and 7B  show F 1 -score and time with varying L intre ; and 
           [0026]      FIG. 8  shows sample annotation results, improving over time. 
       
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Related Work 
       [0027]    Research in automatic image annotation can be roughly categorized into two different ‘schools of thought’: (1) Words and visual features are jointly modeled to yield compound predictors describing an image or its constituent regions. The words and image representations used could be disparate or single vectored representations of text and visual features. (2) 
         [0028]    Automatic annotation is treated as a two-step process consisting of supervised image categorization, followed by word selection based on the categorization results. While the former approaches can potentially label individual image regions, ideal region annotation would require precise image segmentation, an open problem in computer vision. Although the latter techniques cannot label regions, they are typically more scalable to large image collections. 
         [0029]    The term meta-learning has historically been used to describe the learning of meta-knowledge about learned knowledge. Research in meta-learning covers a wide spectrum of approaches and applications, as has been reviewed in. Here, we briefly discuss the approaches most pertinent to this work. One of the most popular meta-learning approaches, boosting is widely used in supervised classification. Boosting involves iteratively adjusting weights assigned to data points during training, to adaptively reduce misclassification. In stacked generalization, weighted combinations of responses from multiple learners are taken to improve overall performance. The goal here is to learn optimal weights using validation data, in the hope of generalization to unseen data. 
         [0030]    A research area under the meta-learning umbrella that is closest to our work is inductive transfer/transfer learning. Research in inductive transfer is grounded on the belief that knowledge assimilated about certain tasks can potentially facilitate the learning of certain other tasks. Incrementally learning support vectors as and when training data is encountered has been explored as a scalable supervised learning procedure. In our work, we draw inspiration from inductive transfer and incremental/decremental learning to develop the meta-learner and the overall T/T framework. 
       Meta-Learning 
       [0031]    Given an image annotation system or algorithm, we treat it as a ‘black-box’ and build a lightweight meta-learner that attempts to understand the performance of the system on each word in its vocabulary, taking into consideration all available information, which includes: 
         [0032]    Annotation performance of the black-box models. 
         [0033]    Ground-truth annotation/tags, whenever available. 
         [0034]    External knowledge bases, e.g., WordNet. 
         [0035]    Visual content of the images. 
         [0036]    Here, we discuss the nature of each one, and formulate a probabilistic framework to harness all of them. We consider a black-box system that takes an image as input and guesses one or more words as its annotation. We do not concern ourselves directly with the methodology or philosophy the black-box employs, but care about their output. A ranked ordering of the guesses is not necessary for our framework, but can be useful for empirical comparison. 
         [0037]    Assume that either there is ground-truth readily available for a subset of the images, or, in an online setting, images are being uploaded and collaboratively/individually tagged from time to time, which means that ground-truth is made available as and when users tag them. For example, consider that an image is uploaded but not tagged. At this time, the black-box can make guesses at its annotation. At a later time, user provide tags to it, at which point it becomes clear how good the black-box&#39;s guesses were. This is where the meta-learner fits in, in an online scenario. The images are also available to the meta-learner for visual content analysis. Furthermore, knowledge bases (e.g., WordNet) can be potentially useful, since semantics recognition is the desiderata of annotation. 
       Generic Framework 
       [0038]    Let the black-box annotation system be known to have a word vocabulary denoted by V bbox . Let us denote the ground-truth vocabulary by V gtruth . The meta-learner works on the union of these vocabularies, namely V=(V bbox ∪V gtruth )={w 1 , . . . , w k }, where K=|V|, the size of this overall vocabulary. Given an image I, the black-box predicts a set of words to be its correct annotation. To denote these guesses, we introduce indicator variables G w ε{0, 1}, wεV, where a value of 1 or 0 indicates whether word w i  is predicted by the black-box for 1 or not. We introduce similar indicator variables A w ε{0, 1}, wεV to denote the ground-truth tagging, where a value of 1 or 0 indicates whether w is a correct annotation for 1 or not. Strictly speaking, we can conceive the black-box as a multi-valued function ƒ bbox  mapping an image I to indicator variables G w     i   : ƒ bbox (I)=(G w     1   , . . . , G w     k   ) Similarly, the ground-truth labels can be thought of as a function ƒ gtruth  mapping the image to its true labels using the indicator variables: ƒ gtruth (I)=(A w     1   , . . . , A w     k   ). 
         [0039]    Regardless of the abstraction of visual content that the black-box uses for annotation, the pixel-level image representation may be still available to the meta-learner. If some visual features extracted from the images represent a different abstraction than what the black-box uses, they can be thought of as a different viewpoint and thus be potentially useful for semantics recognition. Such a visual feature representation, that is also simple enough not to add significant computational overhead, can be thought of as a function defined as: ƒ vis (I)=(h 1 , . . . , h D ). Here, we specify a D-dimensional image feature vector representation as an example. Instead, other non-vector representations (e.g., variable-length region-based features) can also be used as long as they are efficient to compute and process, so as to keep the meta-learner lightweight. 
         [0040]    Finally, the meta-learner also has at its disposal an external knowledge base, namely the semantic lexicon WordNet, which is essentially a semantic lexicon for the English language that has in the past been found useful for image annotation. The invention is not limited in this regard, however, insofar as other and yet to be developed lexicons may be used. In particular, WordNet-based semantic relatedness measures have benefited annotation tasks. WordNet, however, does not include most proper nouns and colloquial words that are often prevalent in human tag vocabularies. Such non-WordNet words must therefore be ignored or eliminated from the vocabulary V in order to use WordNet on the entire vocabulary. The meta-leamer attempts to assimilate useful knowledge from this lexicon for performance gain. 
         [0041]    It can be argued that this semantic knowledge base may help discover the connection between the true semantics of images, the guesses made by the black-box model for that image, and the semantic relatedness among the guesses. Once again, the inductive transfer idea comes into play, whereby we conjecture that the black-box, with its ability to recognize semantics of some image classes, may help recognize the semantics of entirely different classes of images. Let us denote the side-information extracted (externally) from the knowledge base and the black-box guesses for an image by a numerical abstraction, namely ƒ kbase (I)=(ρ 1 , . . . , ρ K ), where ρ i εR, with the knowledge base and the black-box guesses implicitly conditioned. 
         [0042]    We are now ready to postulate a probabilistic formulation for the meta-learner. In essence, this meta-learner, trained on available data with feedback (see  FIG. 2 ), acts a function which takes in all available information pertaining to an image I, including the black-box&#39;s annotation, and produces a new set of guesses as its annotation. In our meta-learner, this function is realized by taking decisions on each word independently. In order to do so, we compute the following odds in favor of each word w j  to be an actual ground-truth tag, given all pertinent information, as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       l 
                       
                         w 
                         j 
                       
                     
                      
                     
                       ( 
                       I 
                       ) 
                     
                   
                   = 
                   
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               A 
                               
                                 w 
                                 j 
                               
                             
                             = 
                             
                               1 
                                
                               
                                 
                                   f 
                                   bbox 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                             
                           
                           , 
                           
                             
                               f 
                               kbase 
                             
                              
                             
                               ( 
                               I 
                               ) 
                             
                           
                           , 
                           
                             
                               f 
                               vis 
                             
                              
                             
                               ( 
                               I 
                               ) 
                             
                           
                         
                         ) 
                       
                     
                     
                       Pr 
                       ( 
                       
                         
                           A 
                           
                             w 
                             j 
                           
                         
                         = 
                         
                           0 
                           | 
                           
                             Pr 
                              
                             
                               ( 
                               
                                 
                                   
                                     f 
                                     bbox 
                                   
                                    
                                   
                                     ( 
                                     I 
                                     ) 
                                   
                                 
                                 , 
                                 
                                   
                                     f 
                                     kbase 
                                   
                                    
                                   
                                     ( 
                                     I 
                                     ) 
                                   
                                 
                                 , 
                                 
                                   
                                     f 
                                     vis 
                                   
                                    
                                   
                                     ( 
                                     I 
                                     ) 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0043]    Note that here ƒbbox(I) (and similarly, the other terms) denotes a realization of the corresponding random variables given the image I. Using Bayes&#39; Rule, we can re-write: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       l 
                       
                         w 
                         j 
                       
                     
                      
                     
                       ( 
                       I 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         
                           Pr 
                            
                           
                             ( 
                             
                               
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                                 = 
                                 
                                   1 
                                    
                                   
                                     
                                       f 
                                       bbox 
                                     
                                      
                                     
                                       ( 
                                       I 
                                       ) 
                                     
                                   
                                 
                               
                               , 
                               
                                 
                                   f 
                                   kbase 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               , 
                               
                                 
                                   f 
                                   vis 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                             
                             ) 
                           
                         
                         
                           Pr 
                            
                           
                             ( 
                             
                               
                                 
                                   f 
                                   bbox 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               , 
                               
                                 
                                   f 
                                   kbase 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               , 
                               
                                 
                                   f 
                                   vis 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                             
                             ) 
                           
                         
                       
                       × 
                       
                         
                           Pr 
                            
                           
                             ( 
                             
                               
                                 
                                   f 
                                   bbox 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               , 
                               
                                 
                                   f 
                                   kbase 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               , 
                               
                                 
                                   f 
                                   vis 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                             
                             ) 
                           
                         
                         
                           Pr 
                            
                           
                             ( 
                             
                               
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                                 = 
                                 0 
                               
                               , 
                               
                                 
                                   f 
                                   bbox 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               , 
                               
                                 
                                   f 
                                   kbase 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               , 
                               
                                 
                                   f 
                                   vis 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     = 
                     
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               1 
                             
                             , 
                             
                               
                                 f 
                                 bbox 
                               
                                
                               
                                 ( 
                                 I 
                                 ) 
                               
                             
                             , 
                             
                               
                                 f 
                                 kbase 
                               
                                
                               
                                 ( 
                                 I 
                                 ) 
                               
                             
                             , 
                             
                               
                                 f 
                                 vis 
                               
                                
                               
                                 ( 
                                 I 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               0 
                             
                             , 
                             
                               
                                 f 
                                 bbox 
                               
                                
                               
                                 ( 
                                 I 
                                 ) 
                               
                             
                             , 
                             
                               
                                 f 
                                 kbase 
                               
                                
                               
                                 ( 
                                 I 
                                 ) 
                               
                             
                             , 
                             
                               
                                 f 
                                 vis 
                               
                                
                               
                                 ( 
                                 I 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0044]    In ƒ bbox (I), if the realization of variable G w     i    for each word w i  is denoted by g i ε{0,1} given I, then without loss of generality, for each j, we can split ƒ bbox (I) as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       f 
                       bbox 
                     
                      
                     
                       ( 
                       I 
                       ) 
                     
                   
                   = 
                   
                     ( 
                     
                       
                         
                           G 
                           
                             w 
                             j 
                           
                         
                         = 
                         
                           g 
                           j 
                         
                       
                       , 
                       
                         
                           ⋃ 
                           
                             i 
                             ≠ 
                             j 
                           
                         
                          
                         
                           ( 
                           
                             
                               G 
                               
                                 w 
                                 i 
                               
                             
                             = 
                             
                               g 
                               i 
                             
                           
                           ) 
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0045]    We now evaluate the joint probability in the numerator and denominator of l w     j    separately, using Eq. 3. For a realization a j ε{0,1} of the random variable A w     i   , we can factor the joint probability (using the chain rule of probability) into a prior and a series of conditional probabilities, as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     Pr 
                      
                     
                       ( 
                       
                         
                           
                             A 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             a 
                             j 
                           
                         
                         , 
                         
                           
                             f 
                             bbox 
                           
                            
                           
                             ( 
                             I 
                             ) 
                           
                         
                         , 
                         
                           
                             f 
                             kbase 
                           
                            
                           
                             ( 
                             I 
                             ) 
                           
                         
                         , 
                         
                           
                             f 
                             vis 
                           
                            
                           
                             ( 
                             I 
                             ) 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             G 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             g 
                             j 
                           
                         
                         ) 
                       
                     
                     × 
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             A 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             
                               
                                 a 
                                 j 
                               
                                
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             
                               g 
                               j 
                             
                           
                         
                         ) 
                       
                     
                     × 
                     
                       Pr 
                       ( 
                       
                         
                           
                             
                               
                                 ⋃ 
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                                
                               
                                 ( 
                                 
                                   
                                     G 
                                     
                                       w 
                                       i 
                                     
                                   
                                   = 
                                   
                                     g 
                                     i 
                                   
                                 
                                 ) 
                               
                             
                              
                             
                               A 
                               
                                 w 
                                 j 
                               
                             
                           
                           = 
                           
                             a 
                             j 
                           
                         
                         , 
                         
                           
                             G 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             g 
                             j 
                           
                         
                       
                       ) 
                     
                     × 
                     
                       Pr 
                       ( 
                       
                         
                           
                             
                               f 
                               kbase 
                             
                              
                             
                               ( 
                               I 
                               ) 
                             
                           
                            
                           
                             
                               ⋃ 
                               
                                 i 
                                 ≠ 
                                 j 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   G 
                                   
                                     w 
                                     i 
                                   
                                 
                                 = 
                                 
                                   g 
                                   i 
                                 
                               
                               ) 
                             
                           
                         
                         , 
                         
                           
                             A 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             a 
                             j 
                           
                         
                         , 
                         
                           
                             G 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             g 
                             j 
                           
                         
                       
                       ) 
                     
                     × 
                     
                       Pr 
                       ( 
                       
                         
                           
                             
                               f 
                               vis 
                             
                              
                             
                               ( 
                               I 
                               ) 
                             
                           
                            
                           
                             
                               f 
                               kbase 
                             
                              
                             
                               ( 
                               I 
                               ) 
                             
                           
                         
                         , 
                         
                           
                             ⋃ 
                             
                               i 
                               ≠ 
                               j 
                             
                           
                            
                           
                             ( 
                             
                               
                                 G 
                                 
                                   w 
                                   i 
                                 
                               
                               = 
                               
                                 g 
                                 i 
                               
                             
                             ) 
                           
                         
                         , 
                         
                           
                             A 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             a 
                             j 
                           
                         
                         , 
                         
                           
                             G 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             g 
                             j 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0046]    The odds in Eq. 1 can now be factored using Eq. 2 and 4: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       l 
                       
                         w 
                         j 
                       
                     
                      
                     
                       ( 
                       I 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               A 
                               
                                 w 
                                 j 
                               
                             
                             = 
                             
                               
                                 1 
                                  
                                 
                                   G 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               A 
                               
                                 w 
                                 j 
                               
                             
                             = 
                             
                               
                                 0 
                                  
                                 
                                   G 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                     
                     × 
                     
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 
                                   
                                     ⋃ 
                                     
                                       i 
                                       ≠ 
                                       j 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         G 
                                         
                                           w 
                                           i 
                                         
                                       
                                       = 
                                       
                                         g 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               = 
                               1 
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 
                                   
                                     ⋃ 
                                     
                                       i 
                                       ≠ 
                                       j 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         G 
                                         
                                           w 
                                           i 
                                         
                                       
                                       = 
                                       
                                         g 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               = 
                               0 
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                     
                     × 
                     
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 
                                   
                                     f 
                                     kbase 
                                   
                                    
                                   
                                     ( 
                                     I 
                                     ) 
                                   
                                 
                                  
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               = 
                               1 
                             
                             , 
                             
                               
                                 ⋃ 
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                                
                               
                                 ( 
                                 
                                   
                                     G 
                                     
                                       w 
                                       i 
                                     
                                   
                                   = 
                                   
                                     g 
                                     i 
                                   
                                 
                                 ) 
                               
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 
                                   
                                     f 
                                     kbase 
                                   
                                    
                                   
                                     ( 
                                     I 
                                     ) 
                                   
                                 
                                  
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               = 
                               0 
                             
                             , 
                             
                               
                                 ⋃ 
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                                
                               
                                 ( 
                                 
                                   
                                     G 
                                     
                                       w 
                                       i 
                                     
                                   
                                   = 
                                   
                                     g 
                                     i 
                                   
                                 
                                 ) 
                               
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                     
                     × 
                     
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 
                                   
                                     f 
                                     vis 
                                   
                                    
                                   
                                     ( 
                                     I 
                                     ) 
                                   
                                 
                                  
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               = 
                               1 
                             
                             , 
                             
                               
                                 f 
                                 kbase 
                               
                                
                               
                                 ( 
                                 I 
                                 ) 
                               
                             
                             , 
                             
                               
                                 ⋃ 
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                                
                               
                                 ( 
                                 
                                   
                                     G 
                                     
                                       w 
                                       i 
                                     
                                   
                                   = 
                                   
                                     g 
                                     i 
                                   
                                 
                                 ) 
                               
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 
                                   
                                     f 
                                     vis 
                                   
                                    
                                   
                                     ( 
                                     I 
                                     ) 
                                   
                                 
                                  
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               = 
                               0 
                             
                             , 
                             
                               
                                 f 
                                 kbase 
                               
                                
                               
                                 ( 
                                 I 
                                 ) 
                               
                             
                             , 
                             
                               
                                 ⋃ 
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                                
                               
                                 ( 
                                 
                                   
                                     G 
                                     
                                       w 
                                       i 
                                     
                                   
                                   = 
                                   
                                     g 
                                     i 
                                   
                                 
                                 ) 
                               
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0047]    Note that the ratio of priors 
         [0000]    
       
         
           
             
               
                 
                   Pr 
                    
                   
                     ( 
                     
                       
                         G 
                         
                           w 
                           j 
                         
                       
                       = 
                       
                         g 
                         j 
                       
                     
                     ) 
                   
                 
                 
                   Pr 
                    
                   
                     ( 
                     
                       
                         G 
                         
                           w 
                           j 
                         
                       
                       = 
                       
                         g 
                         j 
                       
                     
                     ) 
                   
                 
               
               = 
               1 
             
             , 
           
         
       
     
         [0000]    and hence is eliminated. The ratio 
         [0000]    
       
         
           
             
               Pr 
                
               
                 ( 
                 
                   
                     A 
                     
                       w 
                       j 
                     
                   
                   = 
                   
                     
                       1 
                        
                       
                         G 
                         
                           w 
                           j 
                         
                       
                     
                     = 
                     
                       g 
                       j 
                     
                   
                 
                 ) 
               
             
             
               Pr 
                
               
                 ( 
                 
                   
                     A 
                     
                       w 
                       j 
                     
                   
                   = 
                   
                     
                       0 
                        
                       
                         G 
                         
                           w 
                           j 
                         
                       
                     
                     = 
                     
                       g 
                       j 
                     
                   
                 
                 ) 
               
             
           
         
       
     
         [0000]    is a sanity check on the black-box for each word. For G w     j   =1, it can be paraphrased as “Given that word w j  is guessed by the black-box for I, what are the odds of it being correct?”. Naturally, a higher odds indicates that the black-box has greater precision in guesses (i.e., when w j  is guessed, it is usually correct). A similar paraphrasing can be done for G w     i   =0, where higher odds implies lower word-specific recall in the black-box guesses. A good annotation system should be able to achieve independently (word-specific) and collectively (overall) good precision and recall. These probability ratios therefore give the meta-learner indications about the black-box model&#39;s performance for each word in the vocabulary. 
         [0048]    When g j =1, the ratio 
         [0000]    
       
         
           
             
               Pr 
                
               
                 ( 
                 
                   
                     
                       
                         
                           ⋃ 
                           
                             i 
                             ≠ 
                             j 
                           
                         
                          
                         
                           ( 
                           
                             
                               G 
                               
                                 w 
                                 i 
                               
                             
                             = 
                             
                               g 
                               i 
                             
                           
                           ) 
                         
                       
                        
                       
                         A 
                         
                           w 
                           j 
                         
                       
                     
                     = 
                     1 
                   
                   , 
                   
                     
                       G 
                       
                         w 
                         j 
                       
                     
                     = 
                     
                       g 
                       j 
                     
                   
                 
                 ) 
               
             
             
               Pr 
                
               
                 ( 
                 
                   
                     
                       
                         
                           ⋃ 
                           
                             i 
                             ≠ 
                             j 
                           
                         
                          
                         
                           ( 
                           
                             
                               G 
                               
                                 w 
                                 i 
                               
                             
                             = 
                             
                               g 
                               i 
                             
                           
                           ) 
                         
                       
                        
                       
                         A 
                         
                           w 
                           j 
                         
                       
                     
                     = 
                     0 
                   
                   , 
                   
                     
                       G 
                       
                         w 
                         j 
                       
                     
                     = 
                     
                       g 
                       j 
                     
                   
                 
                 ) 
               
             
           
         
       
     
         [0000]    in Eq. 5 relates each correctly/wrongly guessed word w j  to how every other word w i , i≠j is guessed by the black-box. This component has strong ties with the concept of co-occurrence popular in the language modeling community, the difference being that here it models the word co-occurrence of the black-box&#39;s outputs with respect to ground-truth. Similarly, for g j =0, it models how certain words do not co-occur in the black-box&#39;s guesses, given the ground-truth. Since the meta-leamer makes decisions about each word independently, it is intuitive to separate them out in this ratio as well. That is, the question of whether word w i  is guessed or not, given that another word w j  is correctly/wrongly guessed, is treated independently. Furthermore, efficiency and robustness become major issues in modeling joint probability over a large number of random variables, given limited data. Considering these factors, we assume the guessing of each word w i  conditionally independent of each other, given a correctly/wrongly guessed word w j , leading to the following approximation: 
         [0000]    
       
         
           
             
               
                 
                   
                     Pr 
                     ( 
                     
                       
                         
                           
                             
                               ⋃ 
                               
                                 i 
                                 ≠ 
                                 j 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   G 
                                   
                                     w 
                                     i 
                                   
                                 
                                 = 
                                 
                                   g 
                                   i 
                                 
                               
                               ) 
                             
                           
                            
                           
                             A 
                             
                               w 
                               j 
                             
                           
                         
                         = 
                         
                           a 
                           j 
                         
                       
                       , 
                       
                         
                           G 
                           
                             w 
                             j 
                           
                         
                         = 
                         
                           g 
                           j 
                         
                       
                     
                     ) 
                   
                   ≈ 
                   
                     
                       ∏ 
                       
                         i 
                         ≠ 
                         j 
                       
                     
                      
                     
                       Pr 
                       ( 
                       
                         
                           
                             G 
                             
                               w 
                               i 
                             
                           
                           = 
                           
                             
                               
                                 g 
                                 i 
                               
                                
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             
                               a 
                               j 
                             
                           
                         
                         , 
                         
                           
                             G 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             g 
                             j 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0049]    The ratio can then be written as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   ⋃ 
                                   
                                     i 
                                     ≠ 
                                     j 
                                   
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       G 
                                       
                                         w 
                                         i 
                                       
                                     
                                     = 
                                     
                                       g 
                                       i 
                                     
                                   
                                   ) 
                                 
                               
                                
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             1 
                           
                           , 
                           
                             
                               G 
                               
                                 w 
                                 j 
                               
                             
                             = 
                             
                               g 
                               j 
                             
                           
                         
                         ) 
                       
                     
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   ⋃ 
                                   
                                     i 
                                     ≠ 
                                     j 
                                   
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       G 
                                       
                                         w 
                                         i 
                                       
                                     
                                     = 
                                     
                                       g 
                                       i 
                                     
                                   
                                   ) 
                                 
                               
                                
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             0 
                           
                           , 
                           
                             
                               G 
                               
                                 w 
                                 j 
                               
                             
                             = 
                             
                               g 
                               j 
                             
                           
                         
                         ) 
                       
                     
                   
                   = 
                   
                     
                       ∏ 
                       
                         i 
                         ≠ 
                         j 
                       
                     
                      
                     
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 G 
                                 
                                   w 
                                   i 
                                 
                               
                               = 
                               
                                 
                                   
                                     g 
                                     i 
                                   
                                    
                                   
                                     A 
                                     
                                       w 
                                       j 
                                     
                                   
                                 
                                 = 
                                 1 
                               
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                       
                         Pr 
                          
                         
                           ( 
                           
                             
                               
                                 G 
                                 
                                   w 
                                   i 
                                 
                               
                               = 
                               
                                 
                                   
                                     g 
                                     i 
                                   
                                    
                                   
                                     A 
                                     
                                       w 
                                       j 
                                     
                                   
                                 
                                 = 
                                 0 
                               
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 g 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0050]    The problem of conditional multi-word co-occurrence modeling has been effectively transformed into that of pairwise co-occurrences, which is attractive in terms of modeling, representation, and efficiency. While co-occurrence really happens when g i =g j =1, the other combinations of values can also be useful, e.g., how the frequency of certain word pairs not being both guessed differs according to the correctness of these guesses. The usefulness of component ratios of this product to meta-learning, namely 
         [0000]    
       
         
           
             
               
                 Pr 
                  
                 
                   ( 
                   
                     
                       
                         G 
                         
                           w 
                           i 
                         
                       
                       = 
                       
                         
                           
                             g 
                             i 
                           
                            
                           
                             A 
                             
                               w 
                               j 
                             
                           
                         
                         = 
                         1 
                       
                     
                     , 
                     
                       
                         G 
                         
                           w 
                           j 
                         
                       
                       = 
                       
                         g 
                         j 
                       
                     
                   
                   ) 
                 
               
               
                 Pr 
                  
                 
                   ( 
                   
                     
                       
                         G 
                         
                           w 
                           i 
                         
                       
                       = 
                       
                         
                           
                             g 
                             i 
                           
                            
                           
                             A 
                             
                               w 
                               j 
                             
                           
                         
                         = 
                         0 
                       
                     
                     , 
                     
                       
                         G 
                         
                           w 
                           j 
                         
                       
                       = 
                       
                         g 
                         j 
                       
                     
                   
                   ) 
                 
               
             
             , 
           
         
       
     
         [0000]    can again be justified based on ideas of inductive transfer. The following examples illustrate this:
       Some visually coherent objects do not often co-occur in the same natural scene. If the black-box strongly associates orange color with the setting sun, it may often be making the mistake of labeling orange (fruit) as the sun, or vice-versa, but both occurring in the same scene may be unlikely. In this case, with w i =‘oranges’ and w j =‘sun’ (or vice-versa), w i  and w j  will frequently co-occur in the black-box&#39;s guesses, but in most such instances, one guess will be wrong. This will imply low values of the above ratio for this word pair, which in turn models the fact that the black-box mistakenly confuses one word for another, for visual coherence or otherwise.   Some objects that are visually coherent also frequently co-occur in natural scenes. For example, in images depicting beaches, ‘water’, and ‘sky’ often co-occur as correct tags. Since both are blue, the black-box may mistake one for the other. However, such mistakes are acceptable if both are actually correct tags for the image. In such cases, the above ratio is likely to have high values for this word pair, modeling the fact that evidence about one word reinforces belief in another, for visual coherence coupled with co-occurrence (See  FIG. 3 , box A). Highlighted in  FIG. 3  are cases interesting from the meta-learner&#39;s viewpoint. For example, box A is read as “when ‘water’ is a correct guess, ‘sky’ is also guessed.”   For some word w j , the black-box may not have effectively learned anything. This may happen due to lack of good training images, inability to capture apt visual properties, or simply the absence of the word in V bbox . For example, users may be providing the word w j =‘feline’ as ground-truth for images containing w i =‘cat’, while only the latter may be in the black-box&#39;s vocabulary. In this case, G w     j   =0, and the ratio       
 
         [0000]    
       
         
           
             
               Pr 
                
               
                 ( 
                 
                   
                     
                       G 
                       
                         w 
                         i 
                       
                     
                     = 
                     
                       
                         
                           g 
                           i 
                         
                          
                         
                           A 
                           
                             w 
                             j 
                           
                         
                       
                       = 
                       1 
                     
                   
                   , 
                   
                     
                       G 
                       
                         w 
                         j 
                       
                     
                     = 
                     0 
                   
                 
                 ) 
               
             
             
               Pr 
                
               
                 ( 
                 
                   
                     
                       G 
                       
                         w 
                         i 
                       
                     
                     = 
                     
                       
                         
                           g 
                           i 
                         
                          
                         
                           A 
                           
                             w 
                             j 
                           
                         
                       
                       = 
                       0 
                     
                   
                   , 
                   
                     
                       G 
                       
                         w 
                         j 
                       
                     
                     = 
                     0 
                   
                 
                 ) 
               
             
           
         
       
     
         [0000]    will be high. This is a direct case of inductive transfer, where the training on one word induces guesses at another word in the vocabulary (See  FIG. 3 , box C). Other such scenarios where this ratio provides useful information can be conceived (See  FIG. 3 , box B, D). For the term 
         [0000]    
       
         
           
             
               Pr 
                
               
                 ( 
                 
                   
                     
                       
                         
                           f 
                           kbase 
                         
                          
                         
                           ( 
                           I 
                           ) 
                         
                       
                        
                       
                         A 
                         
                           w 
                           j 
                         
                       
                     
                     = 
                     1 
                   
                   , 
                   
                     
                       ⋃ 
                       
                         i 
                         ≠ 
                         j 
                       
                     
                      
                     
                       ( 
                       
                         
                           G 
                           
                             w 
                             i 
                           
                         
                         = 
                         
                           g 
                           i 
                         
                       
                       ) 
                     
                   
                   , 
                   
                     
                       G 
                       
                         w 
                         j 
                       
                     
                     = 
                     
                       g 
                       j 
                     
                   
                 
                 ) 
               
             
             
               Pr 
               ( 
               
                 
                   
                     
                       
                         f 
                         kbase 
                       
                        
                       
                         ( 
                         I 
                         ) 
                       
                     
                      
                     
                       A 
                       
                         w 
                         j 
                       
                     
                   
                   = 
                   0 
                 
                 , 
                 
                   
                     ⋃ 
                     
                       i 
                       ≠ 
                       j 
                     
                   
                    
                   
                     ( 
                     
                       
                         G 
                         
                           w 
                           i 
                         
                       
                       = 
                       
                         g 
                         i 
                       
                     
                     ) 
                   
                 
                 , 
                 
                   
                     G 
                     
                       w 
                       j 
                     
                   
                   = 
                   
                     g 
                     j 
                   
                 
               
             
           
         
       
     
         [0000]    in Eq. 5, since we deal with each word separately, the numerical abstractions ƒ kbase (I) relating WordNet to the model&#39;s guesses/ground-truth can be separated out for each word (conditionally independent of other words). Therefore, we can write 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               f 
                               kbase 
                             
                              
                             
                               ( 
                               I 
                               ) 
                             
                           
                           | 
                           - 
                         
                         ) 
                       
                     
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               f 
                               kbase 
                             
                              
                             
                               ( 
                               I 
                               ) 
                             
                           
                           | 
                           - 
                         
                         ) 
                       
                     
                   
                   ≈ 
                   
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               
                                 ρ 
                                 j 
                               
                               | 
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             1 
                           
                           , 
                           - 
                         
                         ) 
                       
                     
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               
                                 ρ 
                                 j 
                               
                               | 
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             0 
                           
                           , 
                           - 
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0054]    Finally, 
         [0000]    
       
         
           
             
               Pr 
                
               
                 ( 
                 
                   
                     
                       
                         
                           f 
                           vis 
                         
                          
                         
                           ( 
                           I 
                           ) 
                         
                       
                       | 
                       
                         A 
                         
                           w 
                           j 
                         
                       
                     
                     = 
                     1 
                   
                   , 
                   
                     
                       f 
                       kbase 
                     
                      
                     
                       ( 
                       I 
                       ) 
                     
                   
                   , 
                   
                     
                       ⋃ 
                       
                         i 
                         ≠ 
                         j 
                       
                     
                      
                     
                       ( 
                       
                         
                           G 
                           
                             w 
                             i 
                           
                         
                         = 
                         
                           g 
                           i 
                         
                       
                       ) 
                     
                   
                   , 
                   
                     
                       G 
                       
                         w 
                         j 
                       
                     
                     = 
                     
                       g 
                       j 
                     
                   
                 
                 ) 
               
             
             
               Pr 
                
               
                 ( 
                 
                   
                     
                       
                         
                           f 
                           vis 
                         
                          
                         
                           ( 
                           I 
                           ) 
                         
                       
                       | 
                       
                         A 
                         
                           w 
                           j 
                         
                       
                     
                     = 
                     0 
                   
                   , 
                   
                     
                       f 
                       kbase 
                     
                      
                     
                       ( 
                       I 
                       ) 
                     
                   
                   , 
                   
                     
                       ⋃ 
                       
                         i 
                         ≠ 
                         j 
                       
                     
                      
                     
                       ( 
                       
                         
                           G 
                           
                             w 
                             i 
                           
                         
                         = 
                         
                           g 
                           i 
                         
                       
                       ) 
                     
                   
                   , 
                   
                     
                       G 
                       
                         w 
                         j 
                       
                     
                     = 
                     
                       g 
                       j 
                     
                   
                 
                 ) 
               
             
           
         
       
     
         [0000]    in Eq. 5 can be simplified, since ƒ vis (I) is the meta-learner&#39;s own visual representation ƒ vis (I), unrelated to the black-box&#39;s visual abstraction used for making guesses, and hence also the semantic relationship ƒ kbase ( 1 ) Therefore, we re-write 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   f 
                                   vis 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               | 
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             1 
                           
                           , 
                           - 
                         
                         ) 
                       
                     
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   f 
                                   vis 
                                 
                                  
                                 
                                   ( 
                                   I 
                                   ) 
                                 
                               
                               | 
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             0 
                           
                           , 
                           - 
                         
                         ) 
                       
                     
                   
                   ≈ 
                   
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               ( 
                               
                                 
                                   h 
                                   1 
                                 
                                 , 
                                 … 
                                  
                                 
                                     
                                 
                                 , 
                                 
                                   h 
                                   D 
                                 
                               
                               ) 
                             
                             | 
                             
                               A 
                               
                                 w 
                                 j 
                               
                             
                           
                           = 
                           1 
                         
                         ) 
                       
                     
                     
                       Pr 
                        
                       
                         ( 
                         
                           
                             
                               ( 
                               
                                 
                                   h 
                                   1 
                                 
                                 , 
                                 … 
                                  
                                 
                                     
                                 
                                 , 
                                 
                                   h 
                                   D 
                                 
                               
                               ) 
                             
                             | 
                             
                               A 
                               
                                 w 
                                 j 
                               
                             
                           
                           = 
                           0 
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0000]    which is essentially the ratio of conditional probabilities of the visual features extracted by the meta-learner, given w j  is correct/incorrect. A strong support for the independence assumptions made in this formulation comes from the superior experimental results. Putting everything together, and taking logarithm (monotonically increasing) to get around issues of machine precision, we can re-write Eq. 5 as a logit: 
         [0000]    
       
         
           
             
               
                 
                   
                     log 
                      
                     
                         
                     
                      
                     
                       
                          
                         
                           w 
                           j 
                         
                       
                        
                       
                         ( 
                         I 
                         ) 
                       
                     
                   
                   = 
                   
                     
                       log 
                       ( 
                       
                         
                           Pr 
                            
                           
                             ( 
                             
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                               = 
                               
                                 
                                   1 
                                   | 
                                   
                                     G 
                                     
                                       w 
                                       j 
                                     
                                   
                                 
                                 = 
                                 
                                   g 
                                   j 
                                 
                               
                             
                             ) 
                           
                         
                         
                           1 
                           - 
                           
                             Pr 
                              
                             
                               ( 
                               
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                                 = 
                                 
                                   
                                     1 
                                     | 
                                     
                                       G 
                                       
                                         w 
                                         j 
                                       
                                     
                                   
                                   = 
                                   
                                     g 
                                     j 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                       ) 
                     
                     + 
                     
                       
                         ∑ 
                         
                           i 
                           ≠ 
                           j 
                         
                       
                        
                       
                         log 
                          
                         
                           ( 
                           
                             
                               Pr 
                                
                               
                                 ( 
                                 
                                   
                                     
                                       G 
                                       
                                         w 
                                         i 
                                       
                                     
                                     = 
                                     
                                       
                                         
                                           g 
                                           i 
                                         
                                         | 
                                         
                                           A 
                                           
                                             w 
                                             j 
                                           
                                         
                                       
                                       = 
                                       1 
                                     
                                   
                                   , 
                                   
                                     
                                       G 
                                       
                                         w 
                                         j 
                                       
                                     
                                     = 
                                     
                                       g 
                                       j 
                                     
                                   
                                 
                                 ) 
                               
                             
                             
                               Pr 
                                
                               
                                 ( 
                                 
                                   
                                     
                                       G 
                                       
                                         w 
                                         i 
                                       
                                     
                                     = 
                                     
                                       
                                         
                                           g 
                                           i 
                                         
                                         | 
                                         
                                           A 
                                           
                                             w 
                                             j 
                                           
                                         
                                       
                                       = 
                                       0 
                                     
                                   
                                   , 
                                   
                                     
                                       G 
                                       
                                         w 
                                         j 
                                       
                                     
                                     = 
                                     
                                       g 
                                       j 
                                     
                                   
                                 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                     
                     + 
                     
                       log 
                        
                       
                         ( 
                         
                           
                             Pr 
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       ρ 
                                       j 
                                     
                                     | 
                                     
                                       A 
                                       
                                         w 
                                         j 
                                       
                                     
                                   
                                   = 
                                   1 
                                 
                                 , 
                                 
                                   
                                     ⋃ 
                                     
                                       i 
                                       ≠ 
                                       j 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         G 
                                         
                                           w 
                                           i 
                                         
                                       
                                       = 
                                       
                                         g 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                                 , 
                                 
                                   
                                     G 
                                     
                                       w 
                                       j 
                                     
                                   
                                   = 
                                   
                                     g 
                                     j 
                                   
                                 
                               
                               ) 
                             
                           
                           
                             Pr 
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       ρ 
                                       j 
                                     
                                     | 
                                     
                                       A 
                                       
                                         w 
                                         j 
                                       
                                     
                                   
                                   = 
                                   0 
                                 
                                 , 
                                 
                                   
                                     ⋃ 
                                     
                                       i 
                                       ≠ 
                                       j 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         G 
                                         
                                           w 
                                           i 
                                         
                                       
                                       = 
                                       
                                         g 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                                 , 
                                 
                                   
                                     G 
                                     
                                       w 
                                       j 
                                     
                                   
                                   = 
                                   
                                     g 
                                     j 
                                   
                                 
                               
                               ) 
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       log 
                        
                       
                         ( 
                         
                           
                             Pr 
                              
                             
                               ( 
                               
                                 
                                   h 
                                   1 
                                 
                                 , 
                                 … 
                                  
                                 
                                     
                                 
                                 , 
                                 
                                   
                                     
                                       h 
                                       D 
                                     
                                     | 
                                     
                                       A 
                                       
                                         w 
                                         j 
                                       
                                     
                                   
                                   = 
                                   1 
                                 
                               
                               ) 
                             
                           
                           
                             Pr 
                              
                             
                               ( 
                               
                                 
                                   h 
                                   1 
                                 
                                 , 
                                 … 
                                  
                                 
                                     
                                 
                                 , 
                                 
                                   
                                     
                                       h 
                                       D 
                                     
                                     | 
                                     
                                       A 
                                       
                                         w 
                                         j 
                                       
                                     
                                   
                                   = 
                                   0 
                                 
                               
                               ) 
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
         [0055]    This logit is used by our meta-learner for annotation, where a higher value for a word indicates a higher odds in its support, given all pertinent information. What words to eventually use as annotation for an image I can then be decided in at least two different ways, as found in the literature:
       Top r: After ordering all words w j εV in the increasing magnitude of log l w     j   (I) to obtain a rank ordering, we annotate I using the top r ranked words.   Threshold r %: We can annotate I by thresholding at the top r percentile of the range of log l w     i   (I) values for the given image over all the words.       
 
         [0058]    The formulation at this point is fairly generic, particularly with respect to harnessing of WordNet (ƒ kbase (I)) and the visual representation (ƒ vis (I)) We now go into specifics of a particular form of these functions that we use in experiments. Furthermore we consider robustness issues that the meta-learner runs into, which is further discussed below. 
       Estimation and Smoothing 
       [0059]    The crux of the meta-learner is Eq. 10, which takes in an image I and the black-box guesses for it, and subsequently computes odds for each word. The probabilities involving A w     j    must all be estimated from any training data that may be available to the meta-learner. In a temporal setting, there will be seed training data to start with, and the estimates will be refined as and when more data/feedback becomes available. Let us consider the estimation of each term separately, given a training set of size L, consisting of images {I (1) , . . . , I (L) }, the corresponding word guesses made by the black-box, {ƒ bbox (I (1) ), . . . , ƒ bbox (I (L) )}, and the actual ground-truth/feedback, {ƒ gtruth (I (1) ), . . . , ƒ gtruth (I (L) )}. To make estimation lightweight, and thus scalable, each component of the estimation is based on empirical frequencies, and is a fully deterministic process. Moreover, this property of our model estimation makes it adaptable to incremental or decremental learning. 
         [0060]    The probability Pr(A w     j   =|G w     j   =g j ) in Eq. 10 can be estimated from the size L training data as follows: 
         [0000]    
       
         
           
             
               
                 Pr 
                 ^ 
               
                
               
                 ( 
                 
                   
                     A 
                     
                       w 
                       j 
                     
                   
                   = 
                   
                     
                       1 
                       | 
                       
                         G 
                         
                           w 
                           j 
                         
                       
                     
                     = 
                     
                       g 
                       j 
                     
                   
                 
                 ) 
               
             
             = 
             
               
                 
                   ∑ 
                   
                     n 
                     = 
                     1 
                   
                   L 
                 
                  
                 
                   I 
                    
                   
                     { 
                     
                       
                         G 
                         
                           w 
                           j 
                         
                         
                           ( 
                           n 
                           ) 
                         
                       
                       = 
                       
                         
                           
                             
                               g 
                               j 
                             
                             &amp; 
                           
                            
                           
                               
                           
                            
                           
                             A 
                             
                               w 
                               j 
                             
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         = 
                         1 
                       
                     
                     } 
                   
                 
               
               
                 
                   ∑ 
                   
                     n 
                     = 
                     1 
                   
                   L 
                 
                  
                 
                   I 
                    
                   
                     { 
                     
                       
                         G 
                         
                           w 
                           j 
                         
                         
                           ( 
                           n 
                           ) 
                         
                       
                       = 
                       
                         g 
                         j 
                       
                     
                     } 
                   
                 
               
             
           
         
       
     
         [0061]    Here, I(•) is the indicator function. A natural issue of robustness arises when the training set contains too few or no samples for G w     j     (n) =1, where estimation will be poor or impossible. Therefore, we perform a standard interpolation-based smoothing of probabilities. For this we require a prior estimate, which we compute as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         Pr 
                         ^ 
                       
                       prior 
                     
                      
                     
                       ( 
                       g 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         K 
                       
                        
                       
                         
                           ∑ 
                           
                             n 
                             = 
                             1 
                           
                           L 
                         
                          
                         
                           I 
                            
                           
                             { 
                             
                               
                                 G 
                                 
                                   w 
                                   i 
                                 
                                 
                                   ( 
                                   n 
                                   ) 
                                 
                               
                               = 
                               
                                 
                                   
                                     g 
                                     &amp; 
                                   
                                    
                                   
                                       
                                   
                                    
                                   
                                     A 
                                     
                                       w 
                                       i 
                                     
                                     
                                       ( 
                                       n 
                                       ) 
                                     
                                   
                                 
                                 = 
                                 1 
                               
                             
                             } 
                           
                         
                       
                     
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         K 
                       
                        
                       
                         
                           ∑ 
                           
                             n 
                             = 
                             1 
                           
                           L 
                         
                          
                         
                           I 
                            
                           
                             { 
                             
                               
                                 G 
                                 
                                   w 
                                   i 
                                 
                                 
                                   ( 
                                   n 
                                   ) 
                                 
                               
                               = 
                               g 
                             
                             } 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where gε{0, 1}. For g=1 (or 0), it is the estimated probability that a word that is guessed (or not guessed) is correct. The word-specific estimates are interpolated with the prior to get the final estimates as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Pr 
                       ~ 
                     
                      
                     
                       ( 
                       
                         
                           A 
                           
                             w 
                             j 
                           
                         
                         = 
                         
                           
                             1 
                             | 
                             
                               G 
                               
                                 w 
                                 j 
                               
                             
                           
                           = 
                           
                             g 
                             j 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 Pr 
                                 ~ 
                               
                               prior 
                             
                              
                             
                               ( 
                               
                                 g 
                                 j 
                               
                               ) 
                             
                           
                         
                         
                           
                             m 
                             ≤ 
                             
                               1 
                                
                               
                                 ( 
                                 14 
                                 ) 
                               
                             
                           
                         
                       
                       
                         
                           
                             
                               
                                 1 
                                 m 
                               
                                
                               
                                 
                                   
                                     Pr 
                                     ^ 
                                   
                                   prior 
                                 
                                  
                                 
                                   ( 
                                   
                                     g 
                                     j 
                                   
                                   ) 
                                 
                               
                             
                             + 
                             
                               
                                 m 
                                 
                                   m 
                                   + 
                                   1 
                                 
                               
                                
                               
                                 
                                   Pr 
                                   ^ 
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       A 
                                       
                                         w 
                                         j 
                                       
                                     
                                     = 
                                     
                                       
                                         1 
                                         | 
                                         
                                           G 
                                           
                                             w 
                                             j 
                                           
                                         
                                       
                                       = 
                                       
                                         g 
                                         j 
                                       
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             m 
                             &gt; 
                             1 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where m=Σ n=1   L I{G w     j     (n) =g j }, the number of instances out of L where W j  is guessed (or not guessed, depending upon g j ). 
         [0062]    The probability Pr(G w     i   =g i |A w     j   =1, G w     j   =g j ) in Eq. 10 can be estimated from the training data as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Pr 
                       ^ 
                     
                      
                     
                       ( 
                       
                         
                           
                             G 
                             
                               w 
                               i 
                             
                           
                           = 
                           
                             
                               
                                 g 
                                 i 
                               
                               | 
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             1 
                           
                         
                         , 
                         
                           
                             G 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             g 
                             j 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           1 
                         
                         L 
                       
                        
                       
                         I 
                          
                         
                           { 
                           
                             
                               G 
                               
                                 w 
                                 i 
                               
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                             = 
                             
                               
                                 
                                   
                                     g 
                                     i 
                                   
                                   &amp; 
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   G 
                                   
                                     w 
                                     j 
                                   
                                   
                                     ( 
                                     n 
                                     ) 
                                   
                                 
                               
                               = 
                               
                                 
                                   
                                     
                                       g 
                                       j 
                                     
                                     &amp; 
                                   
                                    
                                   
                                       
                                   
                                    
                                   
                                     A 
                                     
                                       w 
                                       j 
                                     
                                     
                                       ( 
                                       n 
                                       ) 
                                     
                                   
                                 
                                 = 
                                 1 
                               
                             
                           
                           } 
                         
                       
                     
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           1 
                         
                         L 
                       
                        
                       
                         I 
                          
                         
                           { 
                           
                             
                               G 
                               
                                 w 
                                 j 
                               
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                             = 
                             
                               
                                 
                                   
                                     g 
                                     j 
                                   
                                   &amp; 
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                   
                                     ( 
                                     n 
                                     ) 
                                   
                                 
                               
                               = 
                               1 
                             
                           
                           } 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0063]    Here, we have a more serious robustness issue, since many word pairs may not appear in the black-box&#39;s guesses. A popular smoothing technique for word pair co-occurrence modeling is similarity-based smoothing, which is appropriate in this case, since semantic similarity based propagation of information is meaningful here. Given a WordNet-based semantic similarity measure W(w i , w j ) between word pairs w i  and w j , the smoothed estimates are given by: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Pr 
                       ~ 
                     
                      
                     
                       ( 
                       
                         
                           
                             G 
                             
                               w 
                               i 
                             
                           
                           = 
                           
                             
                               
                                 g 
                                 i 
                               
                               | 
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             1 
                           
                         
                         , 
                         
                           
                             G 
                             
                               w 
                               j 
                             
                           
                           = 
                           
                             g 
                             j 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         k 
                         = 
                         1 
                       
                       K 
                     
                      
                     
                       
                         
                           W 
                            
                           
                             ( 
                             
                               
                                 w 
                                 j 
                               
                               , 
                               
                                 w 
                                 k 
                               
                             
                             ) 
                           
                         
                         Z 
                       
                        
                       
                         
                           Pr 
                           ^ 
                         
                          
                         
                           ( 
                           
                             
                               
                                 G 
                                 
                                   w 
                                   i 
                                 
                               
                               = 
                               
                                 
                                   
                                     g 
                                     i 
                                   
                                   | 
                                   
                                     A 
                                     
                                       w 
                                       k 
                                     
                                   
                                 
                                 = 
                                 1 
                               
                             
                             , 
                             
                               
                                 G 
                                 
                                   w 
                                   k 
                                 
                               
                               = 
                               
                                 g 
                                 k 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
         [0064]    where Z is a normalization factor. When {circumflex over (P)}{circumflex over (r)}(•|•,•) cannot be estimated due to lack of samples, a prior probability estimate, computed as in the previous case, is used in its place. The Leacock and Chodorow (LCH) word similarity measure, used as W(•,•) here, generates scores between 0.37 and 3.58, higher meaning more semantically related. Thus, this procedure weighs the probability estimates for words semantically closer to w j  more than others. 
         [0065]    The estimation of Pr(ρ j |A w     j   =a, ∪ i≠j (G w     i   =g i ),G w     j   =g j ), aε{0,1} in Eq. 10 will first require a suitable definition for ρj. As mentioned, it can be thought of as a numerical abstraction relating the knowledge base to the black-box&#39;s guesses. The hope here is that the distribution over this numerical abstraction will be different when certain word guesses are correct, and when they are not. One such formulation is as follows. 
         [0066]    Suppose the black-box makes Q word guesses for an image I that has word w j  as a correct (or wrong) tag, for a=1 (or a=0). We model the number of these guesses, out of Q, that are semantically related to w j , using the binomial distribution, which is apt for modeling counts within a bounded domain. Semantic relatedness here is determined by thresholding the LCH relatedness score W(•,•) between pairs of words (a score of 1.7, ˜50 percentile of the range, was arbitrarily chosen as threshold). Of the two binomial parameters (N, p), N is set to the number of word guesses Q made by the black-box, if it always makes a fixed number of guesses, or the maximum possible number of guesses, whichever appropriate. The parameter p is calculated from the training data as the expected value of ρ j  for word w j , normalized by N, to obtain estimates {circumflex over (p)} j,1  (and {circumflex over (p)} j,0 ) for A w     j    being 1 (and 0). This follows from the fact that the expected value over a binomial PMF is N·p. Since robustness may be an issue here again, interpolation-based smoothing, using a prior estimate on p, is performed. Thus, the ratio of the binomial PMFs can be written as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         Pr 
                         ~ 
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 ρ 
                                 j 
                               
                               | 
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             1 
                           
                           , 
                           - 
                         
                         ) 
                       
                     
                     
                       
                         Pr 
                         ~ 
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 ρ 
                                 j 
                               
                               | 
                               
                                 A 
                                 
                                   w 
                                   j 
                                 
                               
                             
                             = 
                             0 
                           
                           , 
                           - 
                         
                         ) 
                       
                     
                   
                   = 
                   
                     
                       
                         ( 
                         
                           
                             
                               p 
                               ^ 
                             
                             
                               j 
                               , 
                               1 
                             
                           
                           
                             
                               p 
                               ^ 
                             
                             
                               j 
                               , 
                               0 
                             
                           
                         
                         ) 
                       
                       
                         ρ 
                         j 
                       
                     
                      
                     
                       
                         ( 
                         
                           
                             1 
                             - 
                             
                               
                                 p 
                                 ^ 
                               
                               
                                 j 
                                 , 
                                 1 
                               
                             
                           
                           
                             1 
                             - 
                             
                               
                                 p 
                                 ^ 
                               
                               
                                 j 
                                 , 
                                 0 
                               
                             
                           
                         
                         ) 
                       
                       
                         Q 
                         - 
                         
                           ρ 
                           j 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
         [0067]    Finally, we discuss Pr(h 1 , . . . , h D |A w     j   =a), aε{0,1}, the visual representation component in Eq. 10. The idea is that the probabilistic model for a simple visual representation may differ when a certain word is correct, versus when it is not. While various feature representations are possible, we employ one that can be efficiently computed and is also suited to efficient incremental/decremental learning. Each image is divided into 16 equal partitions, by cutting along each axis into four equal parts. For each block, the RGB color values are transformed into the LUV space, and the triplet of average L, U, and V values represent that block. Thus, each image is represented by a 48-dimensional vector consisting of these triplets, concatenated in raster order of the blocks from top-left, to obtain (h 1 , . . . , h 48 ). For estimation from training, each of the 48 components is fitted with a univariate Gaussian, which involves calculating the estimated mean {circumflex over (μ)} j,d,a  and std. dev. {circumflex over (σ)} j,d,a . Smoothing is performed by interpolation with estimated priors {circumflex over (μ)} and {circumflex over (σ)}. The joint probability is computed by treating each component as conditionally independent given a word w j : 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Pr 
                       ~ 
                     
                      
                     
                       ( 
                       
                         
                           h 
                           1 
                         
                         , 
                         … 
                          
                         
                             
                         
                         , 
                         
                           
                             
                               h 
                               D 
                             
                             | 
                             
                               A 
                               
                                 w 
                                 j 
                               
                             
                           
                           = 
                           a 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∏ 
                       
                         d 
                         = 
                         1 
                       
                       48 
                     
                      
                     
                         
                     
                      
                     
                       N 
                        
                       
                         ( 
                         
                           
                             
                               h 
                               d 
                             
                             | 
                             
                               
                                 μ 
                                 ^ 
                               
                               
                                 j 
                                 , 
                                 d 
                                 , 
                                 a 
                               
                             
                           
                           , 
                           
                             
                               σ 
                               ^ 
                             
                             
                               j 
                               , 
                               d 
                               , 
                               a 
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
         [0068]    Here, N(.) is the Gaussian PDF. So far, we have discussed the static case, where a batch of images are trained on. If ground-truth for some images is available, it can be used to train the meta-learner, to annotate the remaining ones. We experiment with this setting in Sec. 4, to see if a meta-learner built atop the black-box is advantageous or not. 
       Meta-Learning Over Time 
       [0069]    We now look at image annotation in online settings. The meta-learning framework discussed earlier has the property that the learning components involve summation of instances, followed by simple O(1) parameter estimation. Inference steps are also lightweight in nature. This makes online re-training of the meta-learner convenient via incremental/decremental learning. Imagine the online settings presented in the Background of the Invention (see  FIG. 1 ). Here, images are annotated as they are uploaded, and whenever the users choose to provide feedback by pointing out wrong guesses, adding tags, etc. For example, in Flickr, images are publicly uploaded, and independently or collaboratively tagged, not necessarily at the time of uploading. In Alipr, feedback is solicited immediately upon uploading. In both these cases, ground-truth arrives into the system sequentially, giving an opportunity to learn from it to annotate future pictures better. Note that when we say of tagging ‘over time’, we mean tagging in sequence, temporally ordered. 
         [0070]    At its inception, an annotation system may not have collected any ground-truth for training the meta-learner. Hence, over a certain initial period, the meta-learner stays inactive, collecting an L seed  number of seed user feedback. At this point, the meta-learner is trained quickly (being lightweight), and starts annotation on incoming images. After an L inter  number of new images has been received, the meta-learner is re-trained ( FIG. 4  provides an overview). The primary challenge here is to make use of the models already learned, so as not to redundantly train on the same data. Re-training can be of two types depending on the underlying ‘memory model’:
       Persistent Memory: Here, the meta-learner accumulates new data into the current model, so that at steps of L inter , it learns from all data since the very beginning, inclusive of the seed data. Technically, this only involves incremental learning.   Transient Memory: Here, while the model learns from new data, it also ‘forgets’ an equivalent amount of the earliest memory it has. Technically, this involves incremental and decremental learning, whereby at every L inter  jump, the meta-learner is updated by (a) assimilating new data, and (b) ‘forgetting’ old data.       
 
       Incremental/Decremental Meta-Learning 
       [0073]    Our meta-learner formulation makes incremental and decremental learning efficient. Let us denote ranges of image sequence indices, ordered by time, using the superscript [start: end], and let the index of the current image be L cu . We first discuss incremental learning, required for the case of persistent memory. Here, probabilities are re-estimated over all available data up to the current time, i.e., over [1: L cu ]. This is done by maintaining summations computed in the most recent re-training at l pr  (say), over a range [1: L pr ] where L pr &lt;L cu . For the first term in Eq. 10, suppressing the irrelevant variables, we can write 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             
                               Pr 
                               ^ 
                             
                              
                             
                               ( 
                               
                                 
                                   A 
                                   
                                     w 
                                     j 
                                   
                                 
                                 | 
                                 
                                   G 
                                   
                                     w 
                                     j 
                                   
                                 
                               
                               ) 
                             
                           
                           
                             [ 
                             
                               1 
                                
                               
                                 : 
                               
                                
                               
                                 L 
                                 cu 
                               
                             
                             ] 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 1 
                               
                               
                                 L 
                                 cu 
                               
                             
                              
                             
                               I 
                                
                               
                                 { 
                                 
                                   
                                     
                                       G 
                                       
                                         w 
                                         j 
                                       
                                       
                                         ( 
                                         n 
                                         ) 
                                       
                                     
                                     &amp; 
                                   
                                    
                                   
                                       
                                   
                                    
                                   
                                     A 
                                     
                                       w 
                                       j 
                                     
                                     
                                       ( 
                                       n 
                                       ) 
                                     
                                   
                                 
                                 } 
                               
                             
                           
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 1 
                               
                               
                                 L 
                                 cu 
                               
                             
                              
                             
                               I 
                                
                               
                                 { 
                                 
                                   G 
                                   
                                     w 
                                     j 
                                   
                                   
                                     ( 
                                     n 
                                     ) 
                                   
                                 
                                 } 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               
                                 S 
                                  
                                 
                                   ( 
                                   
                                     
                                       
                                         G 
                                         
                                           w 
                                           j 
                                         
                                       
                                       &amp; 
                                     
                                      
                                     
                                         
                                     
                                      
                                     
                                       A 
                                       
                                         w 
                                         j 
                                       
                                     
                                   
                                   ) 
                                 
                               
                               
                                 [ 
                                 
                                   1 
                                    
                                   
                                     : 
                                   
                                    
                                   
                                     L 
                                     pr 
                                   
                                 
                                 ] 
                               
                             
                             + 
                             
                               
                                 ∑ 
                                 
                                   n 
                                   = 
                                   
                                     
                                       L 
                                       pr 
                                     
                                     + 
                                     1 
                                   
                                 
                                 
                                   L 
                                   cu 
                                 
                               
                                
                               
                                 I 
                                  
                                 
                                   { 
                                   
                                     
                                       
                                         G 
                                         
                                           w 
                                           j 
                                         
                                         
                                           ( 
                                           n 
                                           ) 
                                         
                                       
                                       &amp; 
                                     
                                      
                                     
                                         
                                     
                                      
                                     
                                       A 
                                       
                                         w 
                                         j 
                                       
                                       
                                         ( 
                                         n 
                                         ) 
                                       
                                     
                                   
                                   } 
                                 
                               
                             
                           
                           
                             
                               
                                 S 
                                  
                                 
                                   ( 
                                   
                                     G 
                                     
                                       w 
                                       j 
                                     
                                   
                                   ) 
                                 
                               
                               
                                 [ 
                                 
                                   1 
                                    
                                   
                                     : 
                                   
                                    
                                   
                                     L 
                                     pr 
                                   
                                 
                                 ] 
                               
                             
                             + 
                             
                               
                                 ∑ 
                                 
                                   n 
                                   = 
                                   
                                     
                                       L 
                                       pr 
                                     
                                     + 
                                     1 
                                   
                                 
                                 
                                   L 
                                   cu 
                                 
                               
                                
                               
                                 I 
                                  
                                 
                                   { 
                                   
                                     G 
                                     
                                       w 
                                       j 
                                     
                                     
                                       ( 
                                       n 
                                       ) 
                                     
                                   
                                   } 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
         [0074]    Therefore, updating and maintaining the summation values S(G w     i   ) and S(G w     j    &amp; A w     j   ) suffices to re-train the meta-learner without using time/space on past data. The priors are also computed using these summation values in a similar manner, for smoothing. Since the meta-learner is re-trained at fixed intervals of L inter , i.e., L inter =L cu −L pr  only a fixed amount of time/space is required every time for getting the probability estimates, regardless of the value of L cu . 
         [0075]    The second term in Eq. 10 can also be estimated in a similar manner, by maintaining the summations, taking their quotient, and smoothing with re-estimated priors. For the third term related to WordNet, the estimation is similar, except that the summations of ρ j  for A w     j   =0 and 1, are maintained instead of counts, to obtain estimates {circumflex over (p)} j,0  and {circumflex over (p)} j,1  respectively. For the fourth term related to visual representation, the estimated mean {circumflex over (μ)} j,d,a  and std.dev. {circumflex over (σ)} j,d,a  can also be updated with values of (h 1 , . . . , h 48 ) for the new images by only storing summation values, as follows: 
         [0000]    
       
         
           
             
               
                 μ 
                 ^ 
               
               
                 j 
                 , 
                 d 
                 , 
                 a 
               
               
                 [ 
                 
                   1 
                    
                   
                     : 
                   
                    
                   
                     L 
                     cu 
                   
                 
                 ] 
               
             
             = 
             
               
                 1 
                 
                   L 
                   cu 
                 
               
                
               
                 ( 
                 
                   
                     
                       S 
                        
                       
                         ( 
                         
                           h 
                           d 
                         
                         ) 
                       
                     
                     
                       [ 
                       
                         1 
                          
                         
                           : 
                         
                          
                         
                           L 
                           pr 
                         
                       
                       ] 
                     
                   
                   + 
                   
                     
                       ∑ 
                       
                         n 
                         = 
                         
                           
                             L 
                             pr 
                           
                           + 
                           1 
                         
                       
                       
                         L 
                         cu 
                       
                     
                      
                     
                       h 
                       d 
                       
                         ( 
                         n 
                         ) 
                       
                     
                   
                 
                 ) 
               
             
           
         
       
       
         
           
             
               
                 σ 
                 ^ 
               
               
                 j 
                 , 
                 d 
                 , 
                 a 
               
               
                 [ 
                 
                   1 
                    
                   
                     : 
                   
                    
                   
                     L 
                     cu 
                   
                 
                 ] 
               
             
             = 
             
               
                 
                   
                     1 
                     
                       L 
                       cu 
                     
                   
                    
                   
                     ( 
                     
                       
                         
                           S 
                            
                           
                             ( 
                             
                               h 
                               d 
                               2 
                             
                             ) 
                           
                         
                         
                           [ 
                           
                             1 
                              
                             
                               : 
                             
                              
                             
                               L 
                               pr 
                             
                           
                           ] 
                         
                       
                       + 
                       
                         
                           ∑ 
                           
                             n 
                             = 
                             
                               
                                 L 
                                 pr 
                               
                               + 
                               1 
                             
                           
                           
                             L 
                             cu 
                           
                         
                          
                         
                           
                             ( 
                             
                               h 
                               d 
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                             ) 
                           
                           2 
                         
                       
                     
                     ) 
                   
                 
                 - 
                 
                   
                     ( 
                     
                       
                         μ 
                         ^ 
                       
                       
                         j 
                         , 
                         d 
                         , 
                         a 
                       
                       
                         [ 
                         
                           1 
                            
                           
                             : 
                           
                            
                           
                             L 
                             cu 
                           
                         
                         ] 
                       
                     
                     ) 
                   
                   2 
                 
               
             
           
         
       
     
         [0000]    owing to the fact that σ 2 (X)=E(X 2 )−(E(X)) 2 . Here, S(h d   2 ) [1:L     pr     ]  is the sum-of-squares of the past values of feature h d , to be maintained, and E(.) denotes expectation. This justifies our simple visual representation, since it conveniently allows incremental learning by only maintaining aggregates. Overall, this process continues to re-train the meta-learner, using the past summation values, and updating them at the end, as depicted in  FIG. 4 . 
         [0076]    In the transient memory model, estimates need to be made over a fixed number of recent data instances, not necessarily from the beginning. We show how this can be performed efficiently, avoiding redundancy, by a combination of incremental/decremental learning. Since every estimation process involves summation, we can again maintain summation values, but here we need to subtract the portion that is to be removed from consideration. Suppose the memory span is decided to be L ms , meaning that at the current time L cu , the re-estimation must only involve data over the range [L cu −L ms : L cu ] Let L old =L cu −L ms . Here, we show the re-estimation of {circumflex over (μ)} j,d,a . Here, along with summation S(h d ) [1:L     pr     ] , we also require S(h d ) [1:L     old     -1] . Therefore, 
         [0000]    
       
         
           
             
               
                 μ 
                 ^ 
               
               
                 j 
                 , 
                 d 
                 , 
                 a 
               
               
                 [ 
                 
                   
                     L 
                     old 
                   
                    
                   
                     : 
                   
                    
                   
                     L 
                     cu 
                   
                 
                 ] 
               
             
             = 
             
               
                 
                   1 
                   
                     
                       L 
                       
                         m 
                          
                         
                             
                         
                          
                         s 
                       
                     
                     + 
                     1 
                   
                 
                  
                 
                   
                     ∑ 
                     
                       n 
                       = 
                       
                         L 
                         old 
                       
                     
                     
                       L 
                       cu 
                     
                   
                    
                   
                     h 
                     d 
                     
                       ( 
                       n 
                       ) 
                     
                   
                 
               
               = 
               
                 
                   1 
                   
                     
                       L 
                       
                         m 
                          
                         
                             
                         
                          
                         s 
                       
                     
                     + 
                     1 
                   
                 
                  
                 
                   ( 
                   
                     
                       
                         S 
                          
                         
                           ( 
                           
                             h 
                             d 
                           
                           ) 
                         
                       
                       
                         [ 
                         
                           1 
                            
                           
                             : 
                           
                            
                           
                             L 
                             pr 
                           
                         
                         ] 
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             
                               L 
                               pr 
                             
                             + 
                             1 
                           
                         
                         
                           L 
                           cu 
                         
                       
                        
                       
                         h 
                         d 
                         
                           ( 
                           n 
                           ) 
                         
                       
                     
                     - 
                     
                       
                         S 
                          
                         
                           ( 
                           
                             h 
                             d 
                           
                           ) 
                         
                       
                       
                         [ 
                         
                           
                             1 
                              
                             
                               : 
                             
                              
                             
                               L 
                               old 
                             
                           
                           - 
                           1 
                         
                         ] 
                       
                     
                   
                   ) 
                 
               
             
           
         
       
     
         [0000]    Since L ms , and L inter  are decided a priori, it is straightforward to know the values of L old  for which S(h d ) [1:L     old     -1]  will be required, and we store them along the way. Other terms in Eq. 10 can be estimated similarly. 
         [0077]    Putting things together, a high-level version of our T/T approach is presented in Algorithm 1, below. It starts with an initial training of the meta-learner using seed data of size L seed . This could be accumulated online using the annotation system itself, or from an external source of images with ground-truth (e.g., Corel images). The process then takes one image at a time, annotates it, and solicits feedback. Any feedback received is stored for future meta-learning. After gaps of l inter  the model is re-trained based on the chosen strategy. 
         [0000]    
       
         
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
           
               
                   
               
               
                 Algorithm 1 Tagging over Time 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 Require: Image stream, Black-box, Feedback 
               
               
                 Ensure: Annotation guesses for each incoming image 
               
               
                  1: for L cu  = 1 to L seed  do 
               
             
          
           
               
                  2: 
                 Dat(L cu ) ← Black-box guesses, feedback, etc. for IL cu   
               
             
          
           
               
                  3: end for 
               
               
                  4: Train meta-learner on Dat(1:L seed ) 
               
               
                  5: repeat {I ← incoming image} 
               
             
          
           
               
                  6: 
                 Annotate I using metal-learner 
               
               
                  7: 
                 if Feedback received on annotation for I then 
               
             
          
           
               
                    
                 L cu  ← L cu  + 1, IL cu  ← I 
               
               
                  9: 
                 Dat(L cu ) ← Black-box guesses, feedback, etc. 
               
             
          
           
               
                 10: 
                 end if 
               
               
                 11: 
                 if ((L cu  − L seed ) modulo L inter ) = 0 then 
               
             
          
           
               
                 12: 
                 if Strategy = ‘Persistent Memory’ then 
               
             
          
           
               
                 13: 
                 Re-train meta-learner on Dat(1:L cu ) 
               
               
                 14: 
                 /* Use incremental learning for efficiency * / 
               
             
          
           
               
                 15: 
                 else 
               
             
          
           
               
                 16: 
                 Re-train meta-learner on Dat (L cu  − L ms  : L cu ) 
               
               
                 17: 
                 /* Use incremental/decremental learning for efficiency */ 
               
             
          
           
               
                 18: 
                 end if 
               
             
          
           
               
                 19: 
                 end if 
               
             
          
           
               
                 20: until End of time 
               
               
                   
               
             
          
         
       
     
       Experimental Results 
       [0078]    We perform experiments for the two scenarios shown in  FIG. 1 ; (1) Static tagging, where a batch of images are tagged at once, and (2) Tagging over time (online setting) where images arrive in temporal order, for tagging. In the former, our meta-learning framework simple acts as a new annotation system based on an underlying black-box system. We explore whether the meta-learning layer improves performance over the black-box or not. In the latter, we have a realistic scenario that is particularly suited to online systems (Flickr, Alipr). Here, we see how the seed meta-learner fares against the black-box, and whether its performance improves with newly accumulated feedback or not. We also explore how the two meta-learning memory models, persistent and transient, fare against each other. 
         [0079]    Experiments are performed on standard datasets and real-world data. First, we use the Corel Stock photos, to compare our meta-learning approach with the state-of-the-art. This collection of images is tagged with a 417 word vocabulary. Second, we obtain two real-world, temporally ordered traces from the Alipr system, each 10,000 in length, taken over different periods of time. Each trace consists of publicly uploaded images, the annotations provided by Alipr, and the user-feedback received on these annotations. The Alipr system provides the user with 15 guessed words (ordered by likelihoods), and the user can opt to select the correct guesses and/or add new ones. This is the feedback for our meta-learner. Here, ignoring the non-WordNet words in either vocabulary (to be able to use the WordNet similarity measure uniformly, and to reduce noise in the feedback), we have a consolidated vocabulary of 329 unique words. 
         [0080]    Two different black-box annotation systems, which use different approaches to image tagging, are used in our experiments. A good meta-learner should fare well for different underlying black-box systems, which is what we set out to explore here. The first is Alipr, which is a real-time, online system, and the second is a recently proposed approach that was shown to outperform earlier systems. For both models, we are provided guessed tags given an image, ordered by decreasing likelihoods. Annotation performance is gauged using three standard measures, namely precision, recall and F 1 -score that have been used in the past. Specifically, for each image, 
         [0000]    
       
         
           
             
               precision 
               = 
               
                 
                   # 
                    
                   
                       
                   
                    
                   
                     ( 
                     
                       tags 
                        
                       
                           
                       
                        
                       guessed 
                        
                       
                           
                       
                        
                       correctly 
                     
                     ) 
                   
                 
                 
                   # 
                    
                   
                       
                   
                    
                   
                     ( 
                     
                       tags 
                        
                       
                           
                       
                        
                       guessed 
                     
                     ) 
                   
                 
               
             
             , 
             
               
 
             
              
             
               recall 
               = 
               
                 
                   # 
                    
                   
                       
                   
                    
                   
                     ( 
                     
                       tags 
                        
                       
                           
                       
                        
                       guessed 
                        
                       
                           
                       
                        
                       correctly 
                     
                     ) 
                   
                 
                 
                   # 
                    
                   
                       
                   
                    
                   
                     ( 
                     
                       correct 
                        
                       
                           
                       
                        
                       tags 
                     
                     ) 
                   
                 
               
             
             , 
             and 
           
         
       
       
         
           
             
               
                 F 
                 1 
               
                
               
                 - 
               
                
               score 
             
             = 
             
               
                 2 
                 × 
                 Precision 
                 × 
                 Recall 
               
               
                 Precision 
                 + 
                 Recall 
               
             
           
         
       
     
         [0000]    (harmonic mean of precision and recall). Results reported in each case are averages over all images tested on. 
         [0081]    The ‘lightweight’ nature of our meta-learner is validated by the fact that the re-training of each visual category in [2] and [1] are reported as 109 sec. and 106 sec. respectively. Therefore, at best, re-training will take these times when the models are built ally in parallel. In contrast, our meta-learner re-trains on 10,000 images in ˜6.5 sec. on a single machine. Furthermore, the additional computation due to the meta-learner during annotation is negligible. 
       Tagging in a Static Scenario 
       [0082]    In [1], it was reported that 24,000 Corel images, drawn from 600 image categories were used for training, and 10,000 test images were used to assess performance. We use this system as black-box by obtaining the word guesses made by it, along with the corresponding ground-truth, for each image. Our meta-learner uses an additional L seed =2,000 images (randomly chosen) from the Corel dataset as the seed data. Therefore, effectively, (black-box+meta-learner) uses 26, 000 instead of 24, 000 images for training. We present results on this static case in Table I. Results for our meta-learner approach are shown for both Top r (r=5) and Threshold r % (r=60), as described elsewhere herein. The baseline results are those reported in [1]. Note the significant jump in performance with our meta-learner in both cases. Effectively, this improvement comes at the cost of only 2,000 extra images and marginal addition to computation time. 
         [0000]    
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE I 
               
             
             
               
                   
               
               
                 RESULTS ON 10,000 COREL IMAGES (STATIC) 
               
             
          
           
               
                   
                 Approach 
                 Precision 
                 Recall 
                 F 1 -score 
               
               
                   
                   
               
               
                   
                 Baseline [1] 
                 25.38% 
                 40.69% 
                 31.26 
               
               
                   
                 Meta-learner (Top r) 
                 32.47% 
                 74.24% 
                 45.18 
               
               
                   
                 Meta-learner (Thresh.) 
                 40.25% 
                 61.18% 
                 48.56 
               
               
                   
                   
               
             
          
         
       
     
         [0083]    Next, we experiment with real-world data obtained from Alipr, which we use as the black-box, and the data is treated as a batch here, to emulate a static scenario. We use both data traces consisting of 10,000 images each, the tags guessed by Alipr for them, and the user feedback on them, as described before. It turns out that most people provided feedback by selection, and a much smaller fraction typed in new tags. As a result, the recall is by default very high for the black-box system, but it also yields poor precision. For each trace, our meta-leaner is trained on L seed =2,000 seed images, and tested on the remaining 8,000 images. In Table II, averaged-out results for our meta-learner approach for both Top r (r=5) and Threshold r % (r=75), as described earlier, are presented alongside the baseline performance on the same data (all 15 and top 5 guesses). Again we observe significant performance improvements over the baseline in both cases. As is intuitive, a lower percentile cut-off for threshold, or a higher number r of top words both lead to higher recall, at the cost of lower precision. Therefore, either number can be adjusted according to the specific needs of the application. 
         [0000]    
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE II 
               
             
             
               
                   
               
               
                 RESULTS ON 16,000 REAL-WORLD IMAGES (STATIC) 
               
             
          
           
               
                   
                 Approach 
                 Precision 
                 Recall 
                 F 1 -score 
               
               
                   
                   
               
               
                   
                 Baseline [2] (All 15) 
                 13.07% 
                 81.50% 
                 22.53 
               
               
                   
                 Baseline [2] (Top r) 
                 17.22% 
                 40.89% 
                 24.23 
               
               
                   
                 Meta-learner (Top r) 
                 22.12% 
                 47.94$ 
                 30.27 
               
               
                   
                 Meta-learner (Thresh.) 
                 33.64% 
                 58.09% 
                 42.61 
               
               
                   
                   
               
             
          
         
       
     
       Tagging Over Time 
       [0084]    We now look at the T/T case. Because the Alipr data was generated online in a real-world setting, it makes an apt test data for our T/T approach. Again, the black-box here is the Alipr system, from which we obtain the guessed tags and user feedback. The annotation performance of this system acts as a baseline for all experiments that follow. 
         [0085]    First, we experiment with the two data traces separately. For each trace, a seed data consisting of the first L seed =1,000 images (in temporal order) is used to initially train the meta-learner. Re-training is performed in intervals of L inter =200. We test on the remaining 9,000 images of the trace for (a) static case, where the meta-learner is not further re-trained, and (b) T/T case, where meta-learner is re-trained over time, using (a) Top r (r=5), and (b) Threshold r % (r=75) for each case. For these experiments, the persistent memory model is used. Comparison is made using I and F 1 -score, with the baseline performance being that of Alipr, the black-box. Here a comparison of recall is not interesting because it is generally high for the baseline (as explained before), and it is anyway dependent on the other two measures. These results are shown in  FIGS. 5A to 5D . The scores shown are moving averages over 500 images (or less, for the initial 500 images). 
         [0086]    Next, we explore how the persistent and transient memory models fare against each other. The main motivation for transient learning is to ‘forget’ earlier training data that is irrelevant, due to a shift in trend in the nature of images and/or feedback. Because we observed such a shift between Alipr traces # 1  and # 2  (being taken over distinct time-periods), we merged them together to obtain a new  20 , 000  image trace to emulate a scenario of shifting trend. Performing a seed learning over images  4 , 001  to  5 , 000  (part of trace # 1 ), we test on the trace from 5,001 to 15,000. The results for the two memory models for T/T, along with the static and baseline cases, are presented in  FIGS. 6A and 6B . Note the performance dynamics around the 10,000 mark where the two traces merge. While the persistent and transient models follow each other closely till around this mark, the latter performs better after it (by up to 10%, in precision), verifying our hypothesis that under significant changes, ‘forgetting’ helps to produce a better-adapted meta-learner. 
         [0087]    A strategic question to ask, on implementation, is ‘How often should we re-train the meta-learner, and at what cost?’. To analyze this, we experimented with the 10,000 images in Alipr trace # 1 , varying the interval L inter , between retraining while keeping everything else identical, and measuring the F 1 -score. In each case, the computation time is noted (ignoring the latency incurred due to user waits, treated as constant here). These durations are normalized by the maximum time incurred, i.e., at L inter =100. These results are presented in  FIGS. 7A and 7B . Note that with increasing gaps in re-training, F 1 -score decreases to a certain extent, while computation time saturates quickly, to the amount needed exclusively for tagging. There is a clear trade-off between computational overhead and the F 1 -score achieved. A graph of this nature can therefore help decide on this trade-off for a given application. 
         [0088]    Finally, in  FIG. 8 , we show an image sampling from a large number of cases where we found the annotation performance to improve meaningfully with re-training over time. Specifically, against time  0  is shown the top 5 tags given to the image by Alipr, along with the meta-learner guesses after training over L 1 =1000 and L 2 =3000 images over time. Clearly, more correct tags are pushed up by the meta-learning process, which improves with more re-training data. 
       CONCLUSIONS 
       [0089]    In this specification, we have disclosed a principled lightweight meta-learning framework for image annotation, and through extensive experiments on two different state-of-the-art black-box annotation systems have shown that a meta-learning layer can vastly improve their performance. We have additionally disclosed a new annotation scenario which has considerable potential for real-world implementation. Taking advantage of the lightweight design of our meta-learner, we have set of a ‘tagging over time’ algorithm for efficient re-training of the meta-learner over time, as new user-feedback become available. Experimental results on standard and real-world datasets show dramatic improvements in performance. We have experimentally contrasted two memory models for meta-learner re-training. The meat-learner approach to annotation appears to have a number of attractive properties, and it seems worthwhile to implement it atop other existing systems to strengthen this conviction. 
       REFERENCES 
       [0000]    
       
         [1] R. Datta, W. Ge, J. Li J. Wang; “Toward briding the annotation-retrieval gap in image search by a generative modeling approach.”  In Proc. ACM Multimedia,  2006. 
       
     
         [0091]    [2] J. Li and J. Wang; “Real-time computerized annotation of pictures.”  In Proc. ACM Multimedia  2006.