# Patent

## Title
System and methods for finding hidden topics of documents and preference ranking documents

## Abstract

Systems and methods are disclosed to perform preference learning on a set of documents includes receiving raw input features from the set of documents stored on a data storage device; generating polynomial combinations from the raw input features; generating one or more parameters; applying the parameters to one or more classifiers to generate outputs; determining a loss function and parameter gradients and updating parameters determining one or more sparse regularizing terms and updating the parameters; and expressing that one document is preferred over another in a search query and retrieving one or more documents responsive to the search query.

## Background
This application claims priority to Provisional Application Ser. Nos. 61/360,599 filed Jul. 1, 2010 and 61/381,310 filed Sep. 9, 2010, the contents of which are incorporated by reference.


BACKGROUND
The present application relates to systems and methods for classifying documents. Learning preferences among a set of objects (e.g. documents) given another object as query is a central task of information retrieval and text mining. One of the most natural frameworks for this task is the pairwise preference learning, expressing that one document is preferred over another given the query. Most existing methods learn the preference or relevance function by assigning a real valued score to a feature vector describing a (query, object) pair. This feature vector normally includes a small number of hand-crafted features, such as the BM25 scores for the title or the whole text, instead of the very natural raw features. A drawback of using hand-crafted features is that they are often expensive and specific to datasets, requiring domain knowledge in preprocessing. In contrast, the raw features are easily available, and carry strong semantic information (such as word features in text mining).
Polynomial models (using combination of features as new features) on raw features are powerful and are easy to acquire in many preference learning problems. However, there are usually a very large number of features, make storing and learning difficult. For example, a basic model which uses the raw word features under the supervised pairwise preference learning framework and consider feature relationships in the model. In this model, D be the dictionary size, i.e. the size of the query and document feature set, given a query qεRD and a document dεRD, the relevance score between q and d is modeled as:




  
    
      
        
          
            f
            ⁡
            
              (
              
                q
                ,
                d
              
              )
            
          
          =
          
            
              
                q
                T
              
              ⁢
              Wd
            
            =
            
              
                ∑
                
                  i
                  ,
                  j
                
              
              ⁢
              
                
                  W
                  ij
                
                ⁢
                
                  Φ
                  ⁡
                  
                    (
                    
                      q
                      ,
                      
                        d
                        j
                      
                    
                    )
                  
                
              
            
          
        
        ,
      
    
    
      
        (
        1
        )
      
    
  




where Φ(qi,dj)=qi·dj and Wij models the relationship/correlation between ith query feature qi and jth document feature dj. This is essentially a linear model with pairwise features Φ(.,.) and the parameter matrix WεRD×D is learned from labeled data. Compared to most of the existing models, the capacity of this model is very large because of the D2 free parameters which can carefully model the relationship between each pair of words. From a semantic point of view, a notable superiority of this model is that it can capture synonymy and polysemy as it looks at all possible cross terms, and can be tuned directly for the task of interest.

Although it is very powerful, the basic model in Eq. (1) suffers from the following weakness which hinders its wide application:
1. Memory requirement: Given a dictionary size D, the model requires a large amount of memory to store the W matrix with a size quadratic in D. When D=10,000, storing W needs nearly 1 Gb of RAM (assuming double); when D=30,000, W storage requires 8 Gb of RAM.
2. Generalization ability: Given D2 free parameters (entries of W), when the number of training samples is limited, it can easily lead to overfitting. Considering the dictionary with the size D=10,000, then D2=108 free parameters that need to be estimated which is far too many for small corpora.
Recently researchers found out that raw features (e.g. words for text retrieval) and their pairwise features which describe relationships between two raw features (e.g. word synonymy or polysemy) could greatly improve the retrieval precision. However, most existing methods can not scale up to problems with many raw features (e.g. English vocabulary), due to the prohibitive computational cost on learning and the memory requirement to store a quadratic number of parameters.
Since such models are not practical, present systems often create a smaller feature space by dimension reduction technologies such as PCA. When raw features are used, polynomial models are avoided. When the polynomial models are used, various approaches can be used, including:

    
    
        1. Sparse model: remove the parameters that are less important. However, empirical studies on very large sparse models are lacking
        2. Low rank approximation: try to decompose the relationship matrix.
        3. Hashing: try to put the big number of parameters into a smaller number of bins.
    
    


In a related trend, unsupervised dimension reduction methods, like Latent Semantic Analysis (LSA) have been widely used in the field of text mining for hidden topic detection. The key idea of LSA is to learn a projection matrix that maps the high dimensional vector space representations of documents to a lower dimensional latent space, i.e. so called latent topic space. However LSA could not provide a clear and compact topic-word relationship due LSA projects each topic as a weighted combination of all words in the vocabulary.
Two existing models are closely related to LSA and have been used to find compact topic-word relationships from text data. Latent Dirichlet Allocation (LDA) provides a generative probabilistic model from Bayesian perspective to search for topics. LDA can provide the distribution of words given a topic and hence rank the words for a topic. However LDA could only handle a small number of hidden topics. Sparse coding, as another unsupervised learning algorithm, learn basis functions which capture higher-level features in the data and has been successfully applied in image processing and speech recognition. Sparse coding could provide a compact representation between the document to topics, but could not provide a compact represent between topic to words, since topics are learned basis functions associated to all words.
SUMMARY
In one aspect, a method to perform preference learning on a set of documents includes receiving raw input features from the set of documents stored on a data storage device; generating polynomial combinations from the raw input features; generating one or more parameters W; applying W to one or more classifiers to generate outputs; determining a loss function and parameter gradients and updating W; determining one or more sparse regularizing terms and updating W; and expressing that one document is preferred over another in a search query and retrieving one or more documents responsive to the search query.
In another aspect, a method to apply a query to a set of documents includes reconstructing a document term matrix XεRN×M by minimizing reconstruction errors with min ∥X−UA∥, wherein A is a fixed projection matrix and U is a column orthogonal matrix; determining a loss function and parameter gradients to generate U; fixing U while determining the loss function and sparse regularization constraints on the projection matrix A; generating parameter coefficients and generating a sparse projection matrix A; and generating a Sparse Latent Semantic Analysis (Sparse SLA) model and applying the model to a set of documents and displaying documents matching a query.
Advantages of the preferred embodiments may include one or more of the following. Sparsity is applied to the model which is achieved by an l1 regularization with an efficient online learning method. The method achieves good performance with fast convergence, while remaining sparse during training (small memory consumption), on a model with hundreds of millions of parameters. Extended models can learn group structure or even hierarchical structure of the words using group lasso type of regularization. The prior knowledge on the structure of W can also be imposed. In short, the system is highly efficient, fast and requires minimal computational resources.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 shows an exemplary process for generating preference learning models.
FIG. 2 shows an exemplary “sparse latent semantic analysis” learning method.
FIG. 3 shows an exemplary computer that can analyze documents.



DESCRIPTION
1) Learning Preferences Upon Millions of Features Over Sparsity
FIG. 1 shows an exemplary process for generating preference learning models. This method, also known as Learning Preferences upon Millions of Features Over Sparsity, can quickly generate preference models that require a small amount memory and achieve good accuracy. Turning now to FIG. 1, raw input features are received by the process (102). Next, polynomial combinations are generated (104). Parameters W, as detailed below, are derived (106), and applied to one or more classifiers (108) which generate outputs (110). The process then determines loss and parameter gradients (120). The process then updates W parameters used in 106. Next, the process determines sparse regularizing terms (130), and then updates W parameters used in 106.
The system of FIG. 1 constrains W to be a sparse matrix with many zero entries for the pairs of words which are irrelevant for the preference learning task. If W is a highly sparse matrix, then it consumes much less memory and has only a limited number of free parameters to be estimated. In other words, a sparse W matrix will allow the process to greatly scale up the dictionary size to model infrequent words which are often essential for the preference ordering. In addition, a faster and more scalable learning process is achieved since most entries of W are zeros so that those multiplications can be avoided. Another advantage of learning a sparse representation of W is its good interpretability. The zero Wij indicate that ith query feature and jth document feature are not correlated to the specific task. A sparse W matrix will accurately capture correlation information between pairs of words and the learned correlated word pairs could explain the semantic rationale behind the preference ordering.
In order to enforce the sparsity on W, the process imposes an entry-wise l1 regularization on W. Under certain conditions, l1 regularization can correctly uncover the underlying ground truth sparsity pattern. Since in many preference learning related applications (e.g. search engine), the model needs to be trained in a timely fashion and new (query, document) pairs may be added to the repository at any time, stochastic gradient descent in the online learning framework is used in one embodiment. To enforce the l1 regularization, a mini-batch shrinking step is performed for every T iterations in the stochastic gradient descent which can lead to the sparse solution. Moreover, to reduce the additional bias introduced by the l1 regularization, a refitting step is used to improve the preference prediction while keeping the learned sparsity pattern. Using sparsity, the model can be well controlled and efficiently learned. The result is a stochastic-gradient-descent-based sparse learning method that converges quickly with a small number of training samples. The method remains sparse and thus is memory consumption efficient in the whole training process. The method will make polynomial feature models (such as supervised semantic indexing) more effective in the following ways:

    
    
        1. Consumes less memory.
        2. Fast training process.
        3. Able to handle more features.
    
    


In one embodiment, the system receives a set of documents in the corpus as {dk}k=1K⊂RD and a query as qεRD, where D is the dictionary size, and the jth dimension of a document/query vector indicates the frequency of occurrence of the jth word, e.g. using the tf-idf weighting and then normalizing to unit length. Given a query q and a document d, the system learns a scoring function ƒ(q,d) that measures the relevance of d to q. In one embodiment, ƒ is a linear function which takes the form of Eq. (1). Each entry of W represents a “relationship” between a pair of words.
Given a set of tuples R (labeled data), where each tuple contains a query q, a preferred document d+ and an unpreferred (or lower ranked) document d−, the system learns a W such that qTWd+>qTWd−, making the right preference prediction.
For that purpose, given tuple (q,d+,d−), a margin rank loss technique can be used:

Lw(q,d+,d−)≡h(qTWd+−qTWd−)=max(0,1−qTWd++qTWd−),  (2)

where h(x)≡max(0,1−x) is the hinge loss function as adopted in SVM.

The system learns the W matrix which minimizes the loss in Eq. (2) by summing over all tuples (q,d+,d−) in R:




  
    
      
        
          W
          *
        
        =
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            W
          
          ⁢
          
            1
            
              
              R
              
            
          
          ⁢
          
            
              ∑
              
                
                  (
                  
                    q
                    ,
                    
                      d
                      +
                    
                    ,
                    
                      d
                      -
                    
                  
                  )
                
                ∈
                R
              
            
            ⁢
            
              
                
                  L
                  W
                
                ⁡
                
                  (
                  
                    q
                    ,
                    
                      d
                      +
                    
                    ,
                    
                      d
                      -
                    
                  
                  )
                
              
              .
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




In general, the size of R is large and new tuples may be added to R in a streaming manner, which makes it difficult to directly train the objective in Eq. (3). To address this issue, a stochastic (sub)gradient descent (SGD) is used in an online learning framework. At each iteration, the system randomly draws a sample (q, d+,d−) from R, compute the subgradient of Lw (q, d+, d−) with respect to W as following:




  
    
      
        
          ∇
          
            
          
          ⁢
          
            
              L
              W
            
            ⁡
            
              (
              
                q
                ,
                
                  d
                  +
                
                ,
                
                  d
                  -
                
              
              )
            
          
        
        =
        
          {
          
            
              
                
                  
                    -
                    
                      
                        q
                        ⁡
                        
                          (
                          
                            
                              d
                              +
                            
                            -
                            
                              d
                              -
                            
                          
                          )
                        
                      
                      T
                    
                  
                
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      
                        q
                        T
                      
                      ⁢
                      
                        W
                        ⁡
                        
                          (
                          
                            
                              d
                              +
                            
                            -
                            
                              d
                              -
                            
                          
                          )
                        
                      
                    
                    <
                    1
                  
                
              
              
                
                  0
                
                
                  otherwise
                
              
            
            ,
          
        
      
    
    
      
        (
        4
        )
      
    
  




and then update the W matrix accordingly.

W0 is initialized to the identity matrix as this initializes the model to the same solution as a cosine similarity score. The strategy introduces a prior expressing that the weight matrix should be close to the identity matrix. Term correlations are used when it is necessary to increase the score of a relevant document, or conversely, decrease the score of a irrelevant document. As for the learning rate ηt, a decaying learning rate is used with




  
    
      η
      t
    
    =
    
      C
      
        t
      
    
  
  ,




where C is a pre-defined constant as the initial learning rate. An exemplary pseudo code for the Stochastic Subgradient Descent (SGD) process is described below:













Initialization: W0 ε RD×D , learning rate sequence {ηt},


Iterate for t = 1,2,... until convergence of Wt :


  1. Randomly draw a tuple (q,d+,d−) ε R


  2. Compute the subgradient of LWt−1 (q,d+,d−) with respect to W :


  ∇LWt−1 (q,d+,d−)


  3. Update Wt = Wt−1 − ηt∇LWt−1 (q,d+,d−)









In one embodiment, an explicit form of the subgradient ∇Lw(q,d+,d−) takes the following form:




  
    
      
        
          ∇
          
            
          
          ⁢
          
            
              L
              W
            
            ⁡
            
              (
              
                q
                ,
                
                  d
                  +
                
                ,
                
                  d
                  -
                
              
              )
            
          
        
        =
        
          {
          
            
              
                
                  
                    -
                    
                      
                        q
                        ⁡
                        
                          (
                          
                            
                              d
                              +
                            
                            -
                            
                              d
                              -
                            
                          
                          )
                        
                      
                      T
                    
                  
                
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      
                        q
                        T
                      
                      ⁢
                      
                        W
                        ⁡
                        
                          (
                          
                            
                              d
                              +
                            
                            -
                            
                              d
                              -
                            
                          
                          )
                        
                      
                    
                    <
                    1
                  
                
              
              
                
                  0
                
                
                  otherwise
                
              
            
            .
          
        
      
    
    
      
        (
        5
        )
      
    
  




As discussed in the introduction, the model and the learning algorithm in the previous section will lead to a dense W matrix which consumes a large amount of memory and has poor generalization ability for small corpora. To address these problems, a sparse model with a small number of nonzero entries of W is learned. In order to obtain a sparse W, an entry-wise l1 norm is added to W as a regularization term to the loss function and optimized as the following objective function:




  
    
      
        
          
            W
            *
          
          =
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
                W
              
              ⁢
              
                1
                
                  
                  R
                  
                
              
              ⁢
              
                
                  ∑
                  
                    
                      (
                      
                        q
                        ,
                        
                          d
                          +
                        
                        ,
                        
                          d
                          -
                        
                      
                      )
                    
                    ∈
                    R
                  
                
                ⁢
                
                  
                    L
                    W
                  
                  ⁡
                  
                    (
                    
                      q
                      ,
                      
                        d
                        +
                      
                      ,
                      
                        d
                        -
                      
                    
                    )
                  
                
              
            
            +
            
              λ
              ⁢
              
                
                  
                  W
                  
                
                1
              
            
          
        
        ,
      
    
    
      
        (
        6
        )
      
    
  




where





  
    
      
      W
      
    
    1
  
  =
  
    
      ∑
      
        i
        ,
        
          j
          =
          1
        
      
      D
    
    ⁢
    
      
      
        W
        ij
      
      
    
  




is the entry-wise l1 norm of W and λ is the regularization parameter which controls the sparsity level (the number of nonzero entries) of W. In general, a larger λ leads to a more sparse W. On the other hand, too sparse a W will miss some useful relationship information among word pairs (considering diagonal W as an extreme case). Therefore, in practice, λ is tuned to obtain a W with a suitable sparsity level.

Next, the training of the Sparse Model is discussed. To optimize Eq. (6), a variant of the general sparse online learning scheme is applied. After updating Wt at each iteration in SGD, a shrinkage step is performed by solving the following optimization problem:




  
    
      
        
          
            
              W
              ^
            
            t
          
          =
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
                W
              
              ⁢
              
                1
                2
              
              ⁢
              
                
                  
                  
                    W
                    -
                    
                      W
                      t
                    
                  
                  
                
                F
                2
              
            
            +
            
              λ
              ⁢
              
                
              
              ⁢
              
                η
                t
              
              ⁢
              
                
                  
                  W
                  
                
                1
              
            
          
        
        ,
      
    
    
      
        (
        7
        )
      
    
  




and then use Ŵt as the starting point for the next iteration. In Eq. 7, ∥·∥F denote the matrix Frobenius norm and ηt is the decaying learning rate for the tth iteration. Performing (7) will shrink those Wijt with an absolute value less than ληt to zero and hence lead to a sparse W matrix.

Although performing the shrinkage step leads a sparse W solution, it becomes expensive for a large dictionary size D. For example, when D=10,000, D2=108 operations are needed. In one embodiment, shrinkage is performed for every T iteration cycles. In general, a smaller T guarantees that the shrinkage step can be done in a timely fashion so that the entries of W will not grow too large to produce inaccurate ∇Lw(q,d+, d−); on the other hand, a smaller T increases the computational cost of the training process. In one embodiment, T=100. When t is a multiple of T, the shrinkage step with a cumulative regularization parameter is used for solving the following optimization problem:





  
    W
    T
  
  =
  
    
      
        
          arg
          ⁢
          
            
          
          ⁢
          min
        
        W
      
      ⁢
      
        1
        2
      
      ⁢
      
        
          
          
            W
            -
            
              W
              0
            
          
          
        
        F
        2
      
    
    +
    
      λ
      ⁢
      
        
          ∑
          
            t
            =
            1
          
          T
        
        ⁢
        
          
            η
            t
          
          ⁢
          
            
              
                
                W
                
              
              1
            
            .
          
        
      
    
  




By taking the shrinkage step at every iteration, the learned sparse W is a good approximation. Pseudo-code for the Sparse SGD process is:











Sparse SGD















Initialization: W0 ∈ RD×D, T, learning rate sequence {ηt}.


Iterate for t = 1,2, . . . until convergence of Wt:








1.  
Randomly draw a tuple (q, d+, d−) ε R


2. 
Compute the subgradient of LWt−1(q, d+, d−) with respect to



W: ∇LWt−1(q, d+, d−)


3.
Update Wt = Wt−1 − ηt ∇ LWt−1(q, d+, d−)


4.
If (t mod T = 0)


 











  
    W
    T
  
  =
  
    
      
        argmin
        W
      
      ⁢
      
        1
        2
      
      ⁢
      
        
          
          
            W
            -
            
              W
              0
            
          
          
        
        F
        2
      
    
    +
    
      λ
      ⁢
      
        
          ∑
          
            t
            =
            1
          
          T
        
        ⁢
        
          
            η
            t
          
          ⁢
          
            
              
                
                W
                
              
              1
            
            .
          
        
      
    
  













Next, refitting the Sparse Model is discussed. From Eq. (8), l1 regularization will not only shrink the weights for uncorrelated word pairs to zero but also reduces the absolute value of the weights for correlated word pairs. This additional bias introduced by l1 regularization often harm the prediction performance. In order to reduce this bias, the system refits the model without l1 regularization, but enforcing the sparsity pattern of W by minimizing the following objective function:




  
    
      
        
          
            W
            *
          
          =
          
            
              
                arg
                ⁢
                
                  
                
                ⁢
                min
              
              W
            
            ⁢
            
              1
              
                
                R
                
              
            
            ⁢
            
              
                ∑
                
                  
                    (
                    
                      q
                      ,
                      
                        d
                        +
                      
                      ,
                      
                        d
                        -
                      
                    
                    )
                  
                  ∈
                  R
                
              
              ⁢
              
                
                  L
                  
                    
                      P
                      Ω
                    
                    ⁡
                    
                      (
                      W
                      )
                    
                  
                
                ⁡
                
                  (
                  
                    q
                    ,
                    
                      d
                      +
                    
                    ,
                    
                      d
                      -
                    
                  
                  )
                
              
            
          
        
        ,
      
    
    
      
        (
        9
        )
      
    
  




SGD is used to minimize Eq. (9), but ∇LW(q,d+,d−) is replaced with ∇LPΩ(W)(q,d+,d−). Using the chain rule for sub gradient, ΔLPΩ(W)(q,d+,d−) takes the following form:





  
    ∇
    
      
    
    ⁢
    
      
        L
        
          
            P
            Ω
          
          ⁡
          
            (
            W
            )
          
        
      
      ⁡
      
        (
        
          q
          ,
          
            d
            +
          
          ,
          
            d
            -
          
        
        )
      
    
  
  =
  
    {
    
      
        
          
            
              -
              
                
                  P
                  Ω
                
                ⁡
                
                  (
                  
                    
                      q
                      ⁡
                      
                        (
                        
                          
                            d
                            +
                          
                          -
                          
                            d
                            -
                          
                        
                        )
                      
                    
                    T
                  
                  )
                
              
            
          
          
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  q
                  T
                
                ⁢
                
                  
                    P
                    Ω
                  
                  ⁡
                  
                    (
                    W
                    )
                  
                
                ⁢
                
                  (
                  
                    
                      d
                      +
                    
                    -
                    
                      d
                      -
                    
                  
                  )
                
              
              <
              1
            
          
        
        
          
            0
          
          
            otherwise
          
        
      
      .
    
  




In Eq. (6), the system enforces the sparsity and regularizes each Wij with the same regularization parameter λ which does not incorporate the prior knowledge about the importance of the word pair (i, j) for the specific preference ordering. For example, the most frequent pairs of words, e.g. (a, the), (in, on), do not convey much information; so the regularization parameter for those pairs should be large to let Wij have more tendency to become zero. On the other hand, some less frequent pairs of words, e.g. (Israel, Jerusalem) are very essential for the preference ordering and the corresponding regularization parameters should be small. Therefore, instead of using the same λ to regularize all |Wij|, the system assign different regularization parameters for each |Wij| and propose to learn the sparse W via the following objective function:




  
    
      
        
          
            
              1
              
                
                R
                
              
            
            ⁢
            
              
                ∑
                
                  
                    (
                    
                      q
                      ,
                      
                        d
                        +
                      
                      ,
                      
                        d
                        -
                      
                    
                    )
                  
                  ∈
                  R
                
              
              ⁢
              
                
                  L
                  W
                
                ⁡
                
                  (
                  
                    q
                    ,
                    
                      d
                      +
                    
                    ,
                    
                      d
                      -
                    
                  
                  )
                
              
            
          
          +
          
            λ
            ⁢
            
              
                ∑
                
                  i
                  ,
                  
                    j
                    =
                    1
                  
                
                D
              
              ⁢
              
                
                  γ
                  ij
                
                ⁢
                
                  
                    
                    W
                    
                  
                  ij
                
              
            
          
        
        ,
      
    
    
      
        (
        10
        )
      
    
  




where the hyperparameter γij measures the importance of word pair (i, j) for the preference learning task and it should be large for those less important word pair. Based on the above discussion, in this paper, is set to be proportional to ƒi·ƒj, where ƒi, ƒj are the document frequencies for ith and jth words. We normalize γij such that maxi,jγij=1. Eq. (10) can be minimized as:





  
    W
    t
  
  =
  
    
      
        
          arg
          ⁢
          
            
          
          ⁢
          min
        
        W
      
      ⁢
      
        1
        2
      
      ⁢
      PW
    
    -
    
      
        W
        t
      
      ⁢
      
        P
        F
        2
      
    
    +
    
      λ
      ⁢
      
        
          ∑
          
            k
            =
            
              t
              -
              T
              +
              1
            
          
          t
        
        ⁢
        
          
            η
            t
          
          ⁢
          λ
          ⁢
          
            
              ∑
              
                i
                ,
                
                  j
                  =
                  1
                
              
              D
            
            ⁢
            
              
                γ
                ij
              
              ⁢
              
                
                  
                    
                    W
                    
                  
                  ij
                
                .
              
            
          
        
      
    
  




The prediction performance gets improved after the refitting step. In contrast to the traditional preference learning or “learning to rank” with a few hundred hand-crafted features, the basic model directly performs learning on actual words and considers their pairwise relationships between query and document. Although the pairwise relationship of words could improve and provide additional semantic information, the basic model suffers from storage overloads and parameter overfitting. To overcome these drawbacks, sparsity is applied to the model which is achieved by the l1 regularization with an efficient online learning algorithm. The method achieves good performance with fast convergence, while remaining sparse during training (small memory consumption), on a model with hundreds of millions of parameters. The inventors contemplate that extended models can learn group structure or even hierarchical structure of the words using group lasso type of regularization. The prior knowledge on the structure of W can also be imposed.
2) Sparse Latent Semantic Analysis
As discussed above, LSA is one of the most successful tools for learning the concepts or latent topics from text, has widely been used for the dimension reduction purpose in information retrieval. Given a document-term matrix XεRN×M, where N is the number of documents and M is the number of words, and the number of latent topics (the dimensionality of the latent space) is set as D (D≦min{N,M}), LSA applies singular value decomposition (SVD) to construct a low rank (with rank-D) approximation of X:X≈USVT, where the column orthogonal matrices UεRN×D (UT U=I) and VεRM×D (VTV=I) represent document and word embeddings into the latent space. S is a diagonal matrix with the D largest singular values of X on the diagonal. Subsequently, the so-called projection matrix defined as A=S−1VT provides a transformation mapping of documents from the word space to the latent topic space, which is less noisy and considers word synonymy (i.e. different words describing the same idea). However, in LSA, each latent topic is represented by all word features which sometimes makes it difficult to precisely characterize the topic-word relationships.
FIG. 2 shows an exemplary learning method named “sparse latent semantic analysis” (SLSA) that adds sparsity constraints on the projection matrix inside LSA. The Sparse LSA approach improves LSA as an optimization problem which minimizes the approximation error under the orthogonality constraint of U. Based on this formulation, the sparsity constraint of the projection matrix A is added via the l1 regularization as in the lasso model. By enforcing the sparsity on A, the model has the ability to automatically select the most relevant words for each latent topic. SLSA provides a more compact representation of the topic-word relationship, and is memory consumption efficient in the whole training process.
Referring now to FIG. 2, raw documents are received as input (202). The process reconstructs X by min |X−UA| to get U and A (204). Reconstruction errors are determined (206). Next, the process, with a fixed projection matrix A, determines loss and parameter gradients to obtain U (208). Next, the process fixes U and determines loss and sparse regularization constraints on the projection matrix A. The process also generates the parameter coefficients to get the updated projection matrix A (210) and sends the updated matrix A to operation 204.
A notable advantage of sparse LSA is its good interpretability in topic-word relationship. Sparse LSA automatically selects the most relevant words for each latent topic and hence provides us a clear and compact representation of the topic-word relationship. Moreover, for a new document q, if the words in q has no intersection with the relevant words of d-th topic (nonzero entries in Ad, the d-th row of A), the d-th element of {circumflex over (q)}, Ad q, will become zero. In other words, the sparse latent representation of {circumflex over (q)} clearly indicates the topics that q belongs to.
Another benefit of learning sparse A is to save computational cost and storage requirements when D is large. In traditional LSA, the topics with larger singular values will cover a broader range of concepts than the ones with smaller singular values. For example, the first few topics with largest singular values are often too general to have specific meanings. As singular values decrease, the topics become more and more specific. Therefore, we might want to enlarge the number of latent topics D to have a reasonable coverage of the topics. However, given a large corpus with millions of documents, a larger D will greatly increase the computational cost of projection operations in traditional LSA. In contrary, for Sparse LSA, projecting documents via a highly sparse projection matrix will be computationally much more efficient; and it will take much less memory for storing A when D is large.
In order to obtain a sparse A, inspired by the lasso model, an entry-wise l1-norm of A is added as the regularization term to the loss function and formulate the Sparse LSA model as:

minU,A1⁄2∥X−UA∥F2+λ∥A∥1  (14)

subject-to:UTU=I, 

where





  
    
      
      A
      
    
    1
  
  =
  
    
      ∑
      
        d
        =
        1
      
      D
    
    ⁢
    
      
        ∑
        
          j
          =
          1
        
        M
      
      ⁢
      
        
        
          a
          dj
        
        
      
    
  




is the entry-wise l1-norm of A and λ is the positive regularization parameter which controls the density (the number of nonzero entries) of A. In general, a larger λ leads to a sparser A. On the other hand, a too sparse A will miss some useful topic-word relationships which harms the reconstruction performance. Therefore, in practice, larger λ should be used to obtain a more sparse A while still achieving good reconstruction performance.

Although the optimization problem is non-convex, fixing one variable (either U or A), the objective function with respect to the other is convex. Therefore, one approach to solve Eq. (14) is by:

    
    
        1. When U is fixed, let A, denote the j-th column of A; the optimization problem with respect to A:
    
    






  
    
      
        min
        A
      
      ⁢
      
        
          1
          2
        
        ⁢
        
          
          
            X
            -
            UA
          
          
        
      
    
    +
    
      λ
      ⁢
      
        
          
          A
          
        
        1
      
    
  
  ,




can be decomposed in to M independent ones:





  
    
      
        
          
            
              
                min
                
                  A
                  j
                
              
              ⁢
              
                
                  1
                  2
                
                ⁢
                
                  
                    
                    
                      
                        X
                        j
                      
                      -
                      
                        UA
                        j
                      
                    
                    
                  
                  2
                  2
                
              
            
            +
            
              λ
              ⁢
              
                
                  
                  
                    A
                    j
                  
                  
                
                i
              
            
          
          ;
          
            j
            =
            1
          
        
        ,
        ...
        ⁢
        
          
        
        ,
        
          M
          .
        
      
    
    
      
        (
        15
        )
      
    
  




Each subproblem is a standard lasso problem where Xj can be viewed as the response and U as the design matrix. To solve Eq. (15), a lasso solver can be applied, which is essentially a coordinate descent approach.

    
    
        2. When A is fixed, the optimization problem is equivalent to:

minU1⁄2∥X−UA∥F2  (16)

subjectto:UTU=I. 

    
    


The objective function in Eq. (16) can be further written as:




  
    
      
        
          
            1
            2
          
          ⁢
          
            
              
              
                X
                -
                UA
              
              
            
            F
            2
          
        
        =
        
          
            1
            2
          
          ⁢
          
            tr
            ⁡
            
              (
              
                
                  
                    (
                    
                      X
                      -
                      UA
                    
                    )
                  
                  T
                
                ⁢
                
                  (
                  
                    X
                    -
                    UA
                  
                  )
                
              
              )
            
          
        
      
    
  
  
    
      
        =
        
          
            -
            
              tr
              ⁡
              
                (
                
                  
                    A
                    T
                  
                  ⁢
                  
                    U
                    T
                  
                  ⁢
                  X
                
                )
              
            
          
          +
          
            
              1
              2
            
            ⁢
            
              tr
              ⁡
              
                (
                
                  
                    X
                    T
                  
                  ⁢
                  X
                
                )
              
            
          
          +
          
            
              1
              2
            
            ⁢
            
              tr
              ⁡
              
                (
                
                  
                    A
                    T
                  
                  ⁢
                  
                    U
                    T
                  
                  ⁢
                  UA
                
                )
              
            
          
        
      
    
  
  
    
      
        
          =
          
            
              -
              
                tr
                ⁡
                
                  (
                  
                    
                      A
                      T
                    
                    ⁢
                    
                      U
                      T
                    
                    ⁢
                    X
                  
                  )
                
              
            
            +
            
              
                1
                2
              
              ⁢
              
                tr
                ⁡
                
                  (
                  
                    
                      X
                      T
                    
                    ⁢
                    X
                  
                  )
                
              
            
            +
            
              
                1
                2
              
              ⁢
              
                tr
                ⁡
                
                  (
                  
                    
                      A
                      T
                    
                    ⁢
                    A
                  
                  )
                
              
            
          
        
        ,
      
    
  




where the last equality is according to the constraint that UTU=I. By the fact that tr(ATUTX)≡tr(UTXAT), the optimization problem in Eq. (16) is equivalent to

maxUtr(UTXAT)  (17)

Subject to UTU=I. 

Let V=XAT. In fact, V is the latent topic representations of the documents X. Assuming that V is full column rank, i.e. with rank(V)=D, Eq. (17) has the closed form solution when the singular value decomposition (SVD) of V is V=PΔQ, the optimal solution to Eq. (17) is U=PQ.

As for the starting point, any A0 or U0 stratifying) (U0)TU0=I can be adopted. One embodiment uses a simple initialization strategy for U0 as following:




  
    
      
        
          
            U
            0
          
          =
          
            (
            
              
                
                  
                    I
                    D
                  
                
              
              
                
                  0
                
              
            
            )
          
        
        ,
      
    
    
      
        (
        18
        )
      
    
  




where ID the D by D identity matrix. It is easy to verify that) (U0)TU0=I.

The optimization procedure can be summarized as pseudo code below:










Optimization Algorithm for Sparse LSA















Input: X, the dimensionality of the latent space D, regularization parameter λ


 






  
    
      Initialization
      ⁢
      
        :
      
      ⁢
      
        
      
      ⁢
      
        U
        0
      
    
    =
    
      (
      
        
          
            
              I
              D
            
          
        
        
          
            0
          
        
      
      )
    
  
  ,






 


Iterate until convergence of U and A:








1. 
Compute A by solving M lasso problems as in Eq. (15)


2.
Project X onto the latent space: V = XAT.


3.
Compute the SVD of V: V = PΔQ and let U = PQ .







Output: Sparse projection matrix A.









As for the stopping criteria, let ∥·∥∞ denote the matrix entry-wise l∞-norm, for the two consecutive iterations t and t+1, the process computes the maximum change for all entries in U and A:∥U(t+1)−U(t)∥∞ and ∥A(t+1)−A(t)∥∞; and stop the optimization procedure when both quantities are less than the prefixed constant τ. In one implementation, τ=0.01.
Next, two extensions of the Sparse LSA is discussed:

    
    
        1. Group Structured Sparse LSA with group structured sparsity-inducing penalty added to select the most relevant groups of features relevant to the latent topic.
        2. Non-negative Sparse LSA which enforces non-negativity constraint on the projection matrix A to provide a pseudo probability distribution of each word given the topic, similar as in Latent Dirichlet Allocation (LDA).
    
    


Group Structured Sparse LSA
Although entry-wise l1-norm regularization leads to the sparse projection matrix A, it does not take advantage of any prior knowledge on the structure of the input features (e.g. words). When the features are naturally clustered into groups, it is more meaningful to enforce the sparsity pattern at a group level instead of each individual feature; so that we can learn which groups of features are relevant to a latent topic. It has many potential applications in analyzing biological data. For example, in the latent gene function identification, it is more meaningful to determine which pathways (groups of genes with similar function or near locations) are relevant to a latent gene function (topic).
Similar to the group lasso approach, the process can encode the group structure via a l1/l2 mixed norm regularization of A in Sparse LSA. Formally, we assume that the set of groups of input features G={g1, . . . , g|G|} is defined as a subset of the power set of {1, . . . , M}, and is available as prior knowledge. For the purpose of simplicity, groups are non-overlapped. The group structured Sparse LSA can be formulated as:




  
    
      
        
          
            min
            
              U
              ,
              A
            
          
          ⁢
          
            
              1
              2
            
            ⁢
            
              
                
                
                  X
                  -
                  UA
                
                
              
              F
              2
            
          
        
        +
        
          λ
          ⁢
          
            
              ∑
              
                d
                =
                1
              
              D
            
            ⁢
            
              
                ∑
                
                  g
                  ∈
                  G
                
                
                  
                
              
              ⁢
              
                
                  w
                  g
                
                ⁢
                
                  
                    
                    
                      A
                      dg
                    
                    
                  
                  2
                
              
            
          
        
      
    
    
      
        (
        19
        )
      
    
  




Subject to UTU=I, 

where AdgεR|g| is the subvector of A for the latent dimension d and the input features in group g; wg is the predefined regularization weight each group g, λ is the global regularization parameter; and P·P2 is the vector l2-norm which enforces all the features in group g for the d-th latent topic, Adg, to achieve zeros simultaneously. A simple strategy for setting wg is wg=√{square root over (|g|)} as in [?] so that the amount of penalization is adjusted by the size of each group.
To solve Eq. (19), when U is fixed, the optimization problem becomes:




  
    
      
        
          
            min
            A
          
          ⁢
          
            f
            ⁡
            
              (
              A
              )
            
          
        
        ≡
        
          
            
              1
              2
            
            ⁢
            
              
                
                
                  X
                  -
                  UA
                
                
              
              F
              2
            
          
          +
          
            λ
            ⁢
            
              
                ∑
                
                  d
                  =
                  1
                
                D
              
              ⁢
              
                
                  ∑
                  
                    g
                    ∈
                    G
                  
                  
                    
                  
                
                ⁢
                
                  
                    w
                    g
                  
                  ⁢
                  
                    
                      
                        
                        
                          A
                          dg
                        
                        
                      
                      2
                    
                    .
                  
                
              
            
          
        
      
    
    
      
        (
        20
        )
      
    
  




To solve Eq. (20), an efficient block coordinate descent technique is used: at each iteration, the objective function is minimized with respect to Adg while the other entries in A are held fixed.

More precisely, assume that now fix a particular latent dimension d and a group g; the process optimizes ƒ(A) with respect to Adg. Denote the i-th row of U as Ui and the first part of ƒ(A) as g(A)≡1⁄2∥X−UA∥F2, the gradient of g(A) over Adg is a |g| dimensional vector where the j ε g-th element takes the following form:




  
    
      (
      
        
          ∂
          
            g
            ⁡
            
              (
              A
              )
            
          
        
        
          ∂
          
            A
            dg
          
        
      
      )
    
    
      j
      ∈
      g
    
  
  =
  
    
      ∑
      
        i
        =
        1
      
      N
    
    ⁢
    
      
        
          u
          id
        
        ⁡
        
          (
          
            
              
                
                  (
                  
                    U
                    i
                  
                  )
                
                T
              
              ⁢
              
                A
                j
              
            
            -
            
              x
              ij
            
          
          )
        
      
      .
    
  




To convert





  
    ∂
    
      g
      ⁡
      
        (
        A
        )
      
    
  
  
    ∂
    
      A
      dg
    
  




in the vector form,





  
    C
    d
  
  ⁢
  
    
      ∑
      
        i
        =
        1
      
      N
    
    ⁢
    
      u
      id
      2
    
  




and Bdg be the vector of length |g| such that:





  
    
      
        
          
            (
            
              B
              dg
            
            )
          
          
            j
            ∈
            g
          
        
        =
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
              
                u
                id
              
              (
              
                
                  x
                  ij
                
                -
                
                  
                    ∑
                    
                      k
                      ≠
                      d
                    
                  
                  ⁢
                  
                    
                      u
                      ik
                    
                    ⁢
                    
                      a
                      kj
                    
                  
                
              
              )
            
            .
          
        
      
    
    
      
        (
        11
        )
      
    
  




The vector form of





  
    ∂
    
      g
      ⁡
      
        (
        A
        )
      
    
  
  
    ∂
    
      A
      dg
    
  




can be written as:





  
    
      ∂
      
        g
        ⁡
        
          (
          A
          )
        
      
    
    
      ∂
      
        A
        dg
      
    
  
  =
  
    
      
        C
        d
      
      ⁢
      
        A
        dg
      
    
    -
    
      
        B
        dg
      
      .
    
  




The minimization of ƒ(A) with respect to Adg has a closed-form solution. Take the subgradient of ƒ(A) over Adg:




  
    
      
        
          
            
              ∂
              
                f
                ⁡
                
                  (
                  A
                  )
                
              
            
            
              ∂
              
                A
                dg
              
            
          
          =
          
            
              
                
                  ∂
                  
                    g
                    ⁡
                    
                      (
                      A
                      )
                    
                  
                
                
                  ∂
                  
                    A
                    dg
                  
                
              
              +
              
                
                  ∂
                  
                    
                      
                      
                        A
                        dg
                      
                      
                    
                    2
                  
                
                
                  ∂
                  
                    A
                    dg
                  
                
              
            
            =
            
              
                
                  C
                  d
                
                ⁢
                
                  A
                  dg
                
              
              -
              
                B
                dg
              
              +
              
                λ
                ⁢
                
                  
                
                ⁢
                
                  w
                  g
                
                ⁢
                
                  
                    ∂
                    
                      
                        
                        
                          A
                          dg
                        
                        
                      
                      2
                    
                  
                  
                    ∂
                    
                      A
                      dg
                    
                  
                
              
            
          
        
        ,
      
    
    
      
        (
        12
        )
      
    
  




where





  
    
      
        
          
            
              ∂
              
                PA
                dg
              
            
            ⁢
            
              P
              2
            
          
          
            ∂
            
              A
              dg
            
          
        
        =
        
          {
          
            
              
                
                  
                    A
                    dg
                  
                  
                    
                      
                      
                        A
                        dg
                      
                      
                    
                    2
                  
                
              
              
                
                  
                    A
                    dg
                  
                  ≠
                  0
                
              
            
            
              
                
                  {
                  
                    
                      α
                      ∈
                      
                        R
                        
                          
                          g
                          
                        
                      
                    
                    |
                    
                      
                        
                          
                          α
                          
                        
                        2
                      
                      ≤
                      1
                    
                  
                  }
                
              
              
                
                  
                    A
                    dg
                  
                  ≠
                  0
                
              
            
          
        
      
    
    
      
        (
        13
        )
      
    
  




The closed-form solution of Adg* can be given in the following proposition.
The optimal Adg* for the minimization of ƒ(A) with respect to Adg takes the following form:




  
    
      
        
          A
          dg
          *
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        B
                        dg
                      
                      ⁡
                      
                        (
                        
                          
                            
                              
                              
                                B
                                dg
                              
                              
                            
                            2
                          
                          -
                          
                            λ
                            ⁢
                            
                              
                            
                            ⁢
                            
                              w
                              g
                            
                          
                        
                        )
                      
                    
                    
                      
                        C
                        d
                      
                      ⁢
                      
                        
                          
                          
                            B
                            dg
                          
                          
                        
                        2
                      
                    
                  
                
                
                  
                    
                      
                        
                        
                          B
                          dg
                        
                        
                      
                      2
                    
                    >
                    
                      λ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        w
                        g
                      
                    
                  
                
              
              
                
                  0
                
                
                  
                    
                      
                        
                        
                          B
                          dg
                        
                        
                      
                      2
                    
                    ≤
                    
                      λ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        w
                        g
                      
                    
                  
                
              
            
            .
          
        
      
    
    
      
        (
        14
        )
      
    
  




The block coordinate descent for optimizing A is summarized in the following pseudo-code










Algorithm 2 Optimization for A with group structure


















 
Input: X, U, the dimensionality of the latent space D,




the global regularization parameter λ, group structure




 , regularization weights of groups  .




 while A has not converged do




  for d = 1, 2, . . . , D do




   Compute Cd = Σi=1N uid2




   for all g ∈   do




    Compute Bdg according to Eq. (3.11)




    if ∥Bdg2∥ > λωg then



 




     



  
    A
    
      d
      ⁢
      
        
      
      ⁢
      g
    
  
  ←
  
    
      
        B
        
          d
          ⁢
          
            
          
          ⁢
          g
        
      
      ⁡
      
        (
        
          
            
              
              
                B
                
                  d
                  ⁢
                  
                    
                  
                  ⁢
                  g
                
              
              
            
            2
          
          -
          
            λ
            
              ω
              g
            
          
        
        )
      
    
    
      
        C
        d
      
      ⁢
      
        
          
          
            B
            
              d
              ⁢
              
                
              
              ⁢
              g
            
          
          
        
        2
      
    
  







 




    else




     Adg ← 0




    end if




   end for




  end for




 end while




Output: Sparse projection matrix A.










Non-Negative Sparse LSA
It is natural to assume that each word has a non-negative contribution to a specific topic, i.e. the projection matrix A should be non-negative. In such a case, the system can normalize each row of A to 1:




  
    
      a
      ^
    
    dj
  
  =
  
    
      
        a
        dj
      
      
        
          ∑
          
            j
            =
            1
          
          M
        
        ⁢
        
          a
          dj
        
      
    
    .
  




Since adj measures the relevance of the j-th word, wj, to the d-th topic td, from the probability perspective, âdj, can be viewed as a pseudo probability of the word wi given the topic td, P(wj|td). Similar to topic modeling in the Bayesian framework such as LDA, the non-negative Sparse LSA can also provide the most relevant/likely words to a specific topic.

More formally, the non-negative Sparse LSA can be formulated as the following optimization problem:

minU,A1⁄2∥X−UA∥F2+λ∥A∥1  (15)

Subject to UTU=I,A≧0.

According to the non-negativity constraint of A, |adj|=adj and Eq. (15) is equivalent to:




  
    
      
        
          
            min
            
              U
              ,
              A
            
          
          ⁢
          
            
              1
              2
            
            ⁢
            
              
                
                
                  X
                  -
                  UA
                
                
              
              F
              2
            
          
        
        +
        
          λ
          ⁢
          
            
              ∑
              
                d
                =
                1
              
              D
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                J
              
              ⁢
              
                a
                dj
              
            
          
        
      
    
    
      
        (
        16
        )
      
    
  




Subject to UTU=I,A≧0.

When A is fixed, the optimization with respect to U is the same as that in Eq. (16). When U is fixed, the optimization over A can be decomposed in to M independent subproblems, each one corresponds to a column of A:




  
    
      
        
          
            min
            
              
                A
                j
              
              ≥
              0
            
          
          ⁢
          
            f
            ⁡
            
              (
              
                A
                j
              
              )
            
          
        
        =
        
          
            
              1
              2
            
            ⁢
            
              
              
                
                  X
                  j
                
                -
                
                  UA
                  j
                
              
              
            
          
          +
          
            λ
            ⁢
            
              
                ∑
                
                  d
                  =
                  1
                
                D
              
              ⁢
              
                
                  a
                  dj
                
                .
              
            
          
        
      
    
    
      
        (
        17
        )
      
    
  




The coordinate descent method is used to minimize ƒ(Aj): fix a dimension of the latent space d; optimize ƒ(Aj) with respect to adj while keeping other entries in ƒ(Aj) fixed and iterate over d. More precisely, for a fixed d, the gradient of ƒ(Aj) with respect to adj:




  
    
      
        
          
            
              ∂
              
                f
                ⁡
                
                  (
                  
                    A
                    j
                  
                  )
                
              
            
            
              ∂
              
                a
                dj
              
            
          
          =
          
            
              
                c
                d
              
              ⁢
              
                a
                dj
              
            
            -
            
              b
              d
            
            +
            λ
          
        
        ,
      
    
    
      
        (
        18
        )
      
    
  




where





  
    
      c
      d
    
    ⁢
    
      
        ∑
        
          i
          =
          1
        
        N
      
      ⁢
      
        u
        id
        2
      
    
  
  ,








  
    b
    d
  
  =
  
    
      ∑
      
        i
        =
        1
      
      N
    
    ⁢
    
      
        
          u
          id
        
        (
        
          
            x
            ij
          
          -
          
            
              ∑
              
                k
                ≠
                d
              
            
            ⁢
            
              
                u
                ik
              
              ⁢
              
                a
                kj
              
            
          
        
        )
      
      .
    
  




When bd>λ, setting





  
    a
    dj
  
  =
  
    
      
        b
        d
      
      -
      λ
    
    
      c
      d
    
  




will make





  
    
      ∂
      
        f
        ⁡
        
          (
          
            A
            j
          
          )
        
      
    
    
      ∂
      
        a
        dj
      
    
  
  =
  0.




If bd≦λ,





  
    
      ∂
      
        f
        ⁡
        
          (
          
            A
            j
          
          )
        
      
    
    
      ∂
      
        a
        dj
      
    
  
  ≥
  0




for all adj≦0, f(Aj) is a monotonic increasing function with adj and the minimal is achieved when adj=0.

In sum, the optimal adj* for the minimization ƒ(Aj) with respect to adj takes the following form:




  
    
      
        
          a
          dj
          *
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        b
                        d
                      
                      -
                      λ
                    
                    
                      c
                      d
                    
                  
                
                
                  
                    
                      b
                      d
                    
                    >
                    λ
                  
                
              
              
                
                  0
                
                
                  
                    
                      b
                      d
                    
                    ≤
                    λ
                  
                
              
            
            .
          
        
      
    
    
      
        (
        19
        )
      
    
  




Compared to the traditional LSA, Sparse LSA selects only a small number of relevant words for each topic and hence provides a compact representation of topic-word relationships. Moreover, Sparse LSA is computationally very efficient with significantly reduced memory usage for storing the projection matrix. Empirical results show that Sparse LSA achieves similar performance gains to LSA, but is more efficient in projection computation, storage, and also well explain the topic-word relationships. For example, the LSA is more effective in the following ways:

    
    
        1. Provide a clear and compact representation of the topic-word relationship, which makes the model easy to explain
        2. Consumes less memory.
        3. Able to handle more topics.
    
    


The Sparse LSA model is intuitive that only a part of the vocabulary can be relevant to a certain topic. By enforcing sparsity of A such that each row (representing a latent topic) only has a small number nonzero entries (representing the most relevant words), Sparse LSA can provide a compact representation for topic-word relationship that is easier to interpret. Further, with the adjustment of sparsity level in projection matrix, the system could control the granularity (“level-of-details”) of the topics it is trying to discover, e.g. more generic topics have more nonzero entries in rows of A than specific topics. Due to the sparsity of A, Sparse LSA provides an efficient strategy both in the time cost of the projection operation and in the storage cost of the projection matrix when the dimensionality of latent space D is large. The Sparse LSA could project a document q into a sparse vector representation {circumflex over (q)} where each entry of {circumflex over (q)} corresponds to a latent topic. In other words, we could know the topics that q belongs to directly form the position of nonzero entries of {circumflex over (q)}. Moreover, sparse representation of projected documents will save a lot of computational cost for the subsequent retrieval tasks, e.g. ranking (considering computing cosine similarity), text categorization, among others.
The Sparse LSA provides a more compact and precise projection by selecting only a small number of relevant words for each latent topic. Extensions of Sparse LSA, group structured LSA and non-negative Sparse LSA, along with a simple yet efficient syste to learn the sparse projection matrix for these models, are presented. The inventors contemplate utilizing the online learning scheme to learn web-scale datasets.
The invention may be implemented in hardware, firmware or software, or a combination of the three. Preferably the invention is implemented in a computer program executed on a programmable computer having a processor, a data storage system, volatile and non-volatile memory and/or storage elements, at least one input device and at least one output device.
By way of example, a block diagram of a computer to support the system is discussed next in FIG. 3. The computer preferably includes a processor, random access memory (RAM), a program memory (preferably a writable read-only memory (ROM) such as a flash ROM) and an input/output (I/O) controller coupled by a CPU bus. The computer may optionally include a hard drive controller which is coupled to a hard disk and CPU bus. Hard disk may be used for storing application programs, such as the present invention, and data. Alternatively, application programs may be stored in RAM or ROM. I/O controller is coupled by means of an I/O bus to an I/O interface. I/O interface receives and transmits data in analog or digital form over communication links such as a serial link, local area network, wireless link, and parallel link. Optionally, a display, a keyboard and a pointing device (mouse) may also be connected to I/O bus. Alternatively, separate connections (separate buses) may be used for I/O interface, display, keyboard and pointing device. Programmable processing system may be preprogrammed or it may be programmed (and reprogrammed) by downloading a program from another source (e.g., a floppy disk, CD-ROM, or another computer).
Each computer program is tangibly stored in a machine-readable storage media or device (e.g., program memory or magnetic disk) readable by a general or special purpose programmable computer, for configuring and controlling operation of a computer when the storage media or device is read by the computer to perform the procedures described herein. The inventive system may also be considered to be embodied in a computer-readable storage medium, configured with a computer program, where the storage medium so configured causes a computer to operate in a specific and predefined manner to perform the functions described herein.
The invention has been described herein in considerable detail in order to comply with the patent Statutes and to provide those skilled in the art with the information needed to apply the novel principles and to construct and use such specialized components as are required. However, it is to be understood that the invention can be carried out by specifically different equipment and devices, and that various modifications, both as to the equipment details and operating procedures, can be accomplished without departing from the scope of the invention itself.

## Claims

1. A method to perform preference learning on a set of documents, comprising:
receiving raw input features from the set of documents stored on a data storage device;
generating polynomial combinations from the raw input features;
generating one or more parameters W;
applying W to one or more classifiers to generate outputs;
determining a loss function and parameter gradients and updating W;
determining one or more sparse regularizing terms and updating W; and
expressing that one document is preferred over another in a search query and retrieving one or more documents responsive to the search query,
wherein said regularizing terms are responsive to an imposing of an entry-wise l1 regularization on W and a refitting without the regularization is used to improve preference prediction while keeping the learned sparsity and said refitting reducing additional bias introduced by the l1 regularization, said refitting being affected by





  
    
      
        P
        Ω
      
      ⁡
      
        (
        W
        )
      
    
    ij
  
  =
  
    {
    
      
        
          
            
              
                W
                ij
              
              ⁢
              
                
              
              ⁢
              if
              ⁢
              
                
              
              ⁢
              
                (
                
                  i
                  ,
                  j
                
                )
              
            
            ∈
            Ω
          
        
      
      
        
          
            
              0
              ⁢
              
                
              
              ⁢
              if
              ⁢
              
                
              
              ⁢
              
                (
                
                  i
                  ,
                  j
                
                )
              
              ⁢
              
                
              
              ⁢
              not
            
            ∈
            Ω
          
        
      
    
  



 where W represents a relationship between a pair of words, Ω represents indices of non-zero entries of sparse W, and ij are matrix iterations.

2. The method of claim 1, comprising constraining W to be a sparse matrix zero entry for pairs of words irrelevant to the preference learning.

3. The method of claim 1, comprising enforcing an l1 regularization with mini-batch shrinking for every predetermined iterations in a stochastic gradient descent.

4. The method of claim 1, comprising performing a stochastic (sub)gradient descent (SGD) with an online learning framework.

5. The method of claim 1, comprising applying a learning rate ηt, a decaying learning rate is used with η1=C/√t, where C is a pre-defined constant as an initial learning rate and t represents an iteration .

6. The method of claim 1, comprising shrinking Wijt with an absolute value less than ληt to zero and generating a sparse W matrix, λ is a regularization parameter which controls a sparsity level (number of nonzero entries) of W and ηt denotes a learning rate.

7. The method of claim 1, comprising performing shrinkage at every iteration to generate a sparse W .

8. A computer to perform preference learning on a set of documents, comprising:
means for receiving raw input features from the set of documents stored on a data storage device;
means for generating polynomial combinations from the raw input features ;
means for generating one or more parameters W;
means for applying W to one or more classifiers to generate outputs;
means for determining a loss function and parameter gradients and updating W;
means for determining one or more sparse regularizing terms and updating W; and
means for expressing that one document is preferred over another in a search query and retrieving one or more documents responsive to the search query,
wherein said regularizing terms are responsive to an imposing of an entry-wise l1 regularization on W and to reduce additional bias introduced by the l1 regularization a refitting without the regularization is used to improve preference prediction while keeping the learned sparsity, said refitting being related to





  
    
      
        P
        Ω
      
      ⁡
      
        (
        W
        )
      
    
    ij
  
  =
  
    {
    
      
        
          
            
              
                W
                ij
              
              ⁢
              
                
              
              ⁢
              if
              ⁢
              
                
              
              ⁢
              
                (
                
                  i
                  ,
                  j
                
                )
              
            
            ∈
            Ω
          
        
      
      
        
          
            
              0
              ⁢
              
                
              
              ⁢
              if
              ⁢
              
                
              
              ⁢
              
                (
                
                  i
                  ,
                  j
                
                )
              
              ⁢
              
                
              
              ⁢
              not
            
            ∈
            Ω
          
        
      
    
  



 where W represents a relationship between a pair of words, Ω represents indices of non-zero entries of sparse W, and ij are matrix iterations.

9. The computer of claim 8, comprising means for enforcing an l1 regularization with mini-batch shrinking for every predetermined iterations in a stochastic gradient descent.