# Patent

## Title
Full-sequence training of deep structures for speech recognition

## Abstract

A method includes an act of causing a processor to access a deep-structured model retained in a computer-readable medium, the deep-structured model includes a plurality of layers with respective weights assigned to the plurality of layers, transition probabilities between states, and language model scores. The method further includes the act of jointly substantially optimizing the weights, the transition probabilities, and the language model scores of the deep-structured model using the optimization criterion based on a sequence rather than a set of unrelated frames.

## Background
BACKGROUND
Speech recognition has been the subject of a significant amount of research and commercial development. For example, speech recognition systems have been incorporated into mobile telephones, desktop computers, automobiles, and the like in order to provide a particular response to speech input provided by a user. For instance, in a mobile telephone equipped with speech recognition technology, a user can speak a name of a contact listed in the mobile telephone and the mobile telephone can initiate a call to the contact. Furthermore, many companies are currently using speech recognition technology to aid customers in connection with identifying employees of a company, identifying problems with a product or service, etc.
Research in ASR has explored layered architectures to perform speech recognition, motivated partly by the desire to capitalize on some analogous properties in the human speech generation and perception systems. In these studies, learning of model parameters has been one of the most prominent and difficult problems. In parallel with the development in ASR research, recent progresses made in learning methods from neural network research has ignited interest in exploration of deep-structured models. One particular advance is the development of effective learning techniques for deep belief networks (DBNs), which are densely connected, directed belief networks with many hidden layers. In general, DBNs can be considered as a highly complex nonlinear feature extractor with a plurality of layers of hidden units and at least one layer of visible units, where each layer of hidden units learns to represent features that capture higher order correlations in original input data.
Although DBNs typically have higher modeling power than their more shallow counterparts, learning in DBNs is difficult partly because a back-propagation algorithm often does not perform effectively due to the significantly increased chance of trapping into a local optimum.
Accordingly, improved learning techniques with respect to DBNs are desirable.
SUMMARY
The following is a brief summary of subject matter that is described in greater detail herein. This summary is not intended to be limiting as to the scope of the claims.
Described herein are various technologies pertaining to automatic speech recognition (ASR). With more specificity, various technologies pertaining to utilization of deep-structured models to perform ASR are described herein. With still more specificity, various technologies pertaining to performing full-sequence training of deep-structured models for speech recognition are described herein.
An exemplary deep-structured model that can be utilized in connection with ASR is a deep belief network (DBN). A pretraining procedure can be undertaken on a DBN, wherein such pretraining procedure can pertain to learning initial weights between layers of variables (visible and hidden) in the DBN. In an example, such pretraining procedure can learn the initial weights for each layer of the DBN greedily by treating each pair of layers in the DBN as a Restricted Boltzmann Machine (RBM).
Subsequent to the DBN being subjected to pretraining, the DBN weights, transition parameters, and language model (LM) scores can be substantially optimized jointly through utilization of a discriminative training criterion at the sequence level designed for DBNs. More particularly, speech recognition can be referred to as a sequential or full-sequence learning problem, and it has been well known that discriminative information at the sequence level contributes to improving recognition accuracy. In previous approaches, only frame-level information was utilized for training DBN weights, and transition parameters and LM scores are obtained separately.
Other aspects will be appreciated upon reading and understanding the attached figures and description.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a functional block diagram of an exemplary system that facilitates performing automatic speech recognition (ASR) through utilization of a Deep Believe Network (DBN).
FIG. 2 is a functional block diagram of an exemplary system that facilitates initializing weights of a DBN.
FIG. 3 is a functional block diagram of an exemplary system that facilitates jointly substantially optimizing DBN weights, transition parameters, and language model (LM) scores.
FIG. 4 is an exemplary DBN.
FIG. 5 is a flow diagram that illustrates an exemplary methodology for jointly learning DBN weights, transition parameters, and LM scores.
FIG. 6 is a flow diagram that illustrates an exemplary methodology for jointly learning DBN weights, transition parameters, and LM scores.
FIG. 7 illustrates an exemplary Deep Hidden Conditional Random Field.
FIG. 8 is an exemplary computing system.



DETAILED DESCRIPTION
Various technologies pertaining to automatic speech recognition (ASR) systems will now be described with reference to the drawings, where like reference numerals represent like elements throughout. In addition, several functional block diagrams of example systems are illustrated and described herein for purposes of explanation; however, it is to be understood that functionality that is described as being carried out by certain system components may be performed by multiple components. Similarly, for instance, a component may be configured to perform functionality that is described as being carried out by multiple components, and some steps in methodologies described herein may be omitted, re-ordered, or combined.
With reference to FIG. 1, an exemplary system 100 that facilitates performing ASR is illustrated. The system 100 includes a speech recognition system 102 that receives a sample 104. The sample can be spoken words from an individual over a particular amount of time (e.g., captured through utilization of a microphone). The sample 104 can be digitized through utilization of an analog to digital converter, and can be subject to some form of normalization if desired. While the examples provided herein indicate that the sample 104 is a spoken utterance, it is to be understood that the system 100 may be configured to perform online handwriting recognition and/or real-time gesture recognition. Thus, the sample 104 may be an online handwriting sample or a video signal describing movement of an object such as a human being.
The speech recognition system 102 comprises a deep-structured model 106. In an example, the deep-structured model 106 can be a Deep Belief Network (DBN), wherein the DBN is temporally parameter-tied. A DBN is a probabilistic generative model with multiple layers of stochastic hidden units above a single bottom layer of observed variables that represent a data vector. With more specificity, a DBN is a densely connected, directed belief network with many hidden layers for which learning is a difficult problem. The deep-structured model 106 can receive the sample 104 and can output state posterior probabilities with respect to an output unit, which can be a phone, a senone, or some other suitable output unit. As will be described in more detail below, the deep-structured model 106 can be generated through a pretraining procedure, and thereafter weights of the deep-structured model 106, transition parameters in the deep-structured model 106 and language model scores can be substantially optimized jointly through sequential or full-sequence learning.
The speech recognition system 102 additionally includes a decoder 108, which can decode output of the deep-structured model to generate an output 110. The output 110, pursuant to an example, can include an indication of a word or word sequence that was received as the sample 104. In another example, the output 110 may be a gesture that pertains to a gesture captured in a video sample. In yet another example, the output 110 can be an indication of a word or word sequence that is being written on a pressure-sensitive screen.
Pursuant to an example, the speech recognition system 102 can be deployed in a variety of contexts. For instance, the speech recognition system 102 can be deployed in a mobile telephone, such that the mobile telephone can act responsive to spoken commands of a user. In another example, the speech recognition system 102 can be deployed in an automobile, such that the automobile can act responsive to spoken commands of a user. Other systems within which the speech recognition system 102 can be employed include automated transcribing systems, industrial automation systems, banking systems, and other suitable systems that employ ASR technology.
Now referring to FIG. 2, an exemplary 200 system that facilitates initializing weights of a DBN is illustrated. The system 200 comprises an initializer component 202 that receives a DBN 204. As described previously, DBNs are densely connected, directed belief network with many hidden layers for which learning is a difficult problem. The initializer component 202 can act to learn each layer of the DBN 204 greedily by treating each pair of layers as a Restricted Boltzmann Machine (RBM). The initializer component 202 can access training data in a data repository 206 to perform the aforementioned training With more detail, an RBM is a particular type of Markov random field (MRF) that has one layer of (typically Bernoulli) stochastic hidden units and one layer of (typically Bernoulli or Gaussian) stochastic visible units. RBMs can be represented as bipartite graphs since all visible units are connected to all hidden units, but there are no visible-visible or hidden-hidden connections.
In the RBMs, the joint distribution p(v, h; θ) over the visible units v and hidden units h, given the model parameters θ, can be defined in terms of an energy function E(v, h; θ) of the following algorithm:




  
    
      
        
          
            p
            ⁡
            
              (
              
                v
                ,
                
                  h
                  ;
                  θ
                
              
              )
            
          
          =
          
            
              exp
              ⁡
              
                (
                
                  -
                  
                    E
                    ⁡
                    
                      (
                      
                        v
                        ,
                        
                          h
                          ;
                          θ
                        
                      
                      )
                    
                  
                
                )
              
            
            Z
          
        
        ,
      
    
    
      
        (
        1
        )
      
    
  




where Z=ΣuΣhexp(−E(v, h; θ)) is a normalization factor or partition function, and the marginal probability that the model assigns to a visible vector v can be defined as follows:





  
    
      
        
          p
          ⁡
          
            (
            
              v
              ;
              θ
            
            )
          
        
        =
        
          
            
              ∑
              h
            
            ⁢
            
              exp
              ⁡
              
                (
                
                  -
                  
                    E
                    ⁡
                    
                      (
                      
                        v
                        ,
                        
                          h
                          ;
                          θ
                        
                      
                      )
                    
                  
                
                )
              
            
          
          Z
        
      
    
    
      
        (
        2
        )
      
    
  




For a Bernoulli (visible)-Bernoulli (hidden) RBM, the energy is as follows:

E(v,h;θ)=−Σi=1VΣj=1Hwijvihj−Σi=Vbivi−Σj=1Hajhj,  (3)

where wij represents the symmetric interaction term between visible unit vi and hidden unit hj, bi and aj represent the bias terms, and V and H are the numbers of visible and hidden units. The conditional probabilities can be calculated as follows:

p(hj=1|v;θ)=σ(Σi=1Vwijvi+aj)  (4)

p(vi=1|h;θ)=σ(Σj=1Hwijhj+bi),  (5)

where σ(x)=1/(1+exp(−x)).

Similarly, for a Gaussian-Bernoulli RBM, the energy is as follows after assuming that the variance is unity:




  
    
      
        
          
            E
            ⁡
            
              (
              
                v
                ,
                
                  h
                  ;
                  θ
                
              
              )
            
          
          =
          
            
              -
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  V
                
                ⁢
                
                  
                    ∑
                    
                      j
                      =
                      1
                    
                    H
                  
                  ⁢
                  
                    
                      w
                      ij
                    
                    ⁢
                    
                      v
                      i
                    
                    ⁢
                    
                      h
                      j
                    
                  
                
              
            
            +
            
              
                1
                2
              
              ⁢
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  V
                
                ⁢
                
                  
                    (
                    
                      
                        v
                        i
                      
                      -
                      
                        b
                        i
                      
                    
                    )
                  
                  2
                
              
            
            -
            
              
                ∑
                
                  j
                  =
                  1
                
                H
              
              ⁢
              
                
                  a
                  j
                
                ⁢
                
                  h
                  j
                
              
            
          
        
        ,
      
    
    
      
        (
        6
        )
      
    
  




The corresponding conditional probabilities become:

p(hj=1|v;θ)=σ(Σi=1Vwijvi+aj)  (7)

p(vi|h;θ)=N(Σj=1Hwijhj+bi,1)  (8)

where vi can take real values and can follow a Gaussian distribution with mean Σj=1Hwijhj+bi and variance of one. Gaussian-Bernoulli RBMs can be used to convert real-valued stochastic variables to binary stochastic variables which can then be further processed using the Bernoulli-Bernoulli RBMs.

Following the gradient of the log likelihood log p(v; θ) the update rule for the weights can be obtained by the initializer component 202 as follows:

Δwij=vihjdata−vihjmodel,  (9)

where vihjdata is the expectation observed in the training data and vihjmodel is that same expectation under the distribution defined by the DBN 204. Unfortunately, vihjmodel can be extremely expensive to compute exactly so the contrastive divergence (CD) approximation to the gradient may be used where vihjmodel is replaced by running a Gibbs sampler initialized at the data for one full step.

From a decoding point of view, the DBN 204 can be treated as a multi-layer perceptron with many layers. The input signal (from the training data) can be processed layer by layer through utilization of equation (4) until the final layer. The final layer can be transformed into a multinomial distribution using the following softmax operation:




  
    
      
        
          
            p
            ⁡
            
              (
              
                
                  l
                  =
                  
                    k
                    ❘
                    h
                  
                
                ;
                θ
              
              )
            
          
          =
          
            
              exp
              ⁡
              
                (
                
                  
                    
                      ∑
                      
                        i
                        =
                        1
                      
                      H
                    
                    ⁢
                    
                      
                        λ
                        ik
                      
                      ⁢
                      
                        h
                        i
                      
                    
                  
                  +
                  
                    a
                    k
                  
                
                )
              
            
            
              z
              ⁡
              
                (
                h
                )
              
            
          
        
        ,
      
    
    
      
        (
        10
        )
      
    
  




where l=k denotes the input been classified into the k-th class, and λik is the weight between hidden unit hi at the last layer and class label k.

Pursuant to an example, the initializer component 202 can utilize a conventional frame-level data to train the DBN 204. For instance, the initializer component 202 can train a stack of RBMs in a generative manner, resulting in output of a pretrained DBN 208. As will be described below, the DBN weights, transition parameters, and language model scores can be learned through utilization of a back-propagation algorithm by substantially maximizing the frame-level or utterance-level cross-entropy between the true and the predicted probability distributions over class labels. Furthermore, while the initializer component 202 has been described above as performing pretraining on a DBN in a particular manner, it is to be understood that weights of a DBN can be initialized through other methods, including but not limited to denoising/autoencoding.
Now referring to FIG. 3, an exemplary system 300 that facilitates jointly substantially optimizing DBN weights, transition parameters, and language model (LM) scores is illustrated. The system 300 includes a receiver component 301 that receives the pretrained DBN 208. A trainer component 302 that is in communication with the receiver component receives the pretrained DBN 208 and the training data in the data store 206 (which can be different training data than what was employed by the initializer component 202 or the same training data employed by the initializer component 202). The trainer component 302 can be configured to jointly substantially optimize weights of the pretrained DBN 208, state transition parameters, and language model scores. For instance, the trainer component 302 can utilize back-propagation to perform such joint fine-tuning of the DBN 208.
Conventional discriminative back-propagation methods optimize the log posterior probability p(lt|vt) of class labels given the current input, both at time-frame t (which may be a fixed local block of frames). This method of training DBNs can be referred to as a frame-based approach, because it only uses the frame (or frame-block) of an input sample to predict the class labels. The method does not explicitly use the fact that the neighboring frames (or frame-blocks) have smaller distances between the assigned probability distributions over class labels. To take this fact into account, the probability of the whole sequence of labels given the whole utterance p(l1:T|v1:T) can be modeled.
The approach described herein is to consider the top-most layer of the DBN as a linear-chain conditional random field (CRF) with ht as input features from the lower layer at time t. This model can be viewed as a modification of a deep-structured CRF where the lower multiple layers of CRFs are replaced by DBNs.
The conditional probability of the full-sequence labels given the full-sequence input features in this sequential model can be given as follows:




  
    
      
        
          p
          ⁡
          
            (
            
              
                l
                
                  1
                  :
                  T
                
              
              ❘
              
                v
                
                  1
                  :
                  T
                
              
            
            )
          
        
        =
        
          
            p
            ⁡
            
              (
              
                
                  l
                  
                    1
                    :
                    T
                  
                
                ❘
                
                  h
                  
                    1
                    :
                    T
                  
                
              
              )
            
          
          =
          
            
              exp
              ⁡
              
                (
                
                  
                    
                      ∑
                      
                        t
                        =
                        1
                      
                      T
                    
                    ⁢
                    
                      
                        γ
                        ij
                      
                      ⁢
                      
                        
                          φ
                          ij
                        
                        ⁡
                        
                          (
                          
                            
                              l
                              
                                t
                                -
                                1
                              
                            
                            ,
                            
                              l
                              t
                            
                          
                          )
                        
                      
                    
                  
                  +
                  
                    
                      ∑
                      
                        t
                        =
                        1
                      
                      T
                    
                    ⁢
                    
                      
                        ∑
                        
                          d
                          =
                          1
                        
                        D
                      
                      ⁢
                      
                        
                          λ
                          
                            
                              l
                              t
                            
                            ⁢
                            d
                          
                        
                        ⁢
                        
                          h
                          td
                        
                      
                    
                  
                
                )
              
            
            
              Z
              ⁡
              
                (
                
                  h
                  
                    1
                    :
                    T
                  
                
                )
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  




where the transition feature is as follows:





  
    
      
        
          
            φ
            ij
          
          ⁡
          
            (
            
              
                l
                
                  t
                  -
                  1
                
              
              ,
              
                l
                t
              
            
            )
          
        
        =
        
          {
          
            
              
                1
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    
                      l
                      
                        t
                        -
                        1
                      
                    
                  
                  =
                  
                    
                      i
                      ⁢
                      
                        
                      
                      ⁢
                      and
                      ⁢
                      
                        
                      
                      ⁢
                      
                        l
                        t
                      
                    
                    =
                    j
                  
                
              
            
            
              
                0
              
              
                
                  otherwise
                  ,
                
              
            
          
        
      
    
    
      
        (
        12
        )
      
    
  




γij is the parameter associated with this transition feature, htd is the d-th dimension of the hidden unit value at the t-th frame at the last layer ht, and D is the dimension of (or number of units) at that hidden layer.

To optimize the log conditional probability p(l1:Tn|v1:Tn) of the n-th utterance, the trainer component 302 can take the gradient over the activation parameters λkd, transition parameters γij, and M-th-layer weights wij(M) as follows:





  
    
      
        
          
        
        ⁢
        
          
            
              
                ∂
                log
              
              ⁢
              
                
              
              ⁢
              
                p
                ⁡
                
                  (
                  
                    
                      l
                      
                        1
                        :
                        T
                      
                      n
                    
                    ❘
                    
                      v
                      
                        1
                        :
                        T
                      
                      n
                    
                  
                  )
                
              
            
            
              ∂
              
                λ
                kd
              
            
          
          =
          
            
              ∑
              
                t
                =
                1
              
              T
            
            ⁢
            
              
                (
                
                  
                    δ
                    ⁡
                    
                      (
                      
                        
                          l
                          t
                          n
                        
                        =
                        k
                      
                      )
                    
                  
                  -
                  
                    p
                    ⁡
                    
                      (
                      
                        
                          l
                          t
                          n
                        
                        =
                        
                          k
                          ❘
                          
                            v
                            
                              1
                              :
                              T
                            
                            n
                          
                        
                      
                      )
                    
                  
                
                )
              
              ⁢
              
                h
                td
                
                  
                    (
                    M
                    )
                  
                  ,
                  n
                
              
            
          
        
      
    
    
      
        (
        13
        )
      
    
  
  
    
      
        
          
            
              ∂
              log
            
            ⁢
            
              
            
            ⁢
            
              p
              ⁡
              
                (
                
                  
                    l
                    
                      1
                      :
                      T
                    
                    n
                  
                  ❘
                  
                    v
                    
                      1
                      :
                      T
                    
                    n
                  
                
                )
              
            
          
          
            ∂
            
              γ
              ij
            
          
        
        =
        
          
            ∑
            
              t
              =
              1
            
            T
          
          ⁢
          
            (
            
              
                δ
                ⁡
                
                  (
                  
                    
                      
                        l
                        
                          t
                          -
                          1
                        
                        n
                      
                      =
                      i
                    
                    ,
                    
                      
                        l
                        t
                        n
                      
                      =
                      j
                    
                  
                  )
                
              
              -
              
                p
                ⁡
                
                  (
                  
                    
                      
                        l
                        
                          t
                          -
                          1
                        
                        n
                      
                      =
                      i
                    
                    ,
                    
                      
                        l
                        t
                        n
                      
                      =
                      
                        j
                        ❘
                        
                          v
                          
                            1
                            :
                            T
                          
                          n
                        
                      
                    
                  
                  )
                
              
            
            )
          
        
      
    
    
      
        (
        14
        )
      
    
  
  
    
      
        
          
            
              ∂
              log
            
            ⁢
            
              
            
            ⁢
            
              p
              ⁡
              
                (
                
                  
                    l
                    
                      1
                      :
                      T
                    
                    n
                  
                  ❘
                  
                    v
                    
                      1
                      :
                      T
                    
                    n
                  
                
                )
              
            
          
          
            ∂
            
              w
              ij
              
                (
                M
                )
              
            
          
        
        =
        
          
            ∑
            
              t
              =
              1
            
            T
          
          ⁢
          
            
              
                (
                
                  
                    λ
                    
                      
                        l
                        t
                      
                      ⁢
                      d
                    
                  
                  -
                  
                    
                      ∑
                      
                        k
                        =
                        1
                      
                      K
                    
                    ⁢
                    
                      
                        p
                        ⁡
                        
                          (
                          
                            
                              l
                              t
                              n
                            
                            =
                            
                              k
                              ❘
                              
                                v
                                
                                  1
                                  :
                                  T
                                
                                n
                              
                            
                          
                          )
                        
                      
                      ⁢
                      
                        λ
                        kd
                      
                    
                  
                
                )
              
              ·
              
                
                  h
                  td
                  
                    
                      (
                      M
                      )
                    
                    ,
                    n
                  
                
                ⁡
                
                  (
                  
                    1
                    -
                    
                      h
                      td
                      
                        
                          (
                          M
                          )
                        
                        ,
                        n
                      
                    
                  
                  )
                
              
            
            ⁢
            
              h
              ti
              
                
                  (
                  
                    M
                    -
                    1
                  
                  )
                
                ,
                n
              
            
          
        
      
    
    
      
        (
        15
        )
      
    
  




It can be noted that the gradient ∂ log P(l1:Tn|v1:Tn)/∂wij(m) can be considered as back-propagating the error δ(ltn=k)−p(ltn=k|v1:Tn) versus δ(ltn=k)−p(ltn=k|vtn) in a frame-based training algorithm.

While the basic optimization algorithm with gradient descent can be succinctly described by equations (13), (14), and (15), which compute the gradients in analytical forms, several practical issues can be considered in the algorithm implementation. First, the top-layer CRF's state transition parameters can form a transition matrix, which is different from that of a Hidden Markov Model (HMM). In fact, such state transition parameters are a combination of the transition matrix and bi-phone/senone LM scores. Without proper constraints, the transition matrix may have low likelihoods of being transitioning between states that are prohibited in the left-to-right three-state HMMs even though the training data does not support such transitions. To prevent this from happening so that a sharper model may be built, this constraint can be enforced in the training by setting transition weights that are prohibited in the HMMs to have a very large negative value.
Second, since the weights in the DBNs are jointly optimized together with CRF's transition parameters, the optimization problem is no longer convex. For this reason, good initialization is crucial. The DBN weights can be initialized by the initializer component 202 (FIG. 2) described above. For example, the transition parameters can be initialized from the combination of the HMM transition matrices and the LM scores, and can be further optimized by tuning the transition features while fixing the DBN weights prior to the trainer component 302 performing joint optimization.
Third, there are two ways of doing decoding using a DBN that has been trained as described above. A first approach is to feed the log marginal probability log p(lt|v1:T) as the activation scores to the conventional HMM decoder and use the HMM transition matrices and LM scores in a conventional manner. This approach may work when the full-sequence training can improve the quality of log p(lt|v1:T). A second approach is to generate the state sequence first and then to map the state sequence to the phoneme/senone sequence. The decoding result may be further improved if insertion penalties are contemplated, which can be integrated into the decoder component 108 (FIG. 1) by modifying the transition parameters by the following:

{circumflex over (γ)}ij=ργij+φ  (16)

if state i is the final state of a phone and state j is the first state of a phone, where φ is the insertion penalty, and ρ is the scaling factor.

The pretrained DBN 208 can be configured with the jointly optimized DBN weights, LM scores, and transition probabilities as the parameters. The trainer component 302 can further train the DBN 208 by way of back propagation.
Now referring to FIG. 4, an exemplary DBN 400 is illustrated. A top level 402 of the DBN can be a linear-chain CRF, and the architecture of the DBN 400 can be viewed as shared DBNs unfolding over time (an exemplary shared DBN 404 is illustrated in FIG. 4). The DBN 400 can receive the sample 104 or some derivation thereof, which can be partitioned into a plurality of observed variables 408 over time t. The observed variables 408 can represent data vectors at different instances in time. The DBN 400 further comprises multiple layers of stochastic hidden units 410. The DBN 400 has undirected connections 412 between the top two layers of the stochastic hidden units 410 and directed connections 414 to all other layers from the layers above. Weights w can be initially assigned to the directed and undirected connections 412 and 414, respectively, during the pretraining described above. λik (shown in FIG. 4 generally as λ) is the weight between hidden unit hi at the last layer in the DBN 400 (shown as h(M) in FIG. 4) and class label k (shown as 1 in FIG. 4), and γij (shown generally as γ in FIG. 4) are transition probabilities between classes. In this exemplary embodiment, the DBN 400 can be trained such that the output units in the uppermost layer (the Mth layer) can be modeled as a phonetic unit or subunit, such as a phone or senone.
With reference now to FIGS. 5 and 6, exemplary methodologies are illustrated and described. While the methodologies are described as being a series of acts that are performed in a sequence, it is to be understood that the methodology is not limited by the order of the sequence. For instance, some acts may occur in a different order than what is described herein. In addition, an act may occur concurrently with another act. Furthermore, in some instances, not all acts may be required to implement a methodology described herein.
Moreover, the acts described herein may be computer-executable instructions that can be implemented by one or more processors and/or stored on a computer-readable medium or media. The computer-executable instructions may include a routine, a sub-routine, programs, a thread of execution, and/or the like. Still further, results of acts of the methodologies may be stored in a computer-readable medium, displayed on a display device, and/or the like. The computer-readable medium may be a non-transitory medium, such as memory, hard drive, CD, DVD, flash drive, or the like.
With reference solely to FIG. 5, an exemplary methodology 500 that facilitates training a deep-structured model for utilization in a speech recognition system is illustrated. The methodology 500 begins at 502, and at 504 parameters of a deep-structured model are provided through a pretraining step. For example, weights between layers of a DBN can be initialized during such pretraining step. At 506, labeled training data is provided to the deep structure, wherein the labeled training data may be labeled words or word sequences, labeled gestures, labeled handwriting samples, etc. At 508, weights between layers in the deep-structured model, language model parameters, and state transition probabilities are jointly substantially optimized, such that the resultant trained deep-structured model can be commissioned into a speech recognition system. The methodology 500 completes at 510.
Turning now to FIG. 6, an exemplary methodology 600 that facilitates training a DBN for utilization in an automated speech recognition system is illustrated. The methodology 600 starts at 602, and at 604 each layer of a DBN that is configured for utilization in an automated speech recognition system is greedily learned. At 606, the log conditional probabilities of the output states/sequences of the DBN are substantially optimized through utilization of training data. At 608, weights in the DBN, transition parameters in the DBN, and language model scores are substantially simultaneously optimized based at least in part upon the log of the conditional probabilities of output states/sequences produced by the DBN. The methodology 600 completes at 610.
The systems and methodologies shown and described above have generally referred to utilizing a DBN in a speech recognition system; as indicated above, however, other deep structures can be employed. An exemplary deep structure that can be utilized is a Deep Hidden Conditional Random Field (DHCRF). Referring to FIG. 7, an exemplary DHCRF 700 is illustrated. In an example, the Nth layer of the DHCRF can be a Hidden Conditional Random Field (HCRF), and the intermediate layers can be zero-th order CRFs that do not use state transition features.
In the exemplary DHCRF 700, the observation sequence oj at layer j consists of two parts: the preceding layer's observation sequence oj-1 and the frame-level log marginal posterior probabilities log p(stj-1|oj-1) computed from the preceding layer j−1, where stj-1 is the state value at layer j−1. The raw observations at the first layer can be denoted as o=[ot], t=1, . . . , T.
Both parameter estimation and sequence inference in the DHCRF can be carried out bottom-up, layer by layer. The final layer's state sequence conditional probability can be shown as follows:




  
    
      
        
          p
          ⁡
          
            (
            
              
                w
                ❘
                
                  o
                  N
                
              
              ;
              
                λ
                N
              
            
            )
          
        
        =
        
          
            1
            
              z
              ⁡
              
                (
                
                  
                    o
                    N
                  
                  ;
                  
                    λ
                    N
                  
                
                )
              
            
          
          ⁢
          
            
              ∑
              
                
                  s
                  N
                
                ∈
                w
              
            
            ⁢
            
              exp
              (
              
                
                  
                    (
                    
                      λ
                      N
                    
                    )
                  
                  T
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    
                      w
                      ,
                      
                        s
                        N
                      
                      ,
                      
                        o
                        N
                      
                    
                    )
                  
                
              
              )
            
          
        
      
    
    
      
        (
        17
        )
      
    
  




where N is the total number of layers, (●)T is the transposition of (●), oN=(o1N, . . . , oTN) is the observation sequence at the final layer, w is the output sequence (senone, phoneme, word, etc.), sN=(s1N, . . . , sTN) is a hypothesized state sequence, ƒ(w,sN,oN)=[ƒ1(w, sN,oN), . . . , ƒT(w,sN,oN)]T is the feature vector at the final layer, λN=[λ1N, . . . , λTN]T is the model parameter (weight vector), and z(oN;λN)=Σw,sNεwexp((λN)Tƒ(w,sN,oN)) is the partition function (normalization factor) to ensure probabilities p(w|oN;λN) sum to one. It can be ascertained that invalid sequences can be ruled out by summing over valid phoneme or word sequences only.

In contrast to the final layer, the state conditional probabilities at the intermediate layer j can be as follows:




  
    
      
        
          p
          ⁡
          
            (
            
              
                
                  s
                  j
                
                ❘
                
                  o
                  j
                
              
              ;
              
                λ
                j
              
            
            )
          
        
        =
        
          
            1
            
              z
              ⁡
              
                (
                
                  
                    o
                    j
                  
                  ;
                  
                    λ
                    j
                  
                
                )
              
            
          
          ⁢
          
            
              exp
              (
              
                
                  
                    (
                    
                      λ
                      j
                    
                    )
                  
                  T
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    
                      
                        s
                        j
                      
                      ,
                      
                        o
                        j
                      
                    
                    )
                  
                
              
              )
            
            .
          
        
      
    
    
      
        (
        18
        )
      
    
  




This is different from (17) in two ways. First, transition features are not used in (18) and observation features ƒ(sj,oj) can be simplified to [ƒ(stj,otj)]t=1, . . . ,T which is defined below. Second, there is no summation over state sequences with all possible segmentations in (18).

Weights of the DHCRF can be learned utilizing a combination of supervised and unsupervised learning. The training supervision of the DHCRF 700 is available only at the final layer and can be directly determined by the problem to be solved. For example, in the phonetic recognition task, the phoneme sequence w is known at the final layer during the training phase. Parameter estimation at the final layer can thus be carried out in a supervised manner. The supervision, however, is not available for the intermediate layers, which play the role of converting original observations to some intermediate abstract representations. For this reason, an unsupervised approach can be utilized to learn parameters in the intermediate layers.
There are several approaches to learning the intermediate layer representations in the DHCRF 700. For example, the intermediate layer learning problem can be cast into a multi-objective programming (MOP) problem in which the average frame-level conditional entropy is minimized and the state occupation entropy is maximized at a substantially similar time. Minimizing the average frame-level conditional entropy can force the intermediate layers to be sharp indicators of subclasses (or clusters) for each input vector, while maximizing the occupation entropy guarantees that the input vectors be represented distinctly by different intermediate states. The MOP optimization algorithm alternates the steps in optimizing these two contradictory criteria until no further improvement in the criteria is possible or the maximum number of iterations is reached. The MOP optimization, however, can become difficult when the number of classes in the intermediate layers becomes higher (as in a phone recognition task) since it is hard to control when to switch to optimize the other criterion given the vastly increased probability of being trapped into a local optimum.
Alternatively, a GMM-based algorithm can be employed to learn parameters in the intermediate layers of the DHCRF 700. This algorithm can utilize a layer-by-layer approach: once a lower layer is trained, the parameters of that layer are fixed and the observation sequences of the next layer are generated using the newly trained lower-layer parameters. This process can continue until all the layers are trained.
With more specificity, to learn the parameters of an intermediate layer, a single GMM with diagonal covariance (initialized from the corresponding HMM model which is optimized using the Gaussian splitting strategy) can be trained. The following can then be assigned as the state value to each observation frame otj at layer j by assuming each Gaussian component is a state, where μij and Σij are the mean and variance of the i-th Gaussian component at layer j:

stj=argmaxiN(otj;μij,Σij)  (19)

The parameters of the CRF at layer j can then be learned by maximizing the regularized log-conditional probability as follows:





  
    
      
        
          
            J
            1
          
          ⁡
          
            (
            
              λ
              j
            
            )
          
        
        =
        
          
            
              ∑
              k
            
            ⁢
            
              
                ∑
                t
              
              ⁢
              
                log
                ⁢
                
                  
                
                ⁢
                
                  p
                  (
                  
                    
                      
                        s
                        t
                        
                          
                            (
                            k
                            )
                          
                          ,
                          j
                        
                      
                      ❘
                      
                        o
                        t
                        
                          
                            (
                            k
                            )
                          
                          ,
                          j
                        
                      
                    
                    ;
                    
                      λ
                      j
                    
                  
                  )
                
              
            
          
          -
          
            
              
                
                
                  λ
                  j
                
                
              
              1
            
            
              σ
              1
            
          
          -
          
            
              
                
                
                  λ
                  j
                
                
              
              2
              2
            
            
              σ
              2
            
          
        
      
    
    
      
        (
        20
        )
      
    
  




where k is the utterance ID, ∥·∥1 is a L1-norm to enforce sparseness of the parameters associated with each state value, ∥·∥22 is the square of L2-norm to give preference to smaller weights, and σ1 and σ2 are positive values to determine the importance of each regularization term. A regularized dual averaging method can be used to solve this optimization problem with L1/L2 regularization terms.

Pursuant to an example, transition features may not be used in the intermediate layers. Instead, only the first- and second-order observation features can be used as follows:

ƒs′(M1)(st,ot)=δ(st=s′)ot∀s′  (21)

ƒs′(M2)(st,ot)=δ(st=s′)ot∘ot∀s′  (22)

where ∘ is an element-wise product.

The final layer of the DHCRF 700 can be trained to optimize the following in a supervised manner:




  
    
      
        
          
            J
            2
          
          ⁡
          
            (
            
              λ
              N
            
            )
          
        
        =
        
          
            
              ∑
              k
            
            ⁢
            
              log
              ⁢
              
                
              
              ⁢
              
                p
                ⁡
                
                  (
                  
                    
                      w
                      
                        (
                        k
                        )
                      
                    
                    ❘
                    
                      o
                      
                        
                          (
                          k
                          )
                        
                        ,
                        N
                      
                    
                  
                  )
                
              
            
          
          -
          
            
              
                
                
                  λ
                  N
                
                
              
              1
            
            
              σ
              1
            
          
          -
          
            
              
                
                
                  λ
                  N
                
                
              
              2
              2
            
            
              σ
              2
            
          
        
      
    
    
      
        (
        23
        )
      
    
  




where w(k) is the label for the output unit for the k-th utterance without segmentation information. In the final layer, the following can be used as features:

ƒw′′w′(LM)(w,s,o)=[δ(wi-1=w′′)δ(wi=w′)]i=1, . . . ,I∀w′′w′  (24)

ƒs′′s′(Tr)(w,s,o)=[δ(st-1=s′′)δ(st=s′)]t=1, . . . ,T∀s′′,s′  (25)

ƒs′(M1)(w,s,o)=[δ(st=s′)ot]t=1, . . . ,T∀s′  (26)

ƒs′(M2)(w,s,o)=[δ(st=s′)ot∘ot]t=1, . . . ,T∀s′  (27)

where δ(x)=1 if x is true, and δ(x)=0 otherwise. ƒw′′w′(LM)(w, s, o) are bi-gram language model (LM) features in which each output unit sequence w is consisted of I output units (e.g., senones, phonemes, or words), ƒs′′s′(Tr)(w, s, o) are state transition features, and ƒs′(M1)(w, s, o) and ƒs′(M2)(w, s, o) are the first- and second-order statistics generated from the observations, respectively.

Now referring to FIG. 8, a high-level illustration of an example computing device 800 that can be used in accordance with the systems and methodologies disclosed herein is illustrated. For instance, the computing device 800 may be used in a system that supports ASR. In another example, at least a portion of the computing device 800 may be used in a system that supports training a DBN. The computing device 800 includes at least one processor 802 that executes instructions that are stored in a memory 804. The memory 804 may be or include RAM, ROM, EEPROM, Flash memory, or other suitable memory. The instructions may be, for instance, instructions for implementing functionality described as being carried out by one or more components discussed above or instructions for implementing one or more of the methods described above. The processor 802 may access the memory 804 by way of a system bus 806. In addition to storing executable instructions, the memory 804 may also store a training data set, a validation data set, a DBN, etc.
The computing device 800 additionally includes a data store 808 that is accessible by the processor 802 by way of the system bus 806. The data store may be or include any suitable computer-readable storage, including a hard disk, memory, etc. The data store 808 may include executable instructions, a DBN, a training data set, a validation data set, etc. The computing device 800 also includes an input interface 810 that allows external devices to communicate with the computing device 800. For instance, the input interface 810 may be used to receive instructions from an external computer device, from a user, etc. The computing device 800 also includes an output interface 812 that interfaces the computing device 800 with one or more external devices. For example, the computing device 800 may display text, images, etc. by way of the output interface 812.
Additionally, while illustrated as a single system, it is to be understood that the computing device 800 may be a distributed system. Thus, for instance, several devices may be in communication by way of a network connection and may collectively perform tasks described as being performed by the computing device 800.
As used herein, the terms “component” and “system” are intended to encompass hardware, software, or a combination of hardware and software. Thus, for example, a system or component may be a process, a process executing on a processor, or a processor. Additionally, a component or system may be localized on a single device or distributed across several devices. Furthermore, a component or system may refer to a portion of memory and/or a series of transistors.
It is noted that several examples have been provided for purposes of explanation. These examples are not to be construed as limiting the hereto-appended claims. Additionally, it may be recognized that the examples provided herein may be permutated while still falling under the scope of the claims.

## Claims

1. A method comprising the following computer-executable acts:
accessing a deep belief network (DBN) retained in computer-readable data storage, wherein the DBN comprises:
a plurality of stacked hidden layers, each hidden layer comprises a respective plurality of stochastic units, each stochastic unit in each layer connected to stochastic units in an adjacent hidden layer of the DBN by way of connections, the connections assigned weights learned during a pretraining procedure; and
a linear-chain conditional random field (CRF), the CRF comprises:
a hidden layer that comprises a plurality of stochastic units; and
a plurality of output units that are representative of output states, each state in the output states being one of a phone or senone, the plurality of stochastic units connected to the plurality of output units by way of second connections, the second connections having weights learned during the pretraining procedure, the output units have transition probabilities corresponding thereto that are indicative of probabilities of transitioning between output states represented by the output units; and


jointly optimizing the weights assigned to the connections, the weights assigned to the second connections, the transition probabilities, and language model scores of the DBN based upon training data, wherein a processor performs the jointly optimizing of the weights.

2. The method of claim 1, wherein each state in the output states is a senone.

3. The method of claim 1, wherein the training data comprises speech samples, gesture samples, or handwriting samples.

4. The method of claim 1 configured to execute in a mobile computing apparatus.

5. The method of claim 1, further comprising pretraining the DBN, wherein pretraining the DBN comprises utilizing an unsupervised algorithm to assign the weights to the connections and the weights to the second connections.

6. The method of claim 5, further comprising utilizing back-propagation to jointly optimize the weights to the connections, the weights to the second connections, the transition probabilities, and the language model scores.

7. The method of claim 5, wherein pretraining the DBN comprises learning weights to assign to stochastic units in each hidden layer greedily by treating each pair of adjacent layers in the DBN as a Restricted Boltzmann Machine.

8. A computer-implemented system comprising:
a processor; and
a memory that comprises a plurality of components that are executable by the processor, the components comprising:
a receiver component that receives a pretrained deep belief network (DBN), wherein the DBN comprises a plurality of hidden layers, weights between the hidden layers, a linear conditional random field (CRF) that comprises output units that each represent possible output states, transition probabilities between output units, and language model scores, the transition probabilities representative of probabilities of transitioning between output states represented by the output units, each output state being one of a phone or senone; and
a trainer component that jointly optimizes weights of the pretrained DBN, the transition probabilities of the pretrained DBN, and language model scores of the pretrained DBN based upon a set of training data.

9. The system of claim 8, wherein the pretrained DBN is trained for speech recognition.

10. The system of claim 8, wherein each output unit is representative of a senone.

11. The system of claim 8, wherein the components further comprise an initializer component that performs a pretraining procedure, wherein the initializer component assigns the weights the weights between the hidden layers to generate the pretrained DBN.

12. The system of claim 11, wherein the initializer component greedily learns the weights between the hidden layers of the DBN to generate the pretrained DBN.

13. The system of claim 8, wherein the trainer component determines a conditional probability of a full-sequence of output states of the DBN in connection with jointly optimizing the weights, transition probabilities, and language model scores.

14. The system of claim 8, wherein the trainer component utilizes back-propagation to jointly optimize the weights between the hidden layers, the transition probabilities, and the language model scores.

15. The system of claim 8, wherein the trainer component receives a DBN and learns initial weights for each layer in the DBN to form the pretrained DBN, wherein the trainer component learns the initial weights by greedily treating each adjacent pair of layers in the DBN as a Restricted Boltzmann machine.

16. A computing device comprising a computer-readable medium, the computer-readable medium comprising instructions that, when executed by a processor, cause the processor to perform acts comprising:
greedily learning weights between hidden layers of a deep belief network (DBN) that is configured for employment in an automatic speech recognition (ASR) system, wherein the DBN is temporally parameter-tied and an uppermost layer in the DBN is a linear-chain conditional random field (CRF), the linear chain CRF comprises a plurality of output units that are representative of respective output states, each output state being one of a phone or senone;
providing training data to the DBN to optimize a log of conditional probabilities of output sequences of the DBN, an output sequence comprising a sequence of output states represented by the output units; and
jointly optimizing the weights between the DBN, transition probabilities between the output units in the CRF, and language model scores in the DBN based upon the log of the conditional probabilities of output sequences produced by the DBN.

17. The computing device of claim 16, wherein greedily learning the weights between the hidden layers comprises utilizing an unsupervised algorithm to initialize the weights between the hidden layers of the DBN.

18. The computing device of claim 16, wherein greedily learning the weights between the hidden layers comprises treating pairs of adjacent hidden layers in the DBN as a Restricted Boltzmann Machine.

19. The computing device of claim 16, wherein the DBN is configured to output a probability distribution over the output units, the output states represented by the output units being senones.

20. The computing device of claim 16, wherein back-propagation is used to jointly optimize the weights, the transition probabilities, and the language model scores of the DBN.