# Patent

## Title
Large scale semi-supervised linear support vector machines

## Abstract

A computerized system and method for large scale semi-supervised learning is provided. The training set comprises a mix of labeled and unlabeled examples. Linear classifiers based on support vector machine principles are built using these examples. One embodiment uses a fast design of a linear transductive support vector machine using multiple switching. In another embodiment, mean field annealing is used to form a very effective semi-supervised support vector machine. For both these embodiments the finite Newton method is used as the base method for achieving fast training.

## Background
FIELD OF THE INVENTION
The invention is a method for large scale semi-supervised linear support vector machines. Specifically, the invention provides a system and method that uses a modified finite Newton method for fast training of linear SVMs using a mix of labeled and unlabeled examples.
BACKGROUND OF THE INVENTION
Many problems in information processing involve the selection or classification of items in a large data set. For example, web-based companies such as Yahoo! have to frequently classify web pages as belonging to one group or the other, e.g., as commercial or non-commercial.
Currently, large amounts of data can be cheaply and automatically collected. However, labeling of the data typically involves expensive and fallible human participation. For example, a single web-crawl by a search engine, such as Yahoo or Google, indexes billions of webpages. Only a very small fraction of these web-pages can be hand-labeled by human editorial teams and assembled into topic directories. The remaining web-pages form a massive collection of unlabeled documents.
The modified finite Newton algorithm, described in co-pending application Ser. No. 10/949,821, entitled “A Method And Apparatus For Efficient Training Of Support Vector Machines,” filed Sep. 24, 2004, the entirety of which is incorporated herein by reference, describes a method for training linear support vector machines (SVMs) on sparse datasets with a potentially very large number of examples and features. Such datasets are generated frequently in domains like document classification. However, the system and method described in that application incorporates only labeled data in a finite Newton algorithm (abbreviated L2-SVM-MFN). Large scale learning is often realistic only in a semi-supervised setting where a small set of labeled examples is available together with a large collection of unlabeled data.
A system and method that provides for extension of linear SVMs for semi-supervised classification problems involving large, and possibly very high-dimensional but sparse, partially labeled datasets is desirable. In many information retrieval and data mining applications, linear methods are strongly preferred because of their ease of implementation, interpretability and empirical performance. The preferred embodiments of the system and method described herein clearly address this and other needs.
BRIEF SUMMARY OF THE INVENTION
In one preferred embodiment, a transductive support vector machine (TSVM) system and method for linear semi-supervised classification on large, sparse datasets is provided. The system and method exploits data sparsity and linearity to provide superior scalability. According to another preferred embodiment, a multiple switching heuristic further improves TSVM training significantly for large scale applications.
In another preferred embodiment, a system and method for semi-supervised SVMs is disclosed that uses global optimization using mean field methods. The method generates a family of objective functions with non-convexity that is controlled by an annealing parameter. The global minimizer is tracked with respect to this parameter. This method alleviates the problem of local minima in the TSVM optimization procedure that results in significantly better operation in many applications, while being computationally judicious.
According to another preferred embodiment, a computerized system and method for semi-supervised learning is provided. A training set example elements is received. Elements of the training set that are determined to fall within a classification group are labeled. The training set thereby has labeled elements and unlabelled elements. The system uses selected labeled elements and unlabeled elements as examples in a large scale semi-supervised support vector machine to select a linear classifier. The system receives unclassified data items. Using the selected linear classifier, the received unclassified data elements are classified.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram illustrating components of a search engine in which one embodiment operates;
FIG. 2 is an example of a news web page that can be categorized using one embodiment;
FIG. 3 is a flow diagram illustrating steps performed by the system according to one embodiment associated with search engine relevance ranking;
FIG. 4 is a table listing conjugate gradient scheme iterations according to one embodiment;
FIG. 5 is a table outlining a full line search routine method performed by one embodiment;
FIG. 6 is a table having an abridged pseudo-code listing for a method performed by one embodiment;
FIG. 7 is a graph illustrating an L2 loss function over unlabelled examples for transductive SVM;
FIG. 8 is a table outlining a transductive SVM algorithm performed by one embodiment;
FIG. 9 is a graph illustrating an L2 loss function over unlabelled examples for transductive SVM;
FIG. 10 is a table illustrating steps for optimizing a weight vector w according to one embodiment;
FIG. 11 is a graph of a root function used by an embodiment;
FIG. 12 is table illustrating steps for optimizing a belief probability p according to one embodiment; and
FIG. 13 is table illustrating steps for a method of mean field annealing according to one embodiment.



DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
A preferred embodiment of a large scale semi-supervised linear support vector machine, constructed in accordance with the claimed invention, is directed towards a modified finite Newton method for fast training of linear SVMs. According to one embodiment, the system uses two efficient and scalable methods for training semi-supervised SVMs. The first method provides a fast implementation of a variant of linear a transductive SVM (TSVM). The second method is based on a mean field annealing (MFA) approach, designed to alleviate the problem of local minimum in the TSVM optimization procedure.
In one embodiment, as an example, and not by way of limitation, an improvement in Internet search engine labeling of web pages is provided. The World Wide Web is a distributed database comprising billions of data records accessible through the Internet. Search engines are commonly used to search the information available on computer networks, such as the World Wide Web, to enable users to locate data records of interest. A search engine system 100 is shown in FIG. 1. Web pages, hypertext documents, and other data records from a source 101, accessible via the Internet or other network, are collected by a crawler 102. The crawler 102 collects data records from the source 101. For example, in one embodiment, the crawler 102 follows hyperlinks in a collected hypertext document to collect other data records. The data records retrieved by crawler 102 are stored in a database 108. Thereafter, these data records are indexed by an indexer 104. Indexer 104 builds a searchable index of the documents in database 108. Common prior art methods for indexing may include inverted files, vector spaces, suffix structures, and hybrids thereof. For example, each web page may be broken down into words and respective locations of each word on the page. The pages are then indexed by the words and their respective locations. A primary index of the whole database 108 is then broken down into a plurality of sub-indices and each sub-index is sent to a search node in a search node cluster 106.
To use search engine 100, a user 112 typically enters one or more search terms or keywords, which are sent to a dispatcher 110. Dispatcher 110 compiles a list of search nodes in cluster 106 to execute the query and forwards the query to those selected search nodes. The search nodes in search node cluster 106 search respective parts of the primary index produced by indexer 104 and return sorted search results along with a document identifier and a score to dispatcher 110. Dispatcher 110 merges the received results to produce a final result set displayed to user 112 sorted by relevance scores.
As a part of the indexing process, or for other reasons, most search engine companies have a frequent need to classify web pages as belonging to one “group” or another. For example, a search engine company may find it useful to determine if a web page is of a commercial nature (selling products or services), or not. As another example, it may be helpful to determine if a web page contains a news article about finance or another subject, or whether a web page is spam related or not. Such web page classification problems are binary classification problems (x versus not x). To develop a classifier that can do such distinguishing usually takes a large sample of web pages labeled by editorial teams and for use as a training set for designing a classifier.
Referring to FIG. 2, there is shown an example of a web page that has been categorized. In this example, the web page is categorized as a “Business” related web page, as indicated by the topic indicator 225 at the top of the page. Other category indicators 225 are shown. Thus, if a user had searched for business categorized web pages, then the web page of FIG. 2 would be listed, having been categorized as such.
With reference to FIG. 3, a flow diagram illustrates the steps performed according to one embodiment. In step 300, a training set of documents is provided. In one embodiment, this training set includes randomly selected unlabelled web pages. In step 302, a sub-set of the training set is labeled as meeting the criteria for inclusion in or exclusion from a group (classification group). For example, the group may include sports web pages in the case of the Internet web-page example discussed above. This step may involve, by way of example, and not by way of limitation, human review of sample web pages for labeling of web pages that are determined to fall within the group (for example, sports web pages) and also possibly labeling some pages as outside the group (for example, non-sports pages), in the labeled training set. Unlike previous systems and methods, it is not strictly necessary to label examples of data that does not fall within the criteria (for example, non-sports pages). In one embodiment, non-labeled examples (e.g. unlabelled sports and non-sports pages) can be used by the system, but it is not necessary. Once the sub-set is labeled, the whole training set of labeled and unlabelled data is available to the system.
In step 304, a modified finite Newton method for fast training of large scale semi-supervised linear SVMs is used to find a classifier. Even though the labeled training set can be any set of examples from within and outside the group, it is preferable for the method to retain knowledge of the fraction of the group in the entire distribution. For example, in the case of the group consisting of sports web pages, if this group forms 1% of the entire collection of web pages, then this number is preferably conveyed as an input to the method as compared to unlabeled examples. In the description of the method below, this number, written as a fraction (for example, 0.01) is called r.
In Step 308, new data, such as a web-page of a document to be classified is input into the system. In Step 310, the semi-supervised SVM obtained in Step 304 is used to classify new data.
A modified version of L2-SVM-MFN algorithm is now discussed to suit the description of two semi-supervised extensions discussed thereafter. The first extension provides an efficient implementation of a variant of Linear Transductive SVM (TSVM). The second extension is based on a mean field annealing (MFA) algorithm designed to track the global optimum of the TSVM objective function.
Modified Finite Newton Linear L2-SVM
The modified finite Newton L2-SVM method (L2-SVM-MFN) for Linear SVMs is ideally suited to sparse datasets with large number of examples and possibly large number of features. In a typical application, such as document classification, many training documents are collected and processed into a format that is convenient for mathematical manipulations. For example, each document may be represented as a collection of d features associated with a vocabulary of d words. These features may simply indicate the presence or absence of a word (binary features), or measure the frequency of a word suitably normalized by its importance (term frequency inverse document frequency (TFIDF) features). Even though the vocabulary might be large, only a very small number of words appear in any document relative to the vocabulary size. Thus, each document is sparsely represented as a bag of words. A label is then manually assigned to each document identifying a particular category to which it belongs (e.g. “commercial” or not). The task of a classification algorithm (e.g. SVM) is to produce a classifier that can reliably identify the category of new documents based on training documents.
Given a binary classification problem with l labeled examples {xi,yi}i=1l where the input patterns xiεRd (e.g. a document) and the labels yiε{+1,−1}, L2-SVM-MFN provides an efficient primal solution to the following SVM optimization problem:




  
    
      
        
          w
          *
        
        =
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
                ⁢
                
                  
                
              
              
                w
                ∈
                
                  
                
                ⁢
                
                  R
                  d
                
              
            
            ⁢
            
              1
              2
            
            ⁢
            
              
                ∑
                
                  i
                  =
                  1
                
                t
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        -
                        
                          
                            y
                            i
                          
                          ⁡
                          
                            (
                            
                              
                                w
                                T
                              
                              ⁢
                              
                                x
                                i
                              
                            
                            )
                          
                        
                      
                    
                    ]
                  
                
                2
              
            
          
          +
          
            
              λ
              2
            
            ⁢
            
              
                
                w
                
              
              2
            
          
        
      
    
    
      
        (
        1
        )
      
    
  




Here, λ is a real-valued regularization parameter and sign(w*Tx) is the final classifier.

This objective function differs from the standard SVM problem in some respects. First, instead of using the hinge loss as the data fitting term, the square of the hinge loss (or the so-called quadratic soft margin loss function) is used. This makes the objective function continuously differentiable, allowing easier applicability of gradient techniques. Secondly, the bias term (“b”) is also regularized. In the problem formulation of equation 1, it is assumed that an additional component in the weight vector and a constant feature in the example vectors have been added to indirectly incorporate the bias. This formulation combines the simplicity of a least squares aspect with algorithmic advantages associated with SVMs. It should also be noted that the methods discussed herein can be applied to other loss functions.
In one embodiment, a version of L2-SVM-MFN where a weighted quadratic soft margin loss function is used.




  
    
      
        
          w
          *
        
        =
        
          
            
              
                arg
                ⁢
                
                  
                
                ⁢
                min
              
              
                w
                ⁢
                
                  
                
                ∈
                
                  
                
                ⁢
                
                  R
                  d
                
              
            
            ⁢
            
              f
              ⁡
              
                (
                w
                )
              
            
          
          =
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
                
                  w
                  ∈
                  
                    R
                    d
                  
                
              
              ⁢
              
                
              
              ⁢
              
                1
                2
              
              ⁢
              
                
                  ∑
                  
                    i
                    ∈
                    
                      j
                      ⁡
                      
                        (
                        w
                        )
                      
                    
                  
                
                ⁢
                
                  
                    c
                    i
                  
                  ⁢
                  
                    
                      d
                      i
                      2
                    
                    ⁡
                    
                      (
                      w
                      )
                    
                  
                
              
            
            +
            
              
                λ
                2
              
              ⁢
              
                
                  
                  w
                  
                
                2
              
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




In equation 2, equation 1 is re-written in terms of a partial summation of di(w)=wTxi−yi over an index set j(w)={i:yi(wTxi)<1}. Additionally, the loss associated with the ith example has a cost ci. f(w) refers to the objective function being minimized, evaluated at a candidate solution w. It is noted that if the index set j(w) were independent of w and ran over all data points, this would simply be the objective function for weighted linear regularized least squares (RLS).
In one embodiment, f is a strictly convex, piecewise quadratic, continuously differentiable function having a unique minimizer. The gradient of f at w is given by:




  
    ∇
    
      f
      ⁡
      
        (
        w
        )
      
    
  
  =
  
    
      
        λ
        ⁢
        
          
        
        ⁢
        w
      
      +
      
        
          ∑
          
            i
            ∈
            
              j
              ⁡
              
                (
                w
                )
              
            
          
        
        ⁢
        
          
            c
            i
          
          ⁢
          
            
              d
              i
            
            ⁡
            
              (
              w
              )
            
          
          ⁢
          
            x
            i
          
        
      
    
    =
    
      
        λ
        ⁢
        
          
        
        ⁢
        w
      
      +
      
        
          X
          
            j
            ⁡
            
              (
              w
              )
            
          
          T
        
        ⁢
        
          
            C
            
              j
              ⁡
              
                (
                w
                )
              
            
          
          ⁡
          
            [
            
              
                
                  X
                  
                    j
                    ⁡
                    
                      (
                      w
                      )
                    
                  
                
                ⁢
                w
              
              -
              
                Y
                
                  j
                  ⁡
                  
                    (
                    w
                    )
                  
                
              
            
            ]
          
        
      
    
  




where Xj(w) is a matrix whose rows are the feature vectors of training points corresponding to the index set j(w), Yj(w) is a column vector containing labels for these points, and Cj(w) is a diagonal matrix that contains the costs ci for these points along its diagonal.

In one embodiment, L2-SVM-MFN is a primal algorithm that uses the Newton's method for unconstrained minimization of a convex function. The classical Newton's method is based on a second order approximation of the objective function, and involves updates of the following kind:

w(k+1)=w(k)+δ(k)n(k)  (3)

where the step size δkεR, and the Newton direction nkεRd is given by:

n(k)=−[∇2f(w(k))]−1∇f(w(k))

∇f(w(k)) is the gradient vector and ∇2f(w(k)) is the Hessian matrix of f at w(k). However, the Hessian does not exist everywhere, since f is not twice differentiable at those weight vectors w where wTxi=yi for some index i. For this reason, a finite Newton method works around this issue through a generalized definition of the Hessian matrix. The modified finite Newton procedure proceeds as follows. The step w(k)=w(k)+n(k) in the Newton direction can be seen to be given by solving the following linear system associated with a weighted linear regularized least squares problem over the data subset defined by the indices j(w(k)):

[λI+Xj(w(k))TCj(w(k))Xj(w(k))] w(k)=Xj(w(k))TCj(w(k))Yj(w(k)))  (4)

where I is the identity matrix. Once w(k) is obtained, w(k+1) is obtained from equation 3 by setting w(k+1)=w(k)+δk( w(k)−w(k)) after performing an exact line search for δk, i.e. by exactly solving a one-dimensional minimization problem:





  
    δ
    
      (
      k
      )
    
  
  =
  
    
      argmin
      
        δ
        ≥
        0
      
    
    ⁢
    
      f
      ⁡
      
        (
        
          
            w
            
              (
              k
              )
            
          
          +
          
            δ
            ⁡
            
              (
              
                
                  
                    w
                    _
                  
                  
                    (
                    k
                    )
                  
                
                -
                
                  w
                  
                    (
                    k
                    )
                  
                
              
              )
            
          
        
        )
      
    
  




The modified finite Newton procedure has the property of finite convergence to the optimal solution. The key features that bring scalability and numerical robustness to L2-SVM-MFN are: (a) Solving the regularized least squares system of equation 4 by a numerically well-behaved conjugate gradient scheme referred to as conjugate gradient for least squares method (CGLS), which is designed for large, sparse data matrices X. (b) Due to the one-sided nature of margin loss functions, these systems are solved over restricted index sets j(w), which can be much smaller than the whole dataset. This also allows additional heuristics to be developed such as terminating CGLS early when working with a crude starting guess, such as 0, and allowing the line search step to yield a point where the index set j(w) is small. Subsequent optimization steps then work on smaller subsets of the data.
CGLS
The CGLS procedure solves large, sparse, weighted regularized least squares problems of the following form:

[λI+XTCX]β=XTCY  (5)

The key computational issue in equation 5 is to avoid the construction of the large and dense matrix XTCX, and work only with the sparse matrix X and the diagonal cost matrix (stored as a vector) C.

Starting with a guess solution, β0, Conjugate Gradient performs iterations of the form:

β(j+1)=β(j)+γ(j)p(j) 

where p(j) is a search direction and γ(j)εR gives the step in that direction. The residual vector (the difference vector between LHS and RHS of equation 5 for a candidate β, which is also the gradient of the associated quadratic form evaluated at β) is therefore updated as:

r(j+1)=XTCY−[λI+XTCX]β(j+1)=XTz(j+1)−λβ(j+1) 

The following intermediate vectors are introduced:





  
    
      
        
          z
          
            (
            
              j
              +
              1
            
            )
          
        
        =
        
          
            C
            ⁡
            
              (
              
                Y
                -
                
                  X
                  ⁢
                  
                    
                  
                  ⁢
                  
                    β
                    
                      (
                      
                        j
                        +
                        1
                      
                      )
                    
                  
                
              
              )
            
          
          =
          
            C
            ⁡
            
              (
              
                Y
                -
                
                  [
                  
                    
                      X
                      ⁢
                      
                        
                      
                      ⁢
                      
                        β
                        
                          (
                          j
                          )
                        
                      
                    
                    +
                    
                      
                        γ
                        
                          (
                          j
                          )
                        
                      
                      ⁢
                      
                        Xp
                        
                          (
                          j
                          )
                        
                      
                    
                  
                  ]
                
              
              )
            
          
        
      
    
  
  
    
      
        =
        
          
            z
            
              (
              j
              )
            
          
          -
          
            
              γ
              
                (
                j
                )
              
            
            ⁢
            
              Cq
              
                (
                j
                )
              
            
          
        
      
    
  
  
    
      
        
          where
          ⁢
          
            
          
          ⁢
          
            q
            
              (
              j
              )
            
          
        
        =
        
          Xp
          
            (
            j
            )
          
        
      
    
  




The optimal choice of γ(j) is given by:





  
    γ
    
      (
      j
      )
    
  
  =
  
    
      
        
          
          
            r
            
              (
              j
              )
            
          
          
        
        2
      
      
        
          
            p
            
              
                (
                j
                )
              
              ⁢
              T
            
          
          ⁡
          
            (
            
              
                γ
                ⁢
                
                  
                
                ⁢
                I
              
              +
              
                
                  X
                  T
                
                ⁢
                CX
              
            
            )
          
        
        ⁢
        
          p
          
            (
            j
            )
          
        
      
    
    =
    
      
        
          
          
            r
            
              (
              j
              )
            
          
          
        
        2
      
      
        
          λ
          ⁢
          
            
              
              
                p
                
                  (
                  j
                  )
                
              
              
            
            2
          
        
        +
        
          
            q
            
              
                (
                j
                )
              
              ⁢
              T
            
          
          ⁢
          
            Cq
            
              (
              j
              )
            
          
        
      
    
  




Finally, the search directions are updated as:




  
    
      p
      
        (
        
          j
          +
          1
        
        )
      
    
    =
    
      
        r
        
          (
          
            j
            +
            1
          
          )
        
      
      +
      
        
          w
          
            (
            j
            )
          
        
        ⁢
        
          p
          
            (
            j
            )
          
        
      
    
  




  
    
      where
      ⁢
      
        
      
      ⁢
      
        w
        
          (
          j
          )
        
      
    
    =
    
      
        
          
          
            r
            
              (
              
                j
                +
                1
              
              )
            
          
          
        
        2
      
      
        
          
          
            r
            
              (
              j
              )
            
          
          
        
        2
      
    
  



The CGLS iterations are terminated when the norm of the gradient r(j+1) becomes small enough relative to the norm of the iterate z(j+1) or if the number of iterations exceed a certain maximum allowable number.
The CGLS iterations are listed in the table of FIG. 4. The data matrix X is only involved in the computations through matrix vector multiplication for computing the iterates q(j) and r(j). This forms the dominant expense in each iteration (the product with C simply scales each element of a vector). If there are no non-zero elements in the data matrix, this has O(n0) cost, where n0 is the number of non-zero elements in the data matrix. As a subroutine of L2-SVM-MFN, CGLS is typically called on a small subset of the full data set. The total cost of CGLS is O(tcglsn0) where tcgls is the number of iterations, which depends on the practical rank of X and is typically found to be very small relative to the dimensions of X (number of examples and features). The memory requirements are also minimal: only five vectors need to be maintained, including the outputs over the currently active set of data points.
Finally, another feature of CGLS is worth noting. Suppose the solution β of a regularizer least squares problem is available, i.e. the linear system in equation 5 has been solved using CGLS. If there is a need to solve a perturbed linear system, it is greatly advantageous in many settings to start the CG iterations for the new system with β as the initial guess. This is often called seeding. If the starting residual is small, CGLS can converge much faster than with a guess of 0 vector. The utility of this feature depends on the nature and degree of perturbation. In L2-SVM-MFN, the candidate solution w(k) obtained after line search in iteration k is seeded for the CGLS computation of wk in the next iteration. Also, in tuning λ over a range of values, it is computationally valuable to seed the solution for a particular λ onto the next value. For the transductive SVM implementation with L2-SVM-MFN, solutions are seeded across linear systems with slightly perturbed label vectors and data matrices.
Line Search
Given the vectors w, w in some iteration of L2-SVM-MFN, the line search step includes solving:




  
    δ
    *
  
  =
  
    
      
        
          arg
          ⁢
          
            
          
          ⁢
          min
        
        
          δ
          ≥
          0
        
      
      ⁢
      
        φ
        ⁡
        
          (
          δ
          )
        
      
    
    =
    
      f
      ⁡
      
        (
        
          w
          δ
        
        )
      
    
  




where wδ=w+δ( w−w).

The one-dimensional function φ(δ) is the restriction of the objective function ƒ on the ray from w onto w. Hence, like ƒ, φ(δ) is also a continuously differentiable, strictly convex, piecewise quadratic function with a unique minimizer δ* given by φ′(δ*)=0. Thus, one needs to find the root of the piecewise linear function




  
    
      
        
          
            φ
            ′
          
          ⁡
          
            (
            δ
            )
          
        
        =
        
          
            λ
            ⁢
            
              
            
            ⁢
            
              
                w
                δ
                T
              
              ⁡
              
                (
                
                  
                    w
                    _
                  
                  -
                  w
                
                )
              
            
          
          +
          
            
              ∑
              
                i
                ∈
                
                  j
                  ⁡
                  
                    (
                    
                      w
                      δ
                    
                    )
                  
                
              
            
            ⁢
            
              
                c
                i
              
              ⁢
              
                
                  d
                  i
                
                ⁡
                
                  (
                  
                    w
                    δ
                  
                  )
                
              
              ⁢
              
                (
                
                  
                    
                      o
                      _
                    
                    i
                  
                  -
                  
                    o
                    i
                  
                
                )
              
            
          
        
      
    
    
      
        (
        6
        )
      
    
  




where o=Xw, ō=X w.

The linear pieces of φ′ are defined over those intervals where j(wδ) remains constant. Thus, the break points occur at a certain set of values δi where




  
    
      w
      
        δ
        j
      
      T
    
    ⁢
    
      x
      i
    
  
  =
  
    
      y
      i
    
    .
  




for some data point indexed by, i.e.





  
    δ
    i
  
  =
  
    
      
        
          y
          i
        
        -
        
          o
          i
        
      
      
        
          
            o
            _
          
          i
        
        -
        
          o
          i
        
      
    
    =
    
      
        
          1
          -
          
            
              y
              i
            
            ⁢
            
              o
              i
            
          
        
        
          
            y
            i
          
          ⁡
          
            (
            
              
                
                  o
                  _
                
                j
              
              -
              
                o
                i
              
            
            )
          
        
      
      .
    
  




Among these values, only those indices i where δi≧0 i.e. if iεj(w) (then yioi<1), so yi(ōi−oi)>0 or if i∉j(w) (then yioi>1) are considered, so yi(ōi−oi)<0. When δ is increased past a δi1, in the former case the index i leaves j(w) and in the latter case it enters j(w). Reordering the indices so that δi, are sorted in a non-decreasing order as δj1,δj2 . . . , the root is then easily checked in each interval (δjk,δjk+1), k=1,2 . . . by keeping track of the slope of the linear piece in that interval. The slope is constant for each interval and non-decreasing as the search progresses through these ordered intervals. The interval in which the slope becomes non-negative for the first time brackets the root. Defining the extension of the linear piece in the interval




  
    
      
        (
        
          
            δ
            
              j
              k
            
          
          ,
          
            δ
            
              j
              
                k
                +
                1
              
            
          
        
        )
      
      ⁢
      
        
      
      ⁢
      as
      ⁢
      
        
      
      ⁢
      
        
          φ
          k
          ′
        
        ⁡
        
          (
          δ
          )
        
      
    
    =
    
      
        λ
        ⁢
        
          
        
        ⁢
        
          
            w
            δ
            T
          
          ⁡
          
            (
            
              
                w
                _
              
              -
              w
            
            )
          
        
      
      +
      
        
          ∑
          
            i
            ∈
            
              j
              ⁡
              
                (
                
                  w
                  ⁢
                  
                    
                  
                  ⁢
                  
                    δ
                    
                      j
                      k
                    
                  
                
                )
              
            
          
        
        ⁢
        
          
            c
            i
          
          ⁢
          
            
              d
              i
            
            ⁡
            
              (
              
                w
                δ
              
              )
            
          
          ⁢
          
            (
            
              
                
                  o
                  _
                
                i
              
              -
              
                o
                i
              
            
            )
          
        
      
    
  
  ,




the slope and the root computations are conveniently done by keeping track of





  
    
      
        
          L
          =
          
          ⁢
          
            
              
                φ
                k
                ′
              
              ⁡
              
                (
                0
                )
              
            
            =
            
              
                λ
                ⁢
                
                  
                
                ⁢
                
                  
                    w
                    T
                  
                  ⁡
                  
                    (
                    
                      
                        w
                        _
                      
                      -
                      w
                    
                    )
                  
                
              
              +
              
                
                  ∑
                  
                    i
                    ∈
                    
                      j
                      ⁡
                      
                        (
                        
                          w
                          ⁢
                          
                            
                          
                          ⁢
                          
                            δ
                            
                              j
                              k
                            
                          
                        
                        )
                      
                    
                  
                
                ⁢
                
                  
                    
                      c
                      i
                    
                    ⁡
                    
                      (
                      
                        
                          o
                          i
                        
                        -
                        
                          y
                          i
                        
                      
                      )
                    
                  
                  ⁢
                  
                    (
                    
                      
                        
                          o
                          _
                        
                        i
                      
                      -
                      
                        o
                        i
                      
                    
                    )
                  
                  ⁢
                  
                    
                  
                  ⁢
                  and
                
              
            
          
        
        ⁢
        
          
        
      
    
  
  
    
      
        R
        =
        
        ⁢
        
          
            
              φ
              k
              ′
            
            ⁡
            
              (
              1
              )
            
          
          =
          
            
              λ
              ⁢
              
                
              
              ⁢
              
                
                  
                    w
                    _
                  
                  T
                
                ⁡
                
                  (
                  
                    
                      w
                      _
                    
                    -
                    w
                  
                  )
                
              
            
            +
            
              
                ∑
                
                  i
                  ∈
                  
                    j
                    ⁡
                    
                      (
                      
                        w
                        ⁢
                        
                          
                        
                        ⁢
                        
                          δ
                          
                            j
                            k
                          
                        
                      
                      )
                    
                  
                
              
              ⁢
              
                
                  
                    c
                    i
                  
                  ⁡
                  
                    (
                    
                      
                        
                          o
                          _
                        
                        i
                      
                      -
                      
                        y
                        i
                      
                    
                    )
                  
                
                ⁢
                
                  
                    (
                    
                      
                        
                          o
                          _
                        
                        i
                      
                      -
                      
                        o
                        i
                      
                    
                    )
                  
                  .
                
              
            
          
        
      
    
  




The full line search routine is outlined in the table of FIG. 5.

The table of FIG. 6 provides an abridged pseudo-code for L2-SVM-MFN. Its computational complexity therefore is O(tmfn tcglsn0) where tmfn is the number of outer iterations of CGLS calls and line search, and tcgls is the average number of CGLS iterations. These depend on the data set and the tolerance desired in the stopping criterion, but are typically very small. Therefore the complexity is found to be linear in the number of entries in the data matrix.
Semi-Supervised Linear SVMs
It is now assumed that there are l labeled examples {xi,yi}i=1l and u unlabeled examples {x′j}j=1u with xi,x′jεRd and yiε{−1,+1}. The goal is to construct a linear classifier sign(wTx) that utilizes unlabeled data, typically in situations where l<<u. Semi-supervised algorithms provide L2-SVM-MFN the capability of dealing with unlabeled data.
Transductive SVM
Transductive SVM (TSVM) appends an additional term in the SVM objective function whose role is to drive the classification hyperplane towards low data density regions. The following optimization problem is setup for standard TSVM:



  
    
      w
      *
    
    =
    
      
        
          
            arg
            ⁢
            
              
            
            ⁢
            min
          
          
            
              w
              ∈
              
                R
                d
              
            
            ,
            
              
                {
                
                  
                    y
                    j
                    ′
                  
                  ∈
                  
                    {
                    
                      
                        -
                        1
                      
                      ,
                      
                        +
                        1
                      
                    
                    }
                  
                
                )
              
              
                j
                =
                1
              
              u
            
          
        
        ⁢
        
          λ
          2
        
        ⁢
        
          
            
            w
            
          
          2
        
      
      +
      
        
          1
          
            2
            ⁢
            l
          
        
        ⁢
        
          
            ∑
            
              i
              =
              1
            
            l
          
          ⁢
          
            max
            ⁡
            
              [
              
                0
                ,
                
                  1
                  -
                  
                    
                      y
                      i
                    
                    ⁡
                    
                      (
                      
                        
                          w
                          T
                        
                        ⁢
                        
                          x
                          i
                        
                      
                      )
                    
                  
                
              
              ]
            
          
        
      
      +
      
        
          
            λ
            ′
          
          
            2
            ⁢
            u
          
        
        ⁢
        
          
            ∑
            
              j
              =
              1
            
            u
          
          ⁢
          
            max
            ⁡
            
              [
              
                0
                ,
                
                  1
                  -
                  
                    
                      y
                      j
                      ′
                    
                    ⁡
                    
                      (
                      
                        
                          w
                          T
                        
                        ⁢
                        
                          x
                          j
                          ′
                        
                      
                      )
                    
                  
                
              
              ]
            
          
        
      
    
  




  
    
      subject
      ⁢
      
        
      
      ⁢
      to
      ⁢
      
        :
      
      ⁢
      
        
      
      ⁢
      
        1
        u
      
      ⁢
      
        
          ∑
          
            j
            =
            1
          
          u
        
        ⁢
        
          max
          ⁡
          
            [
            
              0
              ,
              
                sign
                ⁡
                
                  (
                  
                    
                      w
                      T
                    
                    ⁢
                    
                      x
                      j
                      ′
                    
                  
                  )
                
              
            
            ]
          
        
      
    
    =
    r
  



The labels on the unlabeled data, y′1 . . . y′u are {+1,−1}-valued variables in the optimization problem. In other words, TSVM seeks a hyperplane w and a labeling of the unlabeled examples, so that the SVM objective function is minimized, subject to the constraint that a fraction r of the unlabeled data be classified positive. SVM margin maximization in the presence of unlabeled examples can be interpreted as an implementation of the cluster assumption. In the optimization problem above, λ′ is a user-provided parameter that provides control over the influence of unlabeled data. If there is enough labeled data, λ,λ′,r can be tuned by cross-validation. An initial estimate of r can be made from the fraction of labeled examples that belong to the positive class and subsequent fine tuning can be done based on performance on a validation set.

In one method, this optimization is implemented by first using an inductive SVM to label the unlabeled data and then iteratively switching labels and retraining SVMs to improve the objective function. The TSVM algorithm is a wrapper around an SVM training procedure. In one existing software implemented system, the training of SVMs in the inner loops of TSVM uses dual decomposition techniques. In sparse, linear settings significant speed improvements can be obtained with L2-SVM-MFN over this software system. Thus, by implementing TSVM with L2-SVM-MFN, improvements are made for semi-supervised learning on large, sparse datasets. The L2-SVM-MFN retraining steps in the inner loop of TSVM are typically executed extremely fast by using seeding techniques. Additionally, in one embodiment of TSVM, more than one pair of labels may be switched in each iteration.
To develop the TSVM implementation with L2-SVM-MFN, the objective function is considered corresponding to equation 7 below, but with the L2 loss function:




  
    
      
        
          
            w
            *
          
          =
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
                
                  
                    w
                    ∈
                    
                      R
                      d
                    
                  
                  ,
                  
                    
                      {
                      
                        
                          y
                          j
                          ′
                        
                        ∈
                        
                          {
                          
                            
                              -
                              1
                            
                            ,
                            
                              +
                              1
                            
                          
                          }
                        
                      
                      )
                    
                    
                      j
                      =
                      1
                    
                    u
                  
                
              
              ⁢
              
                λ
                2
              
              ⁢
              
                
                  
                  w
                  
                
                2
              
            
            +
            
              
                1
                
                  2
                  ⁢
                  l
                
              
              ⁢
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  l
                
                ⁢
                
                  
                    max
                    ⁡
                    
                      [
                      
                        0
                        ,
                        
                          1
                          -
                          
                            
                              y
                              i
                            
                            ⁡
                            
                              (
                              
                                
                                  w
                                  T
                                
                                ⁢
                                
                                  x
                                  i
                                
                              
                              )
                            
                          
                        
                      
                      ]
                    
                  
                  2
                
              
            
            +
            
              
                
                  λ
                  ′
                
                
                  2
                  ⁢
                  u
                
              
              ⁢
              
                
                  ∑
                  
                    j
                    =
                    1
                  
                  u
                
                ⁢
                
                  
                    max
                    ⁡
                    
                      [
                      
                        0
                        ,
                        
                          1
                          -
                          
                            
                              y
                              j
                              ′
                            
                            ⁡
                            
                              (
                              
                                
                                  w
                                  T
                                
                                ⁢
                                
                                  x
                                  j
                                  ′
                                
                              
                              )
                            
                          
                        
                      
                      ]
                    
                  
                  2
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            subject
            ⁢
            
              
            
            ⁢
            to
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            
              1
              u
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                max
                ⁡
                
                  [
                  
                    0
                    ,
                    
                      sign
                      ⁢
                      
                        
                      
                      ⁢
                      
                        (
                        
                          
                            w
                            T
                          
                          ⁢
                          
                            x
                            j
                            ′
                          
                        
                        )
                      
                    
                  
                  ]
                
              
            
          
          =
          r
        
      
    
    
      
        (
        7
        )
      
    
  




Note that this objective function above can also be equivalently written in terms of the following loss over each unlabeled example x:

min(max[0,1−(wTx)]2,max[0,1+(wTx)]2)=max[0,1−|wTx|]2 

A value of the label variable y is selected that minimizes the loss on the unlabeled example x, and rewritten in terms of the absolute value of the output of the classifier on x. This loss function is shown in FIG. 7. It should be noted that the L1 and L2 loss terms over unlabeled examples are very similar on the interval [−1,+1]. The non-convexity of this loss function implies that the TSVM training procedure is susceptible to local optima issues. Next, a mean field annealing procedure is outlined that can overcome this problem.
The TSVM algorithm with L2-SVM-MFN is outlined in the table of FIG. 8. A classifier is obtained by first running L2-SVM-MFN on just the labeled examples. Temporary labels are assigned to the unlabeled data by thresholding the soft outputs of this classifier so that the fraction of the total number of unlabeled examples that are temporarily labeled positive equals the parameter r.
Then starting from a small value of λ′, the unlabeled data is gradually brought in by increasing λ′ by a factor of R where R is set to 2 in the outer loop. This gradual increase of the influence of the unlabeled data is a way to protect TSVM from being immediately trapped in a local minimum. An inner loop identifies up to S pairs of unlabeled examples with positive and negative temporary labels such that switching these labels would decrease the objective function. L2-SVM-MFN is then retrained with the switched labels.
Transductive L2-SVM-MFN with multiple-pair switching converges in a finite number of steps. Previous transductive support vector machine implementations used single switching (S=1) of labels. However, in the implementation of the present embodiment, larger values for S (S>1, i.e., multiple switching) are used which leads to a significant improvement in efficiency without any loss in performance.
L2-SVM-MFN on large sparse datasets combined with the efficiency gained from seeding w in the re-training steps (after switching labels or after increasing λ′) is very effective. Consider an iteration in Loop 2 of TSVM where a new pair of labels has been switched, and the solution w from the last retraining of L2-SVM-MFN (marked as Re-training 2 in FIG. 8) is available for seeding. When the last L2-SVM-MFN converged, its solution w is given by the linear systems:

[λI+XI(w)TCI(w)XI(w)]w=XI(w)TCI(w)Y 

where Y is the current label vector. When labels Yi,Yj are switched, back at the top of loop 2, the label vector is updated as:

Y=Y+2eij 

where eij is a vector whose elements zero everywhere except in the ith and the jth position which are +1 and −1 or −1 and +1 respectively. Note also that if i,j εj(w) the re-training of L2-SVM-MFN with w as the starting guess immediately encounters a call CGLS to solve the following perturbed system:

[λI+Xj(w)TCj(w)Xj(w)] w=Xj(w)TCj(w)[Y+2eij]

The starting residual vector r0 is given by:





  
    
      
        
          r
          0
        
        =
        
        ⁢
        
          
            
              X
              
                j
                ⁡
                
                  (
                  w
                  )
                
              
              T
            
            ⁢
            
              
                C
                
                  j
                  ⁡
                  
                    (
                    w
                    )
                  
                
              
              ⁡
              
                [
                
                  Y
                  +
                  
                    2
                    ⁢
                    
                      e
                      ij
                    
                  
                
                ]
              
            
          
          -
          
            
              [
              
                
                  λ
                  ⁢
                  
                    
                  
                  ⁢
                  I
                
                +
                
                  
                    X
                    
                      j
                      ⁡
                      
                        (
                        w
                        )
                      
                    
                    T
                  
                  ⁢
                  
                    C
                    
                      j
                      ⁡
                      
                        (
                        w
                        )
                      
                    
                  
                  ⁢
                  
                    X
                    
                      j
                      ⁡
                      
                        (
                        w
                        )
                      
                    
                  
                
              
              ]
            
            ⁢
            w
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            r
            ⁡
            
              (
              w
              )
            
          
          +
          
            2
            ⁢
            
              X
              
                j
                ⁡
                
                  (
                  w
                  )
                
              
              T
            
            ⁢
            
              C
              
                j
                ⁡
                
                  (
                  w
                  )
                
              
            
            ⁢
            
              e
              ij
            
          
        
      
    
  
  
    
      
        ≤
        
        ⁢
        
          ε
          +
          
            2
            ⁢
            
              λ
              ′
            
            ⁢
            
              
              
                
                  x
                  i
                
                -
                
                  x
                  j
                
              
              
            
          
        
      
    
  




where r(w) in the second step is the final residual of w which fell below ε at the convergence of the last re-training. In applications, such as text categorization, TFIDF feature vectors are often length normalized and have positive entries. Therefore, ∥xi−xj∥≧√{square root over (2)}. This gives the following bound on the starting residual:

r0≧ε+2√{square root over (2)}λ′

which is much smaller than a bound of n√{square root over (n)}λ′ with a zero starting vector. Seeding is quite effective for Loop 1 as well, where λ′ is changed. With the two additional loops, the complexity of Transductive L2-TSVM-MFN becomes O(nswitches tmfn tcglsn0), where nswitches is the number of label switches. The outer loop executes a fixed number of times; the inner loop calls L2-TSVM-MFN nswitches times. Typically, nswitches is expected to strongly depend on the data set and also on the number of labeled examples. Since it is difficult to apriori estimate the number of switches, this is an issue that is best understood from empirical observations.

Mean Field Annealing
The transductive SVM loss function over the unlabeled examples can be seen from FIG. 7 to be non-convex. This makes the TSVM optimization procedure susceptible to local minimum issues causing a loss in its performance in many situations. A new algorithm that is based on mean field annealing can be used to overcome this problem while also being computationally very attractive for large scale applications.
Mean field annealing (MFA) is an established tool for combinatorial optimization that approaches the problem from information theoretic principles. The discrete variables in the optimization problem are relaxed to continuous probability variables and a non-negative temperature parameter T is used to track the global optimum.
First, the TSVM objective function is re-written as follows:




  
    w
    *
  
  =
  
    
      
        
          arg
          ⁢
          
            
          
          ⁢
          min
        
        
          
            w
            ∈
            
              R
              d
            
          
          ,
          
            
              {
              
                
                  μ
                  j
                
                ∈
                
                  {
                  
                    0
                    ,
                    1
                  
                  }
                
              
              }
            
            
              j
              =
              1
            
            u
          
        
      
      ⁢
      
        λ
        2
      
      ⁢
      
        
          
          w
          
        
        2
      
    
    +
    
      
        1
        
          2
          ⁢
          l
        
      
      ⁢
      
        
          ∑
          
            i
            =
            1
          
          l
        
        ⁢
        
          
            max
            ⁡
            
              [
              
                0
                ,
                
                  1
                  -
                  
                    
                      y
                      i
                    
                    ⁡
                    
                      (
                      
                        
                          w
                          T
                        
                        ⁢
                        
                          x
                          i
                        
                      
                      )
                    
                  
                
              
              ]
            
          
          2
        
      
    
    +
    
      
        
          λ
          ′
        
        
          2
          ⁢
          u
        
      
      ⁢
      
        
          ∑
          
            j
            =
            1
          
          u
        
        ⁢
        
          (
          
            
              
                μ
                j
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        -
                        
                          (
                          
                            
                              w
                              T
                            
                            ⁢
                            
                              x
                              j
                              ′
                            
                          
                          )
                        
                      
                    
                    ]
                  
                
                2
              
            
            +
            
              
                (
                
                  1
                  -
                  
                    μ
                    j
                  
                
                )
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        +
                        
                          (
                          
                            
                              w
                              T
                            
                            ⁢
                            
                              x
                              j
                              ′
                            
                          
                          )
                        
                      
                    
                    ]
                  
                
                2
              
            
          
          )
        
      
    
  




Binary valued variables μj=(1+yj)/2 are introduced. Let pjε[0,1] denote the probability that the unlabeled example belongs to the positive class. The Ising model 10 of Mean field annealing motivates the following objective function, where the binary variables μj are relaxed to probability variables pj, and include entropy terms for the distributions defined by pj:




  
    
      
        
          w
          T
          *
        
        =
        
          
            
              
                arg
                ⁢
                
                  
                
                ⁢
                min
              
              
                
                  w
                  ∈
                  
                    R
                    d
                  
                
                ,
                
                  
                    {
                    
                      
                        p
                        j
                      
                      ∈
                      
                        [
                        
                          0
                          ⁢
                          
                            
                          
                          ⁢
                          1
                        
                        ]
                      
                    
                    }
                  
                  
                    j
                    =
                    1
                  
                  u
                
              
            
            ⁢
            
              λ
              2
            
            ⁢
            
              
                
                w
                
              
              2
            
          
          +
          
            
              1
              
                2
                ⁢
                l
              
            
            ⁢
            
              
                ∑
                
                  i
                  =
                  1
                
                l
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        -
                        
                          
                            y
                            i
                          
                          ⁡
                          
                            (
                            
                              
                                w
                                T
                              
                              ⁢
                              
                                x
                                i
                              
                            
                            )
                          
                        
                      
                    
                    ]
                  
                
                2
              
            
          
          +
          
            
              
                λ
                ′
              
              
                2
                ⁢
                u
              
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                (
                
                  
                    
                      p
                      j
                    
                    ⁢
                    
                      
                        max
                        ⁡
                        
                          [
                          
                            0
                            ,
                            
                              1
                              -
                              
                                (
                                
                                  
                                    w
                                    T
                                  
                                  ⁢
                                  
                                    x
                                    j
                                    ′
                                  
                                
                                )
                              
                            
                          
                          ]
                        
                      
                      2
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        
                          p
                          j
                        
                      
                      )
                    
                    ⁢
                    
                      
                        max
                        ⁡
                        
                          [
                          
                            0
                            ,
                            
                              1
                              +
                              
                                (
                                
                                  
                                    w
                                    T
                                  
                                  ⁢
                                  
                                    x
                                    j
                                    ′
                                  
                                
                                )
                              
                            
                          
                          ]
                        
                      
                      2
                    
                  
                
                )
              
            
          
          +
          
            
              T
              
                2
                ⁢
                u
              
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                (
                
                  
                    
                      p
                      j
                    
                    ⁢
                    
                      
                    
                    ⁢
                    log
                    ⁢
                    
                      
                    
                    ⁢
                    
                      p
                      j
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        
                          p
                          j
                        
                      
                      )
                    
                    ⁢
                    
                      
                    
                    ⁢
                    log
                    ⁢
                    
                      
                    
                    ⁢
                    
                      (
                      
                        1
                        -
                        
                          p
                          j
                        
                      
                      )
                    
                  
                
                )
              
            
          
        
      
    
    
      
        (
        8
        )
      
    
  




The “temperature” T parameterizes a family of objective functions. The objective function for a fixed T is minimized under the following class balancing constraints:




  
    
      
        
          
            1
            u
          
          ⁢
          
            
              ∑
              
                j
                =
                1
              
              u
            
            ⁢
            
              p
              j
            
          
        
        =
        r
      
    
    
      
        (
        9
        )
      
    
  




where r is the fraction of the number of unlabeled examples belonging to the positive class. As in TSVM, r is treated as a user-provided parameter. It may also be estimated from the labeled examples.
The solution to the optimization problem above is tracked as the temperature parameter T is lowered to 0. The final solution is given as:




  
    
      
        
          w
          *
        
        =
        
          
            lim
            
              T
              →
              0
            
          
          ⁢
          
            w
            T
            *
          
        
      
    
    
      
        (
        10
        )
      
    
  




In practice, the system (indexer 104) monitors the value of the objective function in the optimization path and returns the solution corresponding to the minimum value achieved.

To develop an intuition for this method, the loss term is considered in the objective function associated with an unlabeled example as a function of the output of the classifier. This loss term is based on calculations to be described below. FIG. 9 plots this loss term for various values of T. As the temperature is decreased, the loss function deforms from a squared-loss shape where a global optimum is easier to achieve, to the TSVM loss function in FIG. 7. At high temperatures a global optimum is easier to obtain. The global minimizer is then slowly tracked as the temperature is lowered towards zero.
The optimization is done in stages, starting with high values of T and then gradually decreasing T towards 0. For each T, the problem in equations 8,9 is optimized by alternating the minimization over w and p=[p1 . . . pu] respectively. Fixing p, the optimization over w is done by L2-SVM-MFN. Fixing w, the optimization over p can also be done easily as described below. Both these problems involve convex optimization and can be done exactly and efficiently. Details of these optimization steps follow.
Optimizing w
Described are the steps to efficiently implement the L2-SVM-MFN loop for optimizing w keeping p fixed. The call to L2-SVM-MFN is made on the data {circumflex over (X)}=[XTX′TX′T]T whose first l rows are formed by the labeled examples, and the next 2u rows are formed by the unlabeled examples appearing as two repeated blocks. The associated label vector and cost matrix are given by




  
    
      
        
          
            Y
            ^
          
          =
          
            [
            
              
                y
                1
              
              ,
              
                
                  y
                  2
                
                ⁢
                ...
                ⁢
                
                  
                
                ⁢
                
                  y
                  l
                
              
              ,
              
                
                  
                    1
                    ,
                    1
                    ,
                    
                      ...
                      ⁢
                      
                        
                      
                      ⁢
                      1
                    
                    ,
                  
                  
                    {
                    u
                  
                
                ⁢
                
                  
                    
                      -
                      1
                    
                    ,
                    
                      -
                      1
                    
                    ,
                    
                      ...
                      -
                      1
                    
                  
                  
                    {
                    u
                  
                
              
            
            ]
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                C
                =
                
                  diag
                  [
                  
                    
                      
                        
                          1
                          l
                        
                        ⁢
                        ...
                        ⁢
                        
                          1
                          l
                        
                      
                      
                        {
                        l
                      
                    
                    ,
                    
                      
                        
                          
                            
                              
                                λ
                                ′
                              
                              ⁢
                              
                                p
                                1
                              
                            
                            u
                          
                          ⁢
                          ...
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              
                                λ
                                ′
                              
                              ⁢
                              
                                p
                                u
                              
                            
                            u
                          
                        
                        
                          {
                          u
                        
                      
                      ⁢
                      
                        
                          
                            
                              
                                λ
                                ′
                              
                              ⁡
                              
                                (
                                
                                  1
                                  -
                                  
                                    p
                                    1
                                  
                                
                                )
                              
                            
                            u
                          
                          ⁢
                          ...
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              
                                λ
                                ′
                              
                              ⁡
                              
                                (
                                
                                  1
                                  -
                                  
                                    p
                                    u
                                  
                                
                                )
                              
                            
                            u
                          
                        
                        
                          {
                          u
                        
                      
                    
                  
                  ]
                
              
            
            
              
                
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  




Even though each unlabeled data contributes two terms to the objective function, effectively only one term contributes to the complexity. This is because matrix-vector products, which form the dominant expense in L2-SVM-MFN, are performed only on unique rows of a matrix. The output may be duplicated for duplicate rows.

In fact, the CGLS calls in L2-SVM-MFN can be re-written so that the unlabeled examples appear only once in the data matrix. The CGLS call at some iteration where the active index set is j=j(w) for some current candidate weight vector w is as follows:

[λI+{circumflex over (X)}jTCj{circumflex over (X)}j] w={circumflex over (X)}TCjŶj  (12)

Note that if |wTx′j|≧1, the unlabeled example x′j appears as one row in the data matrix {circumflex over (X)}j with label given by −sign(wTx′j). If |wTx′j|<1, the unlabeled example x′j appears as two identical rows x′j with both labels. Let jlε1 . . . l be the indices of the labeled examples in the active set, j′1ε1 . . . u be the indices of unlabeled examples with |wTx′j|≧1 and j′2ε1 . . . u be the indices of unlabeled examples with |wTx′j|<1. Note that the index of every unlabeled example appears in one of these sets i.e., j′1∪j′2=1 . . . u. Equation 12 may be re-written as:




  
    
      [
      
        
          λ
          ⁢
          
            
          
          ⁢
          I
        
        +
        
          
            1
            l
          
          ⁢
          
            
              ∑
              
                i
                ∈
                
                  j
                  l
                
              
            
            ⁢
            
              
                x
                i
                T
              
              ⁢
              
                x
                i
              
            
          
        
        +
        
          
            
              λ
              ′
            
            u
          
          ⁢
          
            
              ∑
              
                j
                ∈
                
                  j
                  1
                  ′
                
              
            
            ⁢
            
              
                c
                j
              
              ⁢
              
                x
                j
                
                  ′
                  ⁢
                  
                    
                  
                  ⁢
                  T
                
              
              ⁢
              
                x
                j
              
            
          
        
        +
        
          
            
              λ
              ′
            
            u
          
          ⁢
          
            
              ∑
              
                j
                ∈
                
                  j
                  2
                  ′
                
              
            
            ⁢
            
              
                x
                j
                
                  ′
                  ⁢
                  
                    
                  
                  ⁢
                  T
                
              
              ⁢
              
                x
                j
              
            
          
        
      
      ]
    
    ⁢
    
      
    
    ⁢
    
      w
      _
    
  
  =
  
    
      
        1
        l
      
      ⁢
      
        
          ∑
          
            i
            ∈
            
              j
              l
            
          
        
        ⁢
        
          
            y
            i
          
          ⁢
          
            x
            i
          
        
      
    
    -
    
      
        
          λ
          ′
        
        u
      
      ⁢
      
        
          ∑
          
            j
            ∈
            
              j
              1
              ′
            
          
        
        ⁢
        
          
            c
            j
          
          ⁢
          
            
          
          ⁢
          sign
          ⁢
          
            
          
          ⁢
          
            (
            
              
                w
                T
              
              ⁢
              
                x
                j
              
            
            )
          
          ⁢
          
            x
            j
          
        
      
    
    +
    
      
        
          λ
          ′
        
        u
      
      ⁢
      
        
          ∑
          
            j
            ∈
            
              j
              2
              ′
            
          
        
        ⁢
        
          
            (
            
              
                2
                ⁢
                
                  p
                  j
                
              
              -
              1
            
            )
          
          ⁢
          
            x
            j
          
        
      
    
  




where cj=pj if sign(wTx′j)=−1 and cj=1−pj if sign(wTx′j)=1. Rewriting in matrix notation, an equivalent linear system is obtained that can be solved by CGLS:

[λI+ XT C X] w= XT C Y  (13)

where X=[XjiTX′], C is a diagonal matrix and Y is the vector of effectively active labels. Each of these data objects have l+u rows. These are given by:





  
    
      
        
          
            
              
                
                  
                    
                      C
                      _
                    
                    jj
                  
                  =
                  
                    1
                    l
                  
                
                ,
                
                  
                    
                      Y
                      _
                    
                    j
                  
                  =
                  
                    
                      
                        y
                        i
                      
                      ⁢
                      
                        
                      
                      ⁢
                      j
                    
                    ∈
                    
                      1
                      ⁢
                      ...
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                        
                          j
                          l
                        
                        
                      
                    
                  
                
              
              ⁢
              
                

              
              ⁢
              
                
                  C
                  _
                
                
                  
                    (
                    
                      j
                      +
                      
                        
                        
                          j
                          l
                        
                        
                      
                    
                    )
                  
                  ⁢
                  
                    (
                    
                      j
                      +
                      
                        
                        
                          j
                          l
                        
                        
                      
                    
                    )
                  
                
              
            
            =
            
              
                
                  λ
                  ′
                
                ⁢
                
                  p
                  j
                
              
              u
            
          
          ,
          
            
              
                Y
                _
              
              
                j
                +
                
                  
                  
                    j
                    l
                  
                  
                
              
            
            =
            
              
                1
                ⁢
                
                  
                
                ⁢
                if
                ⁢
                
                  
                
                ⁢
                j
              
              ∈
              
                1
                ⁢
                ...
                ⁢
                
                  
                
                ⁢
                u
              
            
          
          ,
          
            j
            ∈
            
              j
              1
              ′
            
          
          ,
          
            
              sign
              ⁢
              
                
                  
                
                ⁢
                
                  
                
              
              (
              
                
                  w
                  T
                
                ⁢
                
                  x
                  j
                  ′
                
              
              )
            
            =
            
              -
              1
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                C
                _
              
              
                
                  (
                  
                    j
                    +
                    
                      
                      
                        j
                        l
                      
                      
                    
                  
                  )
                
                ⁢
                
                  (
                  
                    j
                    +
                    
                      
                      
                        j
                        l
                      
                      
                    
                  
                  )
                
              
            
            =
            
              
                
                  λ
                  ′
                
                ⁡
                
                  (
                  
                    1
                    -
                    
                      p
                      j
                    
                  
                  )
                
              
              u
            
          
          ,
          
            
              
                Y
                _
              
              
                j
                +
                
                  
                  
                    j
                    l
                  
                  
                
              
            
            =
            
              
                
                  -
                  1
                
                ⁢
                
                  
                
                ⁢
                if
                ⁢
                
                  
                
                ⁢
                j
              
              ∈
              
                1
                ⁢
                ...
                ⁢
                
                  
                
                ⁢
                u
                ⁢
                
                  
                
                ⁢
                j
              
              ∈
              
                j
                1
                ′
              
            
          
          ,
          
            
              sign
              ⁢
              
                
              
              ⁢
              
                (
                
                  
                    w
                    T
                  
                  ⁢
                  
                    x
                    j
                    ′
                  
                
                )
              
            
            =
            1
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                C
                _
              
              
                
                  (
                  
                    j
                    +
                    
                      
                      
                        j
                        l
                      
                      
                    
                  
                  )
                
                ⁢
                
                  (
                  
                    j
                    +
                    
                      
                      
                        j
                        l
                      
                      
                    
                  
                  )
                
              
            
            =
            
              
                λ
                ′
              
              u
            
          
          ,
          
            
              
                Y
                _
              
              
                j
                +
                
                  
                  
                    j
                    l
                  
                  
                
              
            
            =
            
              
                
                  (
                  
                    
                      2
                      ⁢
                      
                        p
                        j
                      
                    
                    -
                    1
                  
                  )
                
                ⁢
                
                  
                
                ⁢
                if
                ⁢
                
                  
                
                ⁢
                j
              
              ∈
              
                1
                ⁢
                ...
                ⁢
                
                  
                
                ⁢
                u
                ⁢
                
                  
                
                ⁢
                j
              
              ∈
              
                j
                2
                ′
              
            
          
        
      
    
    
      
        (
        14
        )
      
    
  




Thus, CGLS needs to only operate on data matrices with one instance of each unlabeled example using a suitably modified cost matrix and label vector.

After the CGLS step, the optimality conditions are checked. The optimality conditions can be re-written as:

∀iεjl yiōi≦1+ε

∀iεjlc yiōi≧1−ε

∀jεj′1 |ō′j|≧1−ε

∀jεj′2 |ō′j|≦1+ε

For the subsequent line search step, appropriate output and label vectors are reassembled to call the routine in the table of FIG. 5. The steps for optimizing w: are outlined in the table of FIG. 10.

Optimizing p
For the latter problem of optimizing p for a fixed wi, the Lagrangian is constructed:




  L
  =
  
    
      
        
          λ
          ′
        
        
          2
          ⁢
          u
        
      
      ⁢
      
        
          ∑
          
            j
            =
            1
          
          u
        
        ⁢
        
          (
          
            
              
                p
                j
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        -
                        
                          (
                          
                            
                              w
                              T
                            
                            ⁢
                            
                              x
                              j
                              ′
                            
                          
                          )
                        
                      
                    
                    ]
                  
                
                2
              
            
            +
            
              
                (
                
                  1
                  +
                  
                    p
                    j
                  
                
                )
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        ⁢
                        
                          
                        
                        ⁢
                        
                          (
                          
                            
                              w
                              T
                            
                            ⁢
                            
                              x
                              j
                              ′
                            
                          
                          )
                        
                      
                    
                    ]
                  
                
                2
              
            
          
          )
        
      
    
    +
    
      
        T
        
          2
          ⁢
          u
        
      
      ⁢
      
        
          ∑
          
            j
            =
            1
          
          u
        
        ⁢
        
          (
          
            
              
                p
                j
              
              ⁢
              
                
              
              ⁢
              log
              ⁢
              
                
              
              ⁢
              
                p
                j
              
            
            +
            
              
                (
                
                  1
                  -
                  
                    p
                    j
                  
                
                )
              
              ⁢
              
                
              
              ⁢
              log
              ⁢
              
                
              
              ⁢
              
                (
                
                  1
                  -
                  
                    p
                    j
                  
                
                )
              
            
          
          )
        
      
    
    -
    
      v
      ⁡
      
        [
        
          
            
              1
              u
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                p
                j
              
            
          
          -
          r
        
        ]
      
    
  




Differentiating the Lagrangian with respect to pj, the following is obtained:





  
    
      ∂
      L
    
    
      ∂
      
        p
        j
      
    
  
  =
  
    
      
        
          
            λ
            ′
          
          
            2
            ⁢
            u
          
        
        ⁢
        
          (
          
            
              
                max
                ⁡
                
                  [
                  
                    0
                    ,
                    
                      1
                      -
                      
                        (
                        
                          
                            w
                            T
                          
                          ⁢
                          
                            x
                            j
                            ′
                          
                        
                        )
                      
                    
                  
                  ]
                
              
              2
            
            -
            
              
                max
                ⁡
                
                  [
                  
                    0
                    ,
                    
                      1
                      +
                      
                        (
                        
                          
                            w
                            T
                          
                          ⁢
                          
                            x
                            j
                            ′
                          
                        
                        )
                      
                    
                  
                  ]
                
              
              2
            
          
          )
        
      
      +
      
        
          T
          
            2
            ⁢
            u
          
        
        ⁢
        log
        ⁢
        
          
            p
            j
          
          
            1
            -
            
              p
              j
            
          
        
      
      -
      
        v
        u
      
    
    =
    0
  




Defining

gj=λ′(max[0,1−(wTx′j)]2−max[0,1+(wTx′j)]2),

the expression for pj is given by:





  
    
      
        
          p
          j
        
        =
        
          1
          
            1
            +
            
              e
              
                
                  
                    g
                    j
                  
                  -
                  
                    2
                    ⁢
                    v
                  
                
                T
              
            
          
        
      
    
    
      
        (
        15
        )
      
    
  




Substituting this expression in the balance constraint in equation 9, a one-dimensional non-linear equation in v is as follows:





  
    
      1
      u
    
    ⁢
    
      
        ∑
        
          j
          =
          1
        
        u
      
      ⁢
      
        1
        
          1
          +
          
            e
            
              
                
                  g
                  i
                
                -
                
                  2
                  ⁢
                  v
                
              
              T
            
          
        
      
    
  
  =
  r




The value of 2 v is computed exactly by using a hybrid combination of Newton-Raphson iterations and the bisection method to find the root of the function





  
    B
    ⁡
    
      (
      v
      )
    
  
  =
  
    
      
        1
        u
      
      ⁢
      
        
          ∑
          
            i
            =
            
              l
              +
              1
            
          
          
            l
            +
            u
          
        
        ⁢
        
          1
          
            1
            +
            
              e
              
                
                  
                    g
                    i
                  
                  -
                  v
                
                T
              
            
          
        
      
    
    -
    
      r
      .
    
  




This method is rapid due to the quadratic convergence properties of Newton-Raphson iterations and fail-safe due to bisection steps. Note that the root exists and is unique, since one can see that B(v)→1−r>0 when v→∞, B(v)→−r<0 when v→−∞, and B(v) is a continuous, monotonically increasing function, as shown in FIG. 11. The root finding begins by bracketing the root in the interval [v−,v+] so that B(v−)<0, B(v+)>0 where v−,v+ are given by:




  
    
      v
      -
    
    =
    
      
        min
        ⁡
        
          (
          
            
              g
              1
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            
              g
              i
            
          
          )
        
      
      -
      
        T
        ⁢
        
          
        
        ⁢
        log
        ⁢
        
          
            1
            -
            r
          
          r
        
      
    
  




  
    
      v
      +
    
    =
    
      
        max
        ⁡
        
          (
          
            
              g
              1
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            
              g
              u
            
          
          )
        
      
      -
      
        T
        ⁢
        
          
        
        ⁢
        log
        ⁢
        
          
            1
            -
            r
          
          r
        
      
    
  



The hybrid root finding algorithm performs Newton-Raphson iterations with a starting guess of




  
    
      v
      -
    
    +
    
      v
      +
    
  
  2




and invokes the bisection method whenever an iterate goes outside the brackets. The steps for optimizing p are outlined in table if FIG. 12.

Stopping Criteria
For a fixed T, this alternate minimization proceeds until some stopping criterion is satisfied. A natural criterion is the known mean Kullback-Liebler divergence (relative entropy) KL(p,q) between current values of pi and the values, say qi1, at the end of last iteration. Thus the stopping criterion for fixed T is:




  
    
      
        
          KL
          ⁡
          
            (
            
              p
              ,
              q
            
            )
          
        
        =
        
          
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                
                  p
                  j
                
                ⁢
                log
                ⁢
                
                  
                
                ⁢
                
                  
                    p
                    j
                  
                  
                    q
                    j
                  
                
              
            
            +
            
              
                (
                
                  1
                  -
                  
                    p
                    j
                  
                
                )
              
              ⁢
              
                
              
              ⁢
              log
              ⁢
              
                
                  1
                  -
                  
                    p
                    j
                  
                
                
                  1
                  -
                  
                    q
                    j
                  
                
              
            
          
          <
          
            u
            ⁢
            
              
            
            ⁢
            ε
          
        
      
    
    
      
        (
        16
        )
      
    
  




A good value for ε is 10−6. The temperature may be decreased in the outer loop until the total entropy falls below a threshold T, which is also taken to be 10−6:





  
    
      
        
          H
          ⁡
          
            (
            p
            )
          
        
        =
        
          
            -
            
              
                ∑
                
                  j
                  =
                  l
                
                u
              
              ⁢
              
                (
                
                  
                    
                      p
                      j
                    
                    ⁢
                    
                      
                    
                    ⁢
                    log
                    ⁢
                    
                      
                    
                    ⁢
                    
                      p
                      j
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        
                          p
                          j
                        
                      
                      )
                    
                    ⁢
                    
                      
                    
                    ⁢
                    log
                    ⁢
                    
                      
                    
                    ⁢
                    
                      (
                      
                        1
                        -
                        
                          p
                          j
                        
                      
                      )
                    
                  
                
                )
              
            
          
          <
          
            u
            ⁢
            
              
            
            ⁢
            ε
          
        
      
    
    
      
        (
        17
        )
      
    
  




The TSVM objective function is monitored as the optimization proceeds.





  
    
      
        
          J
          ⁡
          
            (
            w
            )
          
        
        =
        
          
            
              λ
              2
            
            ⁢
            
              
                
                w
                
              
              2
            
          
          +
          
            
              1
              
                2
                ⁢
                l
              
            
            ⁢
            
              
                ∑
                
                  i
                  =
                  1
                
                l
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        -
                        
                          
                            y
                            i
                          
                          ⁡
                          
                            (
                            
                              
                                w
                                T
                              
                              ⁢
                              
                                x
                                i
                              
                            
                            )
                          
                        
                      
                    
                    ]
                  
                
                2
              
            
          
          +
          
            
              
                λ
                ′
              
              
                2
                ⁢
                u
              
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        -
                        
                          
                          
                            
                              w
                              T
                            
                            ⁢
                            
                              x
                              j
                              ′
                            
                          
                          
                        
                      
                    
                    ]
                  
                
                2
              
            
          
        
      
    
    
      
        (
        18
        )
      
    
  




The weight vector corresponding to the minimum transductive cost is returned as the solution. The steps of mean field annealing with L2-SVM-MFN are outlined in the table of FIG. 13.
Application to One-Class Problems
The transductive SVM and mean field annealing algorithms described above can be deployed in a variety of settings involving different amounts of labeled and unlabeled data. Many settings present the task of identifying members of a certain class as opposed to distinguishing between well-specified classes. For example, in order to identify web documents concerning sports, it is much easier to label sports documents than to label the diverse and ill-characterized set of non-sports documents. In such problems, labeled examples come from a single class, very often with large amounts of unlabeled data containing some instances of the class of interest and many instances of the “others” class.
Being a special case of semi-supervised learning, the problem of one-class learning with unlabeled data can be addressed by the algorithms developed in this paper. These algorithms implement the cluster assumption under constraints on class ratios. For one-class problems, unlabeled data is expected to be helpful in biasing the classification hyperplane to pass through a low density region keeping clusters of the relevant class on one side and instances of the “others” class on the other side. The fraction r can first be crudely estimated using a small random sample and then finely adjusted based on validation performance of the trained classifier.
The various embodiments described above are provided by way of illustration only and should not be construed to limit the invention. Those skilled in the art will readily recognize various modifications and changes that may be made to the claimed invention without following the example embodiments and applications illustrated and described herein, and without departing from the true spirit and scope of the claimed invention, which is set forth in the following claims.

## Claims

1. A computerized method for semi-supervised learning for web page classification, comprising:
receiving a set of web pages as training elements;
labeling some of the elements of the set of training elements that are determined to fall within a classification group, the set of training elements thereby having labeled elements and unlabeled elements;
using selected labeled elements and unlabeled elements as examples in a semi-supervised support vector machine implemented using a mean field annealing method, constructing a continuous loss function from a non-continuous loss function, train a linear classifier;
receiving unclassified web pages; and
classifying the unclassified web pages using the trained linear classifier.

2. The method of claim 1, wherein the number of unlabeled elements in the set of training elements that fall within the classification group is specified as an estimate.

3. The method of claim 1, wherein the semi-supervised support vector machine uses a finite Newton method for fast training.

4. The method of claim 3, wherein a step w(k)=w(k)+n(k) in the finite Newton method for determining a weight vector w in a k-th iteration, with n being a Newton step, is given by solving the following linear system associated with a weighted linear regularized least squares problem over a data subset defined by a set of active indices j(w(k)):


[λI+Xj(w(k))TCj(w(k))Xj(w(k))] w(k)=Xj(w(k))TCj(w(k))Yj(w(k)) 

where I is the identity matrix, and wherein once w(k) is obtained, w(k+1) is obtained from w(k+1)=w(k)+δ(k)n(k) by setting w(k+1)=w(k)+δk( w(k)−w(k)) after performing an exact line search for δk , which is by exactly solving a one-dimensional minimization problem:





  
    δ
    
      (
      k
      )
    
  
  =
  
    
      
        arg
        ⁢
        
          
        
        ⁢
        min
      
      
        δ
        ⁢
        
          
        
        ≥
        0
      
    
    ⁢
    
      
        f
        (
        
          
            w
            
              (
              k
              )
            
          
          +
          
            δ
            ⁡
            
              (
              
                
                  
                    w
                    _
                  
                  
                    (
                    k
                    )
                  
                
                -
                
                  w
                  
                    (
                    k
                    )
                  
                
              
              )
            
          
        
        )
      
      .

5. The method of claim 4, wherein the modified Newton method uses a conjugate gradient for least squares method to solve large, sparse, weighted regularized least squares problem.

6. The method of claim 1, wherein the semi-supervised support vector machine is implemented using a modified finite Newton method with one or multiple switching of labels of unlabeled example elements from the training set.

7. The method of claim 6, wherein the objective function is as follows



  
    
      w
      *
    
    =
    
      
        
          
            arg
            ⁢
            
              
            
            ⁢
            min
          
          
            
              w
              ∈
              
                
              
              ⁢
              
                R
                d
              
            
            ,
            
              
                {
                
                  
                    y
                    j
                    ′
                  
                  ∈
                  
                    {
                    
                      
                        -
                        1
                      
                      ,
                      
                        +
                        1
                      
                    
                    }
                  
                
                }
              
              
                j
                =
                1
              
              u
            
          
        
        ⁢
        
          λ
          2
        
        ⁢
        
          
            
            w
            
          
          2
        
      
      +
      
        
          1
          
            2
            ⁢
            l
          
        
        ⁢
        
          
            ∑
            
              i
              =
              1
            
            l
          
          ⁢
          
            
              max
              ⁡
              
                [
                
                  0
                  ,
                  
                    1
                    -
                    
                      
                        y
                        i
                      
                      ⁡
                      
                        (
                        
                          
                            w
                            T
                          
                          ⁢
                          
                            x
                            i
                          
                        
                        )
                      
                    
                  
                
                ]
              
            
            2
          
        
      
      +
      
        
          
            λ
            ′
          
          
            2
            ⁢
            u
          
        
        ⁢
        
          
            ∑
            
              j
              =
              1
            
            u
          
          ⁢
          
            
              max
              ⁡
              
                [
                
                  0
                  ,
                  
                    1
                    -
                    
                      
                        y
                        j
                        ′
                      
                      ⁡
                      
                        (
                        
                          
                            w
                            T
                          
                          ⁢
                          
                            x
                            j
                            ′
                          
                        
                        )
                      
                    
                  
                
                ]
              
            
            2
          
        
      
    
  




  
    
      subject
      ⁢
      
        
      
      ⁢
      to
      ⁢
      
        :
      
      ⁢
      
        
      
      ⁢
      
        1
        u
      
      ⁢
      
        
          ∑
          
            j
            =
            1
          
          u
        
        ⁢
        
          max
          ⁡
          
            [
            
              0
              ,
              
                sign
                ⁡
                
                  (
                  
                    
                      w
                      T
                    
                    ⁢
                    
                      x
                      j
                      ′
                    
                  
                  )
                
              
            
            ]
          
        
      
    
    =
    
      r
      .

8. The method of claim 7, comprising of optimizing w for fixed y′j using the finite Newton method.

9. The method of claim 8, wherein a step w(k)=w(k)+n(k) in the finite Newton method for determining a weight vector w in a k-th iteration, with n being a Newton step, is given by solving the following linear system associated with a weighted linear regularized least squares problem over a data subset defined by a set of active indices j(w(k)):


[λI+Xj(w(k))TCj(w(k))Xj(w(k))] w(k)=Xj(w(k))TCj(w(k))Yj(w(k)) 

where I is the identity matrix, and wherein once w(k) is obtained, w(k+1) is obtained from w(k+1)=w(k)+δ(k)n(k) by setting w(k+1)=w(k)+δk( w(k)−w(k)) after performing an exact line search for δk, which is by exactly solving a one-dimensional minimization problem:





  
    δ
    
      (
      k
      )
    
  
  =
  
    
      
        arg
        ⁢
        
          
        
        ⁢
        min
      
      
        δ
        ≥
        0
      
    
    ⁢
    
      
        f
        ⁡
        
          (
          
            
              w
              
                (
                k
                )
              
            
            +
            
              δ
              ⁡
              
                (
                
                  
                    
                      w
                      _
                    
                    
                      (
                      k
                      )
                    
                  
                  -
                  
                    w
                    
                      (
                      k
                      )
                    
                  
                
                )
              
            
          
          )
        
      
      .

10. The method of claim 9, wherein the modified Newton method uses a conjugate gradient for least squares method to solve large, sparse, weighted regularized least squares problem.

11. The method of claim 7, comprising of optimizing y′j for a fixed w by switching one or more pairs of labels.

12. The method of claim 1, wherein a step w(k)=w(k)+n(k) in the finite Newton method for determining a weight vector w in a k-th iteration, with n being a Newton step, is given by solving the following linear system associated with a weighted linear regularized least squares problem over a data subset defined by a set of active indices j(w(k)):


[λI+Xj(w(k))TCj(w(k))Xj(w(k))] w(k)=Xj(w(k))TCj(w(k))Yj(w(k)) 

where I is the identity matrix, and wherein once w(k) is obtained, w(k+1) is obtained from w(k+1)=w(k)+δ(k)n(k) by setting w(k+1)=w(k)+δk( w(k)−w(k)) after performing an exact line search for δk, which is by exactly solving a one-dimensional minimization problem:





  
    δ
    
      (
      k
      )
    
  
  =
  
    
      
        arg
        ⁢
        
          
        
        ⁢
        min
      
      
        δ
        ⁢
        
          
        
        ≥
        0
      
    
    ⁢
    
      
        f
        (
        
          
            w
            
              (
              k
              )
            
          
          +
          
            δ
            ⁡
            
              (
              
                
                  
                    w
                    _
                  
                  
                    (
                    k
                    )
                  
                
                -
                
                  w
                  
                    (
                    k
                    )
                  
                
              
              )
            
          
        
        )
      
      .

13. The method of claim 12, wherein the modified Newton method uses a conjugate gradient for least squares method to solve large, sparse, weighted regularized least squares problem.

14. The method of claim 1, comprising relaxing discrete variables to continuous probability variables in mean field annealing method, wherein a non-negative temperature parameter T is used to track a global optimum.

15. The method of claim 14, comprising writing a semi-supervised support vector objective as follows:




  
    w
    *
  
  =
  
    
      
        
          arg
          ⁢
          
            
          
          ⁢
          min
        
        
          
            w
            ∈
            
              
            
            ⁢
            
              R
              d
            
          
          ,
          
            
              {
              
                
                  μ
                  j
                
                ∈
                
                  {
                  
                    0
                    ,
                    1
                  
                  }
                
              
              }
            
            
              j
              =
              1
            
            u
          
        
      
      ⁢
      
        λ
        2
      
      ⁢
      
        
          
          w
          
        
        2
      
    
    +
    
      
        1
        
          2
          ⁢
          l
        
      
      ⁢
      
        
          ∑
          
            i
            =
            1
          
          l
        
        ⁢
        
          
            max
            ⁡
            
              [
              
                0
                ,
                
                  1
                  -
                  
                    
                      y
                      i
                    
                    ⁡
                    
                      (
                      
                        
                          w
                          T
                        
                        ⁢
                        
                          x
                          i
                        
                      
                      )
                    
                  
                
              
              ]
            
          
          2
        
      
    
    +
    
      
        
          λ
          ′
        
        
          2
          ⁢
          u
        
      
      ⁢
      
        
          ∑
          
            j
            =
            1
          
          u
        
        ⁢
        
          (
          
            
              
                μ
                j
              
              ⁢
              
                
              
              ⁢
              
                
                  max
                  ⁢
                  
                    
                  
                  [
                  
                    0
                    ,
                    
                      1
                      -
                      
                        (
                        
                          
                            w
                            T
                          
                          ⁢
                          
                            x
                            j
                            ′
                          
                        
                        )
                      
                    
                  
                  ]
                
                2
              
            
            +
            
              
                (
                
                  1
                  -
                  
                    μ
                    j
                  
                
                )
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        +
                        
                          (
                          
                            
                              w
                              T
                            
                            ⁢
                            
                              x
                              j
                              ′
                            
                          
                          )
                        
                      
                    
                    ]
                  
                
                2
              
            
          
          )
        
      
    
  



wherein binary valued variables μj=(1+yj)/2 are introduced, pjε[0,1] denote the belief probability that the unlabeled example belongs to the positive class, l is the number of labeled example elements, u is the number of unlabeled example elements, wherein λ and λ′ are regularization parameters, and the Ising model of mean field annealing motivates the following objective function, where the binary variables μj are relaxed to probability variables pj, and include entropy terms for the distributions defined by pj:





  
    
      
        
          w
          T
          *
        
        =
        
          
            
              
                arg
                ⁢
                
                  
                
                ⁢
                min
              
              
                
                  w
                  ∈
                  
                    R
                    d
                  
                
                ,
                
                  
                    {
                    
                      
                        p
                        j
                      
                      ∈
                      
                        [
                        
                          0
                          ⁢
                          
                            
                          
                          ⁢
                          1
                        
                        ]
                      
                    
                    }
                  
                  
                    j
                    =
                    1
                  
                  u
                
              
            
            ⁢
            
              λ
              2
            
            ⁢
            
              
                
                w
                
              
              2
            
          
          +
          
            
              1
              
                2
                ⁢
                l
              
            
            ⁢
            
              
                ∑
                
                  i
                  =
                  1
                
                l
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        -
                        
                          
                            y
                            i
                          
                          ⁡
                          
                            (
                            
                              
                                w
                                T
                              
                              ,
                              
                                x
                                i
                              
                            
                            )
                          
                        
                      
                    
                    ]
                  
                
                2
              
            
          
          +
          
            
              
                λ
                ′
              
              
                2
                ⁢
                u
              
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                (
                
                  
                    
                      p
                      j
                    
                    ⁢
                    
                      
                        max
                        ⁡
                        
                          [
                          
                            0
                            ,
                            
                              1
                              -
                              
                                (
                                
                                  
                                    w
                                    T
                                  
                                  ⁢
                                  
                                    x
                                    j
                                    ′
                                  
                                
                                )
                              
                            
                          
                          ]
                        
                      
                      2
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        
                          p
                          j
                        
                      
                      )
                    
                    ⁢
                    
                      
                        max
                        ⁡
                        
                          [
                          
                            0
                            ,
                            
                              1
                              +
                              
                                (
                                
                                  
                                    w
                                    T
                                  
                                  ⁢
                                  
                                    x
                                    j
                                    ′
                                  
                                
                                )
                              
                            
                          
                          ]
                        
                      
                      2
                    
                  
                
                )
              
            
          
          +
          
            
              T
              
                2
                ⁢
                u
              
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                (
                
                  
                    
                      p
                      j
                    
                    ⁢
                    
                      
                    
                    ⁢
                    log
                    ⁢
                    
                      
                    
                    ⁢
                    
                      p
                      j
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        
                          p
                          j
                        
                      
                      )
                    
                    ⁢
                    
                      
                    
                    ⁢
                    log
                    ⁢
                    
                      
                    
                    ⁢
                    
                      (
                      
                        1
                        -
                        
                          p
                          j
                        
                      
                      )
                    
                  
                
                )
              
            
          
        
      
    
    
      
        (
        8
        )
      
    
  



wherein the temperature T parameterizes a family of objective functions, wherein the objective function for a fixed T is minimized under the following class balancing constraints:





  
    
      1
      u
    
    ⁢
    
      
        ∑
        
          j
          =
          1
        
        u
      
      ⁢
      
        p
        j
      
    
  
  =
  r



where r, the fraction of the number of unlabeled examples belonging to the positive class.

16. The method of claim 15, wherein the solution to the optimization problem is tracked as the temperature parameter T is lowered to 0, wherein the final solution is given as:




  
    w
    *
  
  =
  
    
      lim
      
        T
        →
        0
      
    
    ⁢
    
      
    
    ⁢
    
      
        w
        T
        *
      
      .

17. The method of claim 16, comprising optimizing W keeping p fixed, wherein the call to finite Newton method is made on data {circumflex over (X)}=[XTX′TX′T]T whose first l rows are formed by labeled examples, and the next 2u rows are formed by unlabeled examples appearing as two repeated blocks, wherein the associated label vector and cost matrix are given by:




  C
  =
  
    diag
    ⁢
    
      
        [
        
          
            
              
                1
                l
              
              ⁢
              ...
              ⁢
              
                
              
              ⁢
              
                1
                l
              
            
            
              {
              l
            
          
          ,
          
            
              
                
                  
                    
                      λ
                      ′
                    
                    ⁢
                    
                      p
                      1
                    
                  
                  u
                
                ⁢
                ...
                ⁢
                
                  
                
                ⁢
                
                  
                    
                      λ
                      ′
                    
                    ⁢
                    
                      p
                      u
                    
                  
                  u
                
              
              
                {
                u
              
            
            ⁢
            
              
                
                  
                    
                      λ
                      ′
                    
                    ⁡
                    
                      (
                      
                        1
                        -
                        
                          p
                          1
                        
                      
                      )
                    
                  
                  u
                
                ⁢
                ...
                ⁢
                
                  
                
                ⁢
                
                  
                    
                      λ
                      ′
                    
                    ⁡
                    
                      (
                      
                        1
                        -
                        
                          p
                          u
                        
                      
                      )
                    
                  
                  u
                
              
              
                {
                u
              
            
          
        
        ]
      
      
        
          Y
          ^
        
        =
        
          [
          
            
              y
              1
            
            ,
            
              
                y
                2
              
              ⁢
              ...
              ⁢
              
                
              
              ⁢
              
                y
                l
              
            
            ,
            
              
                
                  1
                  ,
                  1
                  ,
                  
                    ...
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                  ,
                
                
                  {
                  u
                
              
              ⁢
              
                
                  
                    -
                    1
                  
                  ,
                  
                    
                      
                        -
                        1
                      
                      ⁢
                      ...
                    
                    ⁢
                    
                      
                    
                    -
                    1
                  
                
                
                  {
                  u
                
              
            
          
          ]
        
      
    
  



where y1, y2 . . . yl are labels of the labeled example elements.

18. The method of claim 15, comprising optimizing p for a fixed w, a Lagrangian is constructed using Lagrangian multiplier v as follows:




  L
  =
  
    
      
        
          λ
          ′
        
        
          2
          ⁢
          u
        
      
      ⁢
      
        
          ∑
          
            j
            =
            1
          
          u
        
        ⁢
        
          (
          
            
              
                p
                j
              
              ⁢
              
                
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        -
                        
                          (
                          
                            
                              w
                              T
                            
                            ⁢
                            
                              x
                              j
                              ′
                            
                          
                          )
                        
                      
                    
                    ]
                  
                
                2
              
            
            +
            
              
                (
                
                  1
                  -
                  
                    p
                    j
                  
                
                )
              
              ⁢
              
                
                  max
                  ⁡
                  
                    [
                    
                      0
                      ,
                      
                        1
                        +
                        
                          (
                          
                            
                              w
                              T
                            
                            ⁢
                            
                              x
                              j
                              ′
                            
                          
                          )
                        
                      
                    
                    ]
                  
                
                2
              
            
          
          )
        
      
    
    +
    
      
        T
        
          2
          ⁢
          u
        
      
      ⁢
      
        
          ∑
          
            j
            =
            1
          
          u
        
        ⁢
        
          (
          
            
              
                p
                j
              
              ⁢
              
                
              
              ⁢
              log
              ⁢
              
                
              
              ⁢
              
                p
                j
              
            
            +
            
              
                (
                
                  1
                  -
                  
                    p
                    j
                  
                
                )
              
              ⁢
              
                
              
              ⁢
              log
              ⁢
              
                
              
              ⁢
              
                (
                
                  1
                  -
                  
                    p
                    j
                  
                
                )
              
            
          
          )
        
      
    
    -
    
      υ
      ⁡
      
        [
        
          
            
              1
              u
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                u
              
              ⁢
              
                p
                j
              
            
          
          -
          r
        
        ]
      
    
  



wherein, differentiating the Lagrangian with respect to pj, produces:





  
    
      ∂
      L
    
    
      ∂
      
        p
        j
      
    
  
  =
  
    
      
        
          
            λ
            ′
          
          
            2
            ⁢
            u
          
        
        ⁢
        
          (
          
            
              
                max
                ⁡
                
                  [
                  
                    0
                    ,
                    
                      1
                      -
                      
                        (
                        
                          
                            w
                            T
                          
                          ⁢
                          
                            x
                            j
                            ′
                          
                        
                        )
                      
                    
                  
                  ]
                
              
              2
            
            -
            
              
                max
                ⁡
                
                  [
                  
                    0
                    ,
                    
                      1
                      +
                      
                        (
                        
                          
                            w
                            T
                          
                          ⁢
                          
                            x
                            j
                            ′
                          
                        
                        )
                      
                    
                  
                  ]
                
              
              2
            
          
          )
        
      
      +
      
        

      
      ⁢
      
        
          T
          
            2
            ⁢
            u
          
        
        ⁢
        log
        ⁢
        
          
        
        ⁢
        
          
            p
            j
          
          
            1
            -
            
              p
              j
            
          
        
      
      -
      
        v
        u
      
    
    =
    0
  



defining


gj=λ′(max[0,1−(wTx′j)]2−max[0,1+(wTx′j)]2),


wherein the expression for pj is given by:





  
    p
    j
  
  =
  
    1
    
      1
      +
      
        e
        
          
            
              g
              j
            
            -
            
              2
              ⁢
              v
            
          
          T
        
      
    
  



wherein, substituting the expression for pj in the balance constraint, a one-dimensional non-linear equation in v is as follows:





  
    
      1
      u
    
    ⁢
    
      
        ∑
        
          j
          =
          1
        
        u
      
      ⁢
      
        
      
      ⁢
      
        1
        
          1
          +
          
            e
            
              
                
                  g
                  i
                
                -
                
                  2
                  ⁢
                  v
                
              
              T
            
          
        
      
    
  
  =
  r



wherein the value of v is computed exactly by using a hybrid combination of Newton-Raphson iterations and the bisection method to find the root of the function





  
    B
    ⁡
    
      (
      v
      )
    
  
  =
  
    
      
        1
        u
      
      ⁢
      
        
          ∑
          
            i
            =
            
              l
              +
              1
            
          
          
            l
            +
            u
          
        
        ⁢
        
          
        
        ⁢
        
          1
          
            1
            +
            
              e
              
                
                  
                    g
                    i
                  
                  -
                  v
                
                T
              
            
          
        
      
    
    -
    
      r
      .

19. A system for semi-supervised learning for web page classification, comprising:
an input device operative to receive a set of web pages as training elements;
a processor operative to label some of the elements of the set of training elements that are determined to fall within a classification group, the set of training elements thereby having labeled elements and unlabeled elements;
the processor further operative to use selected labeled elements and unlabeled elements as examples in a semi-supervised support vector machine implemented using a mean field annealing method, constructing a continuous loss function from a non-continuous loss function, to train a linear classifier;
the input device further operative to receive unclassified web pages; and
the processor further for operative to classify the received unclassified web pages using the trained linear classifier.

20. A computer program product stored on a computer-readable medium having instructions for performing a semi-supervised learning method for web page classification, the method comprising:
receiving a set of web pages as training elements;
labeling some of the elements of the set of training elements that are determined to fall within a classification group, the set of training elements thereby having labeled elements and unlabeled elements;
using selected labeled elements and unlabeled elements as examples in a semi-supervised support vector machine implemented using a mean field annealing method, constructing a continuous loss function from a non-continuous loss function, to train a linear classifier;
receiving unclassified web pages; and
classifying the unclassified web pages using the trained linear classifier.