Abstract:
A method for training a learning machine for use in discriminative classification and regression includes randomly selecting, in a first computer process, an unclassified datapoint associated with a phenomenon of interest; determining, in a second computer process, a set of datapoints associated with the phenomenon of interest that is likely to be in the same class as the selected unclassified datapoint; predicting, in a third computer process, a class label for the selected unclassified datapoint in a third computer process; predicting a class label for the set of datapoints in a fourth computer process; combining the predicted class labels in a fifth computer process, to predict a composite class label that describes the selected unclassified datapoint and the set of datapoints; and using the combined class label to adjust at least one parameter of the learning machine in a sixth computer process.

Description:
RELATED APPLICATION 
       [0001]    This application claims the benefit of U.S. Provisional Application No. 61/026,854, filed Feb. 07, 2008, the entire disclosure of which is incorporated herein by reference. 
     
    
     FIELD 
       [0002]    The present disclosure relates to machine learning. More particularly, the present disclosure relates to methods for training learning machines with unlabeled data. 
       BACKGROUND 
       [0003]    Several methods for improving discriminative classifiers using unlabeled data have been developed in the last few years. Perhaps the two most popular ways of utilizing the unlabeled data are: maximizing the margin on the unlabeled data as in Transductive Support Vector Machines (TSVM) so that the decision rule lies in a region of low density; and learning the cluster or manifold structure from the unlabeled data as in cluster kernels, label propagation, and Laplacian SVMs. Both approaches can be seen as making the same structure assumption on the data, that the cluster or manifold structure in the data is correlated with the class labels of interest. 
         [0004]    The Low Density Separation algorithm (LDS) is a two-stage algorithm that combines both of these approaches, with improved results over using only one of the techniques, however the combination method is somewhat ad-hoc. 
         [0005]    One problem with these methods is that they each suffer from an inability to scale to very large datasets, apart from in the linear case. This is ironic because the potential gain of semi-supervised learning lies in the vast amounts of readily available unlabeled data. This performance gain is never attained simply because of the computational burden of calculating the result. 
         [0006]    Accordingly, a new learning method which uses unlabeled data is needed which overcomes the problems associated with existing methods. 
       SUMMARY 
       [0007]    A method is disclosed herein for training a learning machine for use in discriminative classification and regression. In the method an unclassified datapoint associated with a phenomenon of interest is randomly selected in a first computer process. A set of datapoints is determined in a second computer process, which set is associated with the phenomenon of interest that is likely to be in the same class as the selected unclassified datapoint. In a third computer process, a class label for the selected unclassified datapoint is predicted in a third computer process. A class label is predicted for the set of datapoints in a fourth computer process. The predicted class labels are combined in a fifth computer process, to predict a composite class label that describes the selected unclassified datapoint and the set of datapoints. The combined class label is used to adjust at least one parameter of the learning machine in a sixth computer process. 
         [0008]    An apparatus is disclosed herein for use in discriminative classification and regression. The apparatus comprises an input device for inputting unclassified datapoints associated with a phenomenon of interest; a processor; and a memory communicating with the processor. The memory comprises instructions executable by the processor for implementing a learning machine and training the learning machine by: randomly selecting one of the unclassified datapoints associated with the phenomenon of interest; determining a set of datapoints associated with the phenomenon of interest that are likely to be in the same class as the selected unclassified datapoint; predicting a class label for the selected unclassified datapoint; predicting a class label for the set of datapoints; combining the predicted class labels to predict a composite class label that describes the selected unclassified datapoint and the set of datapoints; and using the combined class label to adjust at least one parameter of the learning machine. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0009]      FIG. 1  is a flow chart illustrating an exemplary embodiment of a method for training a learning machine for use in discriminative classification and regression. 
           [0010]      FIG. 2  is a block diagram of an exemplary embodiment of a computer system which may be used for performing the methods described herein. 
       
    
    
     DETAILED DESCRIPTION 
       [0011]      FIG. 1  is a flow chart illustrating an exemplary embodiment of a method for training a learning machine for use in discriminative classification and regression. The method uses a large scale manifold transductive loss function for improving generalization of the learning machine using unclassified (unlabeled) data. The method may be used to improve the error rate of any supervised learning machine, including without limitation, neural networks and support vector machines, if unlabeled data is available. 
         [0012]    As illustrated in  FIG. 1 , a learning machine is selected in step  101  for training. The selected learning machine may include, without limitation, a neural network, a support vector machine and any other suitable learning machine. 
         [0013]    A plurality of unlabeled examples or datapoints associated with a phenomenon of interest is obtained or provided in step  102 . The phenomenon of interest may include, without limitation, human language, written text, an object viewed by a camera, financial information, and any other phenomenon commonly addressed in natural language processing, syntactic pattern recognition, search engines, medical diagnosis, bioinformatics, brain-machine interfaces and cheminformatics, financial analysis, speech and handwriting recognition, and object recognition in computer vision, game playing and robot locomotion. 
         [0014]    For each unlabeled datapoint, a set of examples or datapoints associated with the phenomenon, which is likely to be in the same class as the unclassified example or datapoint, is determined in step  103 . In one exemplary embodiment, each set of datapoints may be determined using a distance metric or other method that determines whether two datapoints are in the same class, e.g. neighbors. The distance metric may comprise a calculation using the k-nearest neighbors of each datapoint, as neighbors in input space are assumed to have the same class label. 
         [0015]    In step  104 , the selected learning machine predicts a class label for each unclassified datapoint received at an input of the learning machine. In step  105 , the selected learning machine predicts a class label for each set of datapoints received at an input of the learning machine. 
         [0016]    In step  106 , the selected learning machine combines the predicted class labels to predict a composite class label that describes the selected unclassified datapoint and the set of datapoints. In other words, the prediction of the composite class label is a number (in the two-class case) which indicates the composite class label, either negative or positive. In one exemplary embodiment, the learning machine combines the predicted class labels by taking a mean of the prediction, i.e., a number determined by taking the average of two numbers, where each number represents one of the predicted class labels determined in step  105 . In another exemplary embodiment, the learning machine combines the predicted class labels by taking a maximum prediction, i.e., a number determined by taking the largest one of the two numbers representing the predicted class labels determined in step  105 . 
         [0017]    In step  107 , at least one parameter of the learning machine is adjusted according to the combined class label. In step  108 , steps  104 - 107  are repeated until training with unclassified datapoints is completed. 
         [0018]    In another embodiment, the method may use classified (labeled) and unclassified (unlabeled) data for training the learning machine. This embodiment of the method may be expressed formally as the following algorithm (equation 1): minimize 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         1 
                         L 
                       
                        
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           L 
                         
                          
                         
                           l 
                            
                           
                             ( 
                             
                               
                                 f 
                                  
                                 
                                   ( 
                                   
                                     x 
                                     i 
                                   
                                   ) 
                                 
                               
                               , 
                               
                                 y 
                                 i 
                               
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         λ 
                         
                           U 
                           2 
                         
                       
                        
                       
                         
                           ∑ 
                           
                             i 
                             , 
                             
                               j 
                               = 
                               1 
                             
                           
                           U 
                         
                          
                         
                           
                             W 
                             ij 
                           
                            
                           
                             l 
                              
                             
                               ( 
                               
                                 
                                   f 
                                    
                                   
                                     ( 
                                     
                                       x 
                                       i 
                                       * 
                                     
                                     ) 
                                   
                                 
                                 , 
                                 
                                   
                                     y 
                                     * 
                                   
                                    
                                   
                                     ( 
                                     
                                       { 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       } 
                                     
                                     ) 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   where 
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       y 
                       * 
                     
                      
                     
                       ( 
                       N 
                       ) 
                     
                   
                   = 
                   
                     sign 
                     ( 
                     
                       
                         ∑ 
                         
                           k 
                           ∈ 
                           N 
                         
                       
                        
                       
                         f 
                          
                         
                           ( 
                           
                             x 
                             k 
                             * 
                           
                           ) 
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0000]    and where the edge weights W ij  define pairwise similarity relationships between unlabeled examples x*. 
         [0019]    The algorithm (equation 1) may be implemented using a plurality of algorithmic selections. Specifically, the function is minimized in the primal by stochastic gradient descent. This allows semi-supervised learning to be performed online in real time. In addition, a multi-layer architecture is used for defining f(x), in nonlinear applications. This makes training and testing much faster than in kernel based learning machines, such as transductive support vector machines (TSVM). Further, a specific recommendation is made herein about which type of a balancing constraint to use. 
         [0020]    In the algorithm of equation 1, a new loss function is proposed for the unlabeled datapoints: 
         [0000]        l ( *f ( x   i *))= l (( x   i *),  y *( N )) 
         [0000]    where N is a set of datapoints that is likely to share the same label, e.g. a set of neighboring datapoints. The function y* predicts the label of that set by taking the mean prediction. Alternatively, a weighted prediction of the form: y i *(N)=sign(Σk∈NW ik f(x k *)) may be used to predict the set. For both labeled and unlabeled training data we use a hinge loss function l(f(x), y)=max(0,1−yf(x)). which is implemented in support vector machines (SVMs). In the equation f(x)=w·x+b, pairs of datapoints are considered, weighted by the graph W ij . If W ij =1 and W ij =0 for i≠j then a TSVM loss function is recovered: 
         [0000]        l *( f ( x   i *))= l ( f ( x   i *),sign( f ( x   i *))) 
         [0000]    because neighborhood information is not accounted for. 
         [0021]    Setting W ij =1 if x i * and x j * are neighbors, and zero otherwise, the algorithm becomes a natural generalization of a TSVM that regularizes using neighborhood information. It is a similar regularizer to the neighborhood-based manifold regularizers, but based on clustering rather than embedding. 
         [0022]    In the present method, the assumption is made that if two datapoints are neighbors, they have the same class label, whereas manifold-based regularization assumes they are close in an embedding space. The constraint used in the present method is not as strict, but captures the prior knowledge we have which we can use to influence the design of the algorithm. For example, if one class of data has more variance than the other, then the regularization of Laplacian SVMs which minimize: 
         [0000]    
       
         
           
             
               
                 min 
                 
                   w 
                   , 
                   b 
                 
               
                
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   L 
                 
                  
                 
                   l 
                    
                   
                     ( 
                     
                       
                         f 
                          
                         
                           ( 
                           
                             x 
                             i 
                           
                           ) 
                         
                       
                       , 
                       
                         y 
                         i 
                       
                     
                     ) 
                   
                 
               
             
             + 
             
               γ 
                
               
                 
                    
                   w 
                    
                 
                 2 
               
             
             + 
             
               λ 
                
               
                 
                   ∑ 
                   
                     i 
                     , 
                     
                       j 
                       = 
                       1 
                     
                   
                   U 
                 
                  
                 
                   
                     W 
                     ij 
                   
                    
                   
                     
                        
                       
                         
                           f 
                            
                           
                             ( 
                             
                               x 
                               i 
                               * 
                             
                             ) 
                           
                         
                         - 
                         
                           f 
                            
                           
                             ( 
                             
                               x 
                               j 
                               * 
                             
                             ) 
                           
                         
                       
                        
                     
                     2 
                   
                 
               
             
           
         
       
     
         [0000]    might focus on that class, and ignore the other. 
         [0023]    Extensions of the algorithm of equation 1 are also possible. First, in the multi-class case where f(x′) outputs a c-dimensional vector, 
         [0000]    
       
         
           
             
               
                 y 
                 * 
               
                
               
                 ( 
                 N 
                 ) 
               
             
             = 
             
               argmax 
                
               
                 
                   ∑ 
                   
                     k 
                     ∈ 
                     N 
                   
                 
                  
                 
                   f 
                    
                   
                     ( 
                     
                       x 
                       k 
                       * 
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0000]    can be defined. Further, if the set N contains more than two examples then the present algorithm takes into account a neighborhood in analogy to k-nearest neighbor. This is not easily possible with a Laplacian SVM which is limited to pairs. 
         [0024]    The present method may also be considerd in a co-training like framework: if the set N contains datapoints with different views of the data, the present classifier may make better local predictions. In this context, it may be beneficial to predict the most confident label of all the datapoints in N, rather than the mean prediction. 
         [0025]    As discussed in the Background Section, the issue that makes existing algorithms computationally expensive in the nonlinear case is their choice of the kernel expansion. The present algorithm solves this problem by using a multi-layer model of the form: 
         [0000]    
       
         
           
             
               f 
                
               
                 ( 
                 x 
                 ) 
               
             
             = 
             
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   d 
                 
                  
                 
                   
                     w 
                     i 
                     0 
                   
                    
                   
                     
                       h 
                       i 
                     
                      
                     
                       ( 
                       x 
                       ) 
                     
                   
                 
               
               + 
               b 
             
           
         
       
     
         [0000]    where typically one chooses hidden units 
         [0000]    
       
         
           
             
               
                 h 
                 i 
               
                
               
                 ( 
                 x 
                 ) 
               
             
             = 
             
               S 
               ( 
               
                 
                   
                     ∑ 
                     j 
                   
                    
                   
                     
                       w 
                       j 
                       i 
                     
                      
                     
                       x 
                       j 
                     
                   
                 
                 + 
                 
                   b 
                   i 
                 
               
               ) 
             
           
         
       
     
         [0000]    where S is a non-linear squashing function, and using the Hard Tanh function: 
         [0000]    
       
         
           
             
               S 
                
               
                 ( 
                 x 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     1 
                   
                   
                     
                       
                         if 
                          
                         
                             
                         
                          
                         x 
                       
                       ≥ 
                       1 
                     
                   
                 
                 
                   
                     
                       - 
                       1 
                     
                   
                   
                     
                       
                         if 
                          
                         
                             
                         
                          
                         x 
                       
                       ≤ 
                       
                         - 
                         1 
                       
                     
                   
                 
                 
                   
                     x 
                   
                   
                     otherwise 
                   
                 
               
             
           
         
       
     
         [0026]    In the multi-class case, one output f i (x) is defined for each class, but each function f i  shares the same hidden units h j , as is often done in neural network models. The flexibility of using multi-layer architectures also allows encoding prior knowledge in the present method. 
         [0027]    In the present method, the objective is optimized online, in the primal, using stochastic gradient descent. To simplify the hyperparameters, the present method fixes λ=1. If the model is multi-layered then backpropagation is used during the gradient step. A typical stopping criteria is to use a validation set or to measure the objective function value. 
         [0028]    The method and algorithm (equation 1), which uses both labeled (classified) and unlabeled (unclassified) data and may also be stated, without balance constraints as:
       Input: labeled data (x i , y i ) and unlabeled data x i *   Repeat
           Pick a random labeled example (x i , y i )   Make a gradient step to optimize l(f(x i ), y i )   Pick a random unlabeled example x i *   Pick a random neighbor x j * of x i *   Make a gradient step for l(f(x i *), y*({i,j}))   until stopping criteria is met.   
               
 
         [0037]    To implement a balancing constraint while learning online, a cache of (arbitrarily) the last 25c predictions f(x i *) are kept where c is the number of classes. The next prediction is made balanced assuming a fixed estimate Pest(y) of the probability of each class, which without further information, can be estimated from the labeled data: 
         [0000]    
       
         
           
             
               Ptrn 
                
               
                 ( 
                 
                   y 
                   = 
                   i 
                 
                 ) 
               
             
             = 
             
               
                 
                    
                   
                     { 
                     
                       
                         i 
                          
                         
                           : 
                         
                          
                         
                           y 
                           i 
                         
                       
                       = 
                       i 
                     
                     } 
                   
                    
                 
                 L 
               
               . 
             
           
         
       
     
         [0000]    Then, two alternatives are considered. In the first alternative, the term ∇bal may be added to the objective function multiplied by a scaling factor as in ∇TSVMs. The disadvantage of such an approach is that the scaling factor is a further hyperparameter. In the second alternative, referred to herein as “ignore-bal,” examples in the cache are counted which have been attributed to each class. If the next unlabeled example x* is given a label y* by the model that already has too many examples assigned to it, then a gradient step is simply not made for this example. 
         [0038]    The quality of Ptrn depends on the ratio of labeled examples L to the number of classes c, not the input dimensionality d. Thus it may not be a good estimate in many real datasets. Therefore, a method Pknn may be performed, which comprises labeling the k nearest neighbors of each labeled example with its label. If k is large enough some labeled points will label the same examples, and so when the number or points assigned to each class are counted, a smoothed version of Ptrn is achieved. 
         [0039]    The methods described herein may be executed in software, hardware, a combination of software and hardware, or in other suitable executable implementations. The methods implemented in software may be executed by a processor of a computer system or by one or more processors of one or more associated computers or computer systems connected to the computer system. 
         [0040]    The computer system may include, without limitation, a mainframe computer system, a workstation, a personal computer system, a personal digital assistant (PDA), or other device or apparatus having at least one processor that executes instructions from a memory medium. 
         [0041]    The computer system(s) may include one or more memory mediums on which one or more computer programs or software components implementing the methods described herein may be stored. The one or more software programs which are executable to perform the methods described herein, may be stored in the memory medium. The one or more memory mediums may include, without limitation, CD-ROMs, floppy disks, tape devices, random access memories such as but not limited to DRAM, SRAM, EDO RAM, and Rambus RAM, non-volatile memories such as, but not limited hard drives and optical storage devices, and combinations thereof. In addition, the memory medium may be entirely or partially located in one or more associated computers or computer systems which connect to the computer system over a network, such as the Internet. 
         [0042]      FIG. 2  is a block diagram of an exemplary embodiment of a computer system  200  which may be used for performing the methods described herein. The computer system  200  includes a processor  210 , a memory  220  for storing one or more programs which are executable by the processor for performing the methods described herein, an input  230  for receiving input data (e.g., the unlabeled and labeled training data), and an output for  240  for outputting data (e.g., the predicted class labels). 
         [0043]    While exemplary drawings and specific embodiments have been described and illustrated herein, it is to be understood that that the scope of the present invention is not to be limited to the particular embodiments discussed. Thus, the embodiments shall be regarded as illustrative rather than restrictive, and it should be understood that variations may be made in those embodiments by persons skilled in the art without departing from the scope of the present invention as set forth in the claims that follow and their structural and functional equivalents.