Abstract:
A speech recognition method, comprising:
       receiving a speech input in a first noise environment which comprises a sequence of observations;   determining the likelihood of a sequence of words arising from the sequence of observations using an acoustic model, comprising:
           providing an acoustic model for performing speech recognition on a input signal which comprises a sequence of observations, wherein said model has been trained to recognise speech in a second noise environment, said model having a plurality of model parameters relating to the probability distribution of a word or part thereof being related to an observation;   
           adapting the model trained in the second environment to that of the first environment;   the speech recognition method further comprising determining the likelihood of a sequence of observations occurring in a given language using a language model;   combining the likelihoods determined by the acoustic model and the language model and outputting a sequence of words identified from said speech input signal,   wherein adapting the model trained in the second environment to that of the first environment comprises:   adapting the model parameters of the model trained in the second noise environment to those of the first noise environment using transform parameters to produce a target distribution, wherein the transform parameters have a block diagonal form and are applied to regression classes, each regression class comprising a plurality of probability distributions;   mimicking the target distribution using a linear regression type distribution, said linear regression type distribution comprising mimicked transform parameters;   and estimating the mimicked transformed parameters.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application is based upon and claims the benefit of priority from UK application number 0912319.1 filed on Jul. 15, 2009; the entire contents of which are incorporated herein by reference. 
       TECHNICAL FIELD 
       [0002]    The present invention is concerned with the technical field of pattern recognition and specifically speech recognition. More particularly, the present invention is concerned with speech recognition in noisy environments. 
       TECHNICAL BACKGROUND 
       [0003]    Speech recognition is a technique which relies on the use of trained models such as Hidden Markov Models (HMMs) to decode an audio speech signal into recognisable words which can either be displayed or further processed. Further processing may include outputting the text into a language translation device or converting it into an understandable instruction for use voice controlled apparatus. 
         [0004]    Generally, the models are trained in a noise-free environment. However, in use, the systems are generally used in relatively noisy environments compared to the laboratory training environment. 
         [0005]    Two successful techniques have been developed for speech recognition in noisy environments. The first of these is the vector Taylor series (VTS) method. The VTS method is described in Acero et al: “HMM adaptation using vector Taylor series for noisy speech recognition”, In ICSLP-2000, vol. 3, 869-872. The VTS method compensates the HMM on each Gaussian mixture level. The system uses the mean value of each mixture as the Taylor extension points and calculates the Taylor extension matrices for each mixture. The likelihood during recognition is then expressed as: 
         [0000]        p ( y|m )= N ( y,μ   y   m   ;Σ   y   m )  (a)
 
         [0000]    where p(y|m) is the likelihood of the Gaussian mixture m from the noisy speech feature y, μ y  and Σ y  are the Gaussian mixture mean and variance. 
         [0006]    In the VTS, it is assumed that the relationship between noisy and clean features is as follows: 
         [0000]        y=x+h+g ( x,n,h )= x+h+C  ln(1 +e   C     −1     (n-x-h) )  (b)
 
         [0000]    where y is the noisy speech feature, x the corresponding clean speech feature, C the discrete cosine transform matrix and n and h the static features for additive and convolutional noise respectively. 
         [0007]    Given a Taylor extension point (x e , n e , h e ), the above non-linear relation can be linearly approximated by the first-order Taylor series as: 
         [0000]        y≈x   e   h   e   +g ( x   e   ,n   e   ,h   e )+ W ( x−x   e )+( I−W ) g ( x   e   ,n   e   ,h   e )( n−n   e )+ W ( h−h   e ) 
         [0000]        W=I+∇   x   g ( x   e   ,n   e   ,h   e )  (c)
 
         [0008]    By using the above relations, it is possible to relate the mean and variance of a Gaussian for clean speech to the mean and variance of a Gaussian for noisy speech. This can be done for the static, delta and delta-delta parts of the received signal. By applying these conversions, it is possible to adapt the trained clean model for the noisy environment. 
         [0009]    The above method suffers from the problem in that it is computationally very laborious since conversion parameters need to be calculated for each Gaussian in the HMM. Generally, in this procedure, only the first order Taylor series expansion is used. 
         [0010]    An alternative method is the so-called joint uncertainty decoding (JUD) method, which is described in Liao, H./Gales, M. J. F. (2005): “Joint uncertainty decoding for noise robust speech recognition”, In  INTERSPEECH -2005, 3129-3132. The JUD method calculates the output probability for the mixture m as follows: 
         [0000]        p ( Y|m )= |A   r   |N ( A   r   Y+b   r ;Λ x   m ,Ξ x   m +Ξ b   r )  (d)
 
         [0011]    It is assumed that mixture m belongs to the r th  regression class the method is performed in a class-by-class basis. This means that the JUD transforms relate to the same regression class are defined as: 
         [0000]        A   r =Ξ x   r (Ξ yx   r ) −1   ,b   r =Λ x   r   −A   r Λ y   r  
 
         [0000]      Ξ b   r   =A   r Ξ y   r   A   r   T −Ξ x   r   (e)
 
         [0012]    Where Λ x   r , Ξ r   x , Λ y   r , Ξ t   y  are respectively the mean and covariance for clean and noisy speech in regression class r, and Ξ r   yx  is the cross covariance matrix. 
         [0013]    As JUD transforms are usually obtained by Taylor expansion, JUD is the same as VTS except that JUD only computes Taylor expansion on each regression classes. Furthermore, most compensations in JUD are applied on feature vectors instead of HMM parameters which makes the adaptation process independent of the size of HMM. Therefore JUD is much faster than VTS on adaptation. 
         [0014]    However, one problem for JUD is the difficulty of applying non-diagonal transforms because it results in non-diagonal covariance matrices for decoding and the computational cost becomes extremely high. As a consequence, JUD implementation often uses diagonal transforms and the performance is observed to be much worse than VTS. 
       SUMMARY OF THE INVENTION 
       [0015]    The present inventors have attempted to address the above problem and derive a speech recognition method which is computationally on a par with a JUD method but which achieves accuracy similar to that of VTS methods. 
         [0016]    The present invention at least partially addresses the above problems and in first aspect provides a speech recognition method, comprising: 
         [0017]    receiving a speech input in a first noise environment which comprises a sequence of observations; 
         [0018]    determining the likelihood of a sequence of words arising from the sequence of observations using an acoustic model, comprising: 
         [0019]    providing an acoustic model for performing speech recognition on a input signal which comprises a sequence of observations, wherein said model has been trained to recognise speech in a second noise environment, said model having a plurality of model parameters relating to the probability distribution of a word or part thereof being related to an observation; 
         [0020]    adapting the model trained in the second environment to that of the first environment; 
         [0021]    the speech recognition method further comprising determining the likelihood of a sequence of observations occurring in a given language using a language model; 
         [0022]    combining the likelihoods determined by the acoustic model and the language model and outputting a sequence of words identified from said speech input signal, 
         [0023]    wherein adapting the model trained in the second environment to that of the first environment comprises: 
         [0024]    adapting the model parameters of the model trained in the second noise environment to those of the first noise environment using transform parameters to produce a target distribution, wherein the transform parameters have a block diagonal form and are applied to regression classes, each regression class comprising a plurality of probability distributions; 
         [0025]    mimicking the target distribution using a linear regression type distribution, said linear regression type distribution comprising mimicked transform parameters; and estimating the mimicked transformed parameters. 
         [0026]    In a preferred embodiment the model parameters of the model trained in the second noise environment are adapted to those of the first noise environment using a VTS-JUD compensation of the type: 
         [0000]        p ( y|m )= N ( y;B   (r     m     ) (μ x   (m)   −b   (r     m     ) ,diag( B   (r     m     ) (Σ x   (m) +Σ b   (r     m     ) ) B   (r     m     )     T   ))
 
         [0000]    wherein y is a feature vector for noisy speech, m is a component index indicating a probability distribution relating a word or part thereof to a feature vector, μ x   (m)  is the mean of the distribution m in the second noise environment and Σ x   (m)  the covariance matrix of the distribution m in the second noise environment, and 
         [0000]        A   (r     m     )   =B   (r     m     )     −1   =Σ x   (r     m     ) (Σ yx   (r     m     ) )− 1 ,
 
         [0000]        b   (r     m     ) =μ x   (r     m     )   −A   (r     m     ) μ y   (r     m     )  
 
         [0000]      Σ b   (r     m     )   =A   (r     m     ) Σ y   (r     m     )   A   (r     m     )     T   −Σ x   (r     m     )  
 
         [0000]    where μ x   (r     m     ) , μ y   (r     m     ) , Σ x   (r     m     ) , Σ y   (r     m     ) , Σ xy   (r     m     )  and Σ yx   (r     m     )  are mean, covariance and cross-covariances for the second noise environment and first noise environment respectively in each regression class 
         [0027]    VTS-JUD is able to employ block-diagonal JUD transformation to compensate HMM means. This gives good model compensation, but at the expense of poor efficiency compared to JUD. The use of the linear regression type distribution allows the transforms to be applied in feature space. Other types of distributions may also be used to mimic the target distribution with transforms which may be applied in feature space. 
         [0028]    In a further preferred embodiment, the linear regression type distribution is a PCMLLR type distribution of the form: 
         [0000]        p   c ( y|m )=| A   c   (r     m     )   |N ( A   c   (r     m     )   y+b   c   (r     m     ) ;μ x   (r     m     ) ,Σ x   (m) )
 
         [0000]    Where A c   (r     m     )  and b c   (r     m     )  are the PCMLLR transforms, y is the feature vector for noisy speech, m is a component index indicating a probability distribution relating a word or part thereof to a feature vector, μ x   (m)  is the mean of the distribution m in the second noise environment and Σ x   (m)  the covariance matrix of the distribution m in the second noise environment. 
         [0029]    As explained above, the PCMLLR framework allows the transforms to be applied in feature space. 
         [0030]    The mimicked transform parameters may be estimated by minimising the divergence between the linear regression type distribution and the target distribution. The divergence may be calculated as the Kullback-Leibler divergence. 
         [0031]    In a preferred embodiment, the target distribution comprises a mean and covariance, and said covariance in the target distribution is diagonalised when determining the mimicked transform parameters. 
         [0032]    For example, if the target distribution uses VTS-JUD which is mimicked using PCMLLR, the off diagonal terms in the covariance matrix are sensitive to approximation errors, therefore the diagonal form of the covariance is desirable. 
         [0033]    In a preferred embodiment, estimation of the mimicked transform parameters comprises separating calculations which need to be performed for all probability distributions from those which are regression class dependent and separately determining and caching the results from the calculations which need to be performed for all probability distributions. 
         [0034]    It may also be preferable to approximate the variance with an averaged variance as this is found to reduce the computation cost when calculating second order statistics for estimating PCMLLR transforms. 
         [0035]    Generally, the probability functions are Gaussians and the acoustic model is a Hidden Markov Model. 
         [0036]    In many situations the first environment is a noisy environment and the second environment is a noise free environment. However, it will be appreciated by those skilled in the art that the present invention can be used to adapt a model between any two environments with different noise levels. 
         [0037]    The method may be embodied in a system such that the system always applies the method without performing any test for noisiness of the environment. Alternatively, a noise test may be performed first to see if the noise conditions warrant the use of compensating the model as described above. 
         [0038]    The invention may be used as part of a speech translation system where the output of the above method is translated into a different language; and outputted said recognised speech in said different language. The outputting may comprise using a text to speech conversion method. 
         [0039]    Thus, in a second aspect, the present invention provides a speech translation method, comprising: 
         [0040]    recognising a speech input signal as described above 
         [0041]    translating said recognised speech into a different language; and 
         [0042]    outputting said recognised speech in said different language. 
         [0043]    Outputting said recognised speech may comprise using a text to speech conversion method. 
         [0044]    The present invention may also be used to adapt a model which has been trained in a second environment to operate in a first environment. 
         [0045]    Thus, in a third aspect, the present invention provides a method of adapting a speech recognition model between first and second noise environments, the method comprising: 
         [0046]    providing a model for performing speech recognition on a input signal which comprises a sequence of observations, wherein said model has been trained to recognise speech in a second noise environment, said model having a plurality of model parameters relating to the probability distribution of a word or part thereof being related to an observation; and 
         [0047]    adapting the model trained in the second environment to that of the first environment; 
         [0048]    wherein adapting the model parameters of the model trained in the second noise environment to those of the first noise environment using transform parameters to produce a target distribution, wherein the transform parameters have a block diagonal form and are applied to regression classes, each regression class comprising a plurality of probability distributions; 
         [0049]    mimicking the target distribution using a linear regression type distribution, said linear regression type distribution comprising mimicked transform parameters; 
         [0050]    and estimating the mimicked transformed parameters. 
         [0051]    The present invention also provides a training method for an acoustic model to be used in speech recognition. Therefore, in a fourth aspect, the present invention provides a method of training a speech recognition system in a noise environment, said speech recognition system comprising an acoustic model, said model having a plurality of model parameters relating the probability distribution of a word or part thereof being to an observation or utterance, said model parameters comprising canonical model parameters and mimicked transform parameters which relate the canonical model parameters to the noise environment of the model during training, said mimicked transform parameters being estimated from a linear regression type distribution which is used to mimic a target distribution relating the canonical model parameters to the model parameters in the noise environment, the transform parameters of said target distribution having a block diagonal form which are applied to regression classes, each regression class comprising a plurality of probability distributions; 
         [0052]    wherein training said model comprises: 
         [0053]    expressing the auxiliary function of an Expectation Maximisation algorithm in terms canonical model parameters and mimicked transform parameters; 
         [0054]    estimating mimicked transform parameters and canonical model parameters using a maximum likelihood method applied to said Expectation Maximisation algorithm. 
         [0055]    The above method may be performed in an adaptive or non-adaptive manner. When used in a non-adaptive manner, all training data is used in the same way. For adaptive training transforms are used to normalise the noise in each training utterance and then train an acoustic model. Therefore an adaptively trained model should be better as the noise is removed as training progresses. 
         [0056]    In a fifth aspect, the present invention provides a speech recognition system, comprising: 
         [0057]    a receiver for receiving a speech input in a first noise environment which comprises a sequence of observations; 
         [0058]    a processor configured to: 
         [0059]    determine the likelihood of a sequence of words arising from the sequence of observations using an acoustic model, comprising: 
         [0060]    provide an acoustic model for performing speech recognition on a input signal which comprises a sequence of observations, wherein said model has been trained to recognise speech in a second noise environment, said model having a plurality of model parameters relating to the probability distribution of a word or part thereof being related to an observation; 
         [0061]    adapt the model trained in the second environment to that of the first environment; 
         [0062]    determine the likelihood of a sequence of observations occurring in a given language using a language model; and 
         [0063]    combine the likelihoods determined by the acoustic model and the language model, 
         [0064]    the system further comprising an output configured to output a sequence of words identified from said speech input signal; 
         [0065]    wherein adapting the model trained in the second environment to that of the first environment comprises: 
         [0066]    adapting the model parameters of the model trained in the second noise environment to those of the first noise environment using transform parameters to produce a target distribution, wherein the transform parameters have a block diagonal form and are applied to regression classes, each regression class comprising a plurality of probability distributions; 
         [0067]    mimicking the target distribution using a linear regression type distribution, said linear regression type distribution comprising mimicked transform parameters; 
         [0068]    and estimating the mimicked transformed parameters. 
         [0069]    In a sixth aspect, the present invention provides a computer running a computer program configured to cause a computer to perform any of the above methods, 
         [0070]    The present invention can be implemented either in hardware or on software in a general purpose computer. Further the present invention can be implemented in a combination of hardware and software. The present invention can also be implemented by a single processing apparatus or a distributed network of processing apparatuses. 
         [0071]    Since the present invention can be implemented by software, the present invention encompasses computer code provided to a general purpose computer on any suitable carrier medium. The carrier medium can comprise any storage medium such as a floppy disk, a CD ROM, a magnetic device or a programmable memory device, or any transient medium such as any signal e.g. an electrical, optical or microwave signal. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0072]    The present invention will now described with reference to the following non-limiting embodiments in which: 
           [0073]      FIG. 1  is a schematic of a general speech recognition system; 
           [0074]      FIG. 2  is a schematic of the components of a speech recognition processor; 
           [0075]      FIG. 3  is a schematic of a Gaussian probability function; 
           [0076]      FIG. 4  is a schematic plot of acoustic space representing both probability density functions and an observation vector; 
           [0077]      FIG. 5  is a flow diagram showing a speech recognition method in accordance with an embodiment of the present invention; and 
           [0078]      FIG. 6  is a flow diagram showing a speech recognition method in accordance with a further embodiment of the present invention. 
       
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
       [0079]      FIG. 1  is a schematic of a very basic speech recognition system. A user (not shown) speaks into microphone  1  or other collection device for an audio system. The device  1  could be substituted by a memory which contains audio data previously recorded or the device  1  may be a network connection for receiving audio data from a remote location. 
         [0080]    The speech signal is then directed into a speech processor  3  which will be described in more detail with reference to  FIG. 2 . 
         [0081]    The speech processor  3  takes the speech signal and turns it into text corresponding to the speech signal. Many different forms of output are available. For example, the output may be in the form of a display  5  which outputs to a screen. Alternatively, the output could be directed to a printer or the like. Also, the output could be in the form of an electronic signal which is provided to a further system  9 . For example, the further system  9  could be part of a speech translation system which takes the outputted text from processor  3  and then converts it into a different language. The converted text is then outputted via a further text or speech system. 
         [0082]    Alternatively, the text outputted by the processor  3  could be used to operate different types of equipment, for example, it could be part of a mobile phone, car, etc. where the user controls various functions via speech. The output could be used in an in-car navigation system to direct the user to a named location. 
         [0083]      FIG. 2  is a block diagram of the standard components of a speech recognition processor  3  of the type shown in  FIG. 1 . The speech signal received from microphone, through a network or from a recording medium  1  is directed into front-end unit  11 . 
         [0084]    The front end unit  11  digitises the received speech signal and splits it into frames of equal lengths. The speech signals are then subjected to a spectral analysis to determine various parameters which are plotted in an “acoustic space of feature space”. The parameters which are derived will be discussed in more detail later. 
         [0085]    The front end unit  11  also removes signals which are believed not to be speech signals and other irrelevant information. Popular front end units comprise apparatus which use filter bank (F BANK) parameters, MelFrequency Cepstral Coefficients (MFCC) and Perceptual Linear Predictive (PLP) parameters. The output of the front end unit is in the form of an input vector which is in n-dimensional acoustic space. 
         [0086]    The input vector is then fed into a decoder  13  which cooperates with both an acoustic model section  15  and a language model section  17 . The acoustic model section  15  will generally operate using Hidden Markov Models. However, it is also possible to use acoustic models based on connectionist models and hybrid models. 
         [0087]    The acoustic model unit  15  derives the likelihood of a sequence of observations corresponding to a word or part thereof on the basis of the acoustic input alone. 
         [0088]    The language model section  17  contains information concerning probabilities of a certain sequence of words or parts of words following each other in a given language. Generally a static model is used. The most popular method is the N-gram model. 
         [0089]    The decoder  13  then traditionally uses a dynamic programming (DP) approach to find the best transcription for a given speech utterance using the results from the acoustic model  15  and the language model  17 . 
         [0090]    This is then output via the output device  19  which allows the text to be displayed, presented or converted for further use e.g. in speech to speech translation or to control a voice activated device. 
         [0091]    This description will be mainly concerned with the use of an acoustic model which is a Hidden Markov Model (HMM). However, it could also be used for other models. 
         [0092]    The actual model used in this embodiment is a standard model, the details of which are outside the scope of this patent application. However, the model will require the provision of probability density functions (pdfs) which relate to the probability of an observation represented by an acoustic vector (speech vector or feature vector) being related to a word or part thereof. Generally, this probability distribution will be a Gaussian distribution in n-dimensional space. 
         [0093]    A schematic example of a generic Gaussian distribution is shown in  FIG. 3 . Here, the horizontal axis corresponds to a parameter of the input vector in one dimension and the probability distribution is for a particular word or part thereof relating to the observation. For example, in  FIG. 3 , an observation corresponding to an acoustic vector x has a probability p 1  of corresponding to the word whose probability distribution is shown in  FIG. 3 . The shape and position of the Gaussian is defined by its mean and variance. These parameters are determined during training for the vocabulary which the acoustic model, they will be referred to as the “model parameters”. 
         [0094]    In a HMM, once the model parameters have been determined, the model can be used to determine the likelihood of a sequence of observations corresponding to a sequence of words or parts of words. 
         [0095]      FIG. 4  is schematic plot of acoustic space where an observation is represented by an observation vector or feature vector x 1 . The open circles g correspond to the means of Gaussians or other probability distribution functions plotted in acoustic space. 
         [0096]    During decoding, the acoustic model will calculate a number of different likelihoods that the feature vector x 1  corresponds to a word or part thereof represented by the Gaussians. These likelihoods are then used in the acoustic model and combined with probabilities from the language model to determine the text spoken. 
         [0097]    The acoustic model is generally trained under noise-free or so-called “clean” conditions. However, the error rate of the system will increase if the speech inputted into the system is then collected under noisier conditions. The front-end unit  11  described with reference to  FIG. 2  can remove some of the noise. However, some of it is so engrained into the inputted speech signal that it is impossible to remove at this early stage. 
         [0098]      FIG. 5  is a flow diagram of a method in accordance with an embodiment of the present invention for coping with a noisy input signal when using an acoustic model which has been trained under clean conditions. First, the noisy input signal is collected in S 51 . This has been explained with reference to  FIGS. 1 and 2 . 
         [0099]    An indication of the noise in this signal is then determined in step S 53 . A possible method of estimating the noise is to evaluate a part of the input signal where there is no speech. Often the first and last few frames are assumed to have no speech. Other methods may be used such as estimating noise in the signal without checking to see if the signal is voiced or non-voiced. 
         [0100]    In Step S 55  the model which has been trained under clean conditions is transformed using transform parameters to a noisy environment using, in this preferred embodiment, using a distribution which a combination of the known Vector Taylor Series (VTS) and the known Joint Uncertainty Decoding (JUD). 
         [0101]    In the classical Hidden Markov Model (HMM) based ASR, the core part is the calculation of the HMM state emission probability modelled by the GMM: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           p 
                            
                           
                             ( 
                             
                               x 
                                
                               S 
                             
                             ) 
                           
                         
                         = 
                         
                           
                             ∑ 
                             
                               m 
                               ∈ 
                               S 
                             
                             
                                 
                             
                           
                            
                           
                               
                           
                            
                           
                             
                               c 
                               m 
                             
                              
                             
                               p 
                                
                               
                                 ( 
                                 
                                   x 
                                    
                                   m 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             ∑ 
                             
                               m 
                               ∈ 
                               S 
                             
                             
                                 
                             
                           
                            
                           
                               
                           
                            
                           
                             
                               c 
                               m 
                             
                              
                             
                               N 
                               ( 
                               
                                 
                                   x 
                                   ; 
                                   
                                     μ 
                                     x 
                                     
                                       ( 
                                       m 
                                       ) 
                                     
                                   
                                 
                                 , 
                                 
                                   ∑ 
                                   x 
                                   
                                     ( 
                                     m 
                                     ) 
                                   
                                 
                               
                                
                               
                                   
                               
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where x is the clean speech feature, S is the HMM state, and N (x; μ x   (m) , Σ x   (m)  is the Gaussian PDF for the mixture m with mean μ x   (m) , covariance matrix Σ x   (m)  and mixture weight c m . 
         [0102]    When noise exists in the input speech, the clean speech feature x is not observable any more. Instead, the output probability of noisy speech feature y on the mixture m can be obtained as follows: 
         [0000]        p ( y|m )=∫ p ( y|x,m ) p ( x|m ) dx   (2)
 
         [0103]    For model based joint compensation, each HMM mixture m is often assigned to a fixed regression class rm and the joint distribution p(y, x|r m ) can be modelled by Gaussian distribution: 
         [0000]    
       
         
           
             
               
                 
                   
                     p 
                      
                     
                       ( 
                       
                         y 
                         , 
                         
                           x 
                            
                           
                             r 
                             m 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     N 
                      
                     
                       ( 
                       
                         
                           
                             [ 
                             
                               
                                 
                                   x 
                                 
                               
                               
                                 
                                   y 
                                 
                               
                             
                             ] 
                           
                           : 
                           
                             [ 
                             
                               
                                 
                                   
                                     μ 
                                     x 
                                     
                                       ( 
                                       
                                         r 
                                         m 
                                       
                                       ) 
                                     
                                   
                                 
                               
                               
                                 
                                   
                                     μ 
                                     y 
                                     
                                       ( 
                                       
                                         r 
                                         m 
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                             ] 
                           
                         
                         , 
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     ∑ 
                                     x 
                                     
                                       ( 
                                       
                                         r 
                                         m 
                                       
                                       ) 
                                     
                                   
                                    
                                   
                                       
                                   
                                 
                               
                               
                                 
                                   ∑ 
                                   yx 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                               
                             
                             
                               
                                 
                                   ∑ 
                                   xy 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                               
                               
                                 
                                   ∑ 
                                   y 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0104]    Where μ x   (r     m     ) , μ y   (r     m     ) , Σ x   (r     m     ) , Σ y   (r     m     ) , Σ xy   (r     m     )  and Σ yx   (r     m     )  are mean, covariance and cross-covariances for clean and noisy speech in each regression class, and Σ x   (r     m     )  is normally assumed to be diagonal. 
         [0105]    Therefore, Eq. (2) becomes 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           p 
                            
                           
                             ( 
                             
                               y 
                                
                               m 
                             
                             ) 
                           
                         
                         ≈ 
                           
                          
                         
                           ∫ 
                           
                             
                               p 
                                
                               
                                 ( 
                                 
                                   
                                     y 
                                      
                                     x 
                                   
                                   , 
                                   
                                     r 
                                     m 
                                   
                                 
                                 ) 
                               
                             
                              
                             
                               p 
                                
                               
                                 ( 
                                 
                                   x 
                                    
                                   m 
                                 
                                 ) 
                               
                             
                              
                             
                                
                               x 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                            
                           ( 
                           
                             
                               y 
                               ; 
                               
                                 
                                   B 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       μ 
                                       x 
                                       
                                         ( 
                                         m 
                                         ) 
                                       
                                     
                                     - 
                                     
                                       b 
                                       
                                         ( 
                                         
                                           r 
                                           m 
                                         
                                         ) 
                                       
                                     
                                   
                                   ) 
                                 
                               
                             
                             , 
                             
                               
                                 
                                   B 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                                 ( 
                                 
                                   
                                     ∑ 
                                     x 
                                     
                                       ( 
                                       m 
                                       ) 
                                     
                                   
                                    
                                   
                                       
                                   
                                    
                                   
                                     + 
                                     
                                       ∑ 
                                       b 
                                       
                                         ( 
                                         
                                           r 
                                           m 
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                  
                                 
                                     
                                 
                                 ) 
                               
                                
                               
                                 B 
                                 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                    
                                   T 
                                 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
             
               
                 
                   = 
                   
                      
                     
                       
                         A 
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                       
                        
                       
                          
                         ( 
                         
                           
                             
                               
                                 
                                   A 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                                  
                                 y 
                               
                               + 
                               
                                 b 
                                 
                                   ( 
                                   
                                     r 
                                     m 
                                   
                                   ) 
                                 
                               
                             
                             ; 
                             
                               μ 
                               x 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                           
                           , 
                           
                             
                               ∑ 
                               x 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                              
                             
                                 
                             
                              
                             
                               + 
                               
                                 ∑ 
                                 b 
                                 
                                   ( 
                                   
                                     r 
                                     m 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                          
                         
                             
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0106]    And the transforms are obtained as 
         [0000]        A   (r     m     )   B   (r     m     )     −1   =Σ x   (r     m     ) (Σ yx   (r     m     ) ) −1 ,
 
         [0000]        b   (r     m     ) =μ x   (r     m     )   −A   (r     m     ) μ y   (r     m     )  
 
         [0000]      Σ b   (r     m     )   =A   (r     m     ) Σ y   (r     m     )   A   (r     m     )     T   −Σ x   (r     m     )   (6)
 
         [0107]    Both Eq. (4) and Eq. (5) can be used for HMM adaptation. Applying all the transformations on HMM parameters, Eq. (4) has to conduct the compensation mixture by mixture, making it very slow especially when the size of HMM is big. As a contrast, Eq. (5) is much more efficient because most of the transformations happen on feature vectors. 
         [0108]    There are several ways to obtain μ y   (r     m     ) , Σ y   (r     m     )  and Σ yx   (r     m     ) . One of the most efficient is the first order Taylor expansion which linearly approximates the relationship between clean and noisy speech on their static parts: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       y 
                       s 
                     
                     = 
                     
                       
                         μ 
                         xs 
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                       
                       + 
                       
                         g 
                          
                         
                           ( 
                           
                             
                               μ 
                               xs 
                               
                                 ( 
                                 
                                   r 
                                   m 
                                 
                                 ) 
                               
                             
                             , 
                             
                               μ 
                               ns 
                             
                             , 
                             
                               μ 
                               hs 
                             
                           
                           ) 
                         
                       
                       + 
                       
                         W 
                          
                         
                           ( 
                           
                             
                               x 
                               s 
                             
                             - 
                             
                               μ 
                               xs 
                               
                                 ( 
                                 
                                   r 
                                   m 
                                 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                       + 
                       
                         
                           ( 
                           
                             I 
                             - 
                             W 
                           
                           ) 
                         
                          
                         
                           ( 
                           
                             
                               n 
                               s 
                             
                             - 
                             
                               μ 
                               ns 
                             
                           
                           ) 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                       
                   
                    
                   
                     W 
                     = 
                     
                       
                         
                           
                              
                             
                               y 
                               s 
                             
                           
                           
                              
                             
                               x 
                               s 
                             
                           
                         
                          
                         
                            
                           
                             
                               
                                 x 
                                 s 
                               
                               = 
                               
                                 μ 
                                 xs 
                                 
                                   ( 
                                   
                                     r 
                                     m 
                                   
                                   ) 
                                 
                               
                             
                             , 
                             
                               n 
                               = 
                               
                                 μ 
                                 ns 
                               
                             
                           
                         
                          
                         
                           
 
                         
                          
                         
                             
                         
                          
                         
                           g 
                            
                           
                             ( 
                             
                               
                                 μ 
                                 xs 
                                 
                                   ( 
                                   
                                     r 
                                     m 
                                   
                                   ) 
                                 
                               
                               , 
                               
                                 μ 
                                 ns 
                               
                               , 
                               
                                 μ 
                                 hs 
                               
                             
                             ) 
                           
                         
                       
                       = 
                       
                         h 
                         + 
                         
                           C 
                            
                           
                               
                           
                            
                           
                             ln 
                             ( 
                             
                               I 
                               + 
                               
                                  
                                 
                                   
                                     C 
                                     
                                       - 
                                       1 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         μ 
                                         ns 
                                       
                                       - 
                                       
                                         μ 
                                         hs 
                                       
                                       - 
                                       
                                         μ 
                                         xs 
                                         
                                           ( 
                                           
                                             r 
                                             m 
                                           
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0000]    and n denotes additive noise, h convolutional noise, s for the static part, μ ns  the static mean of noise, I the identity matrix and C the discrete cosine transformation matrix. 
         [0109]    The noise varies from frame to frame during the collection of the speech signal. However, from the frames noted above, it is possible to estimate the mean of the additive noise, the variance of the additive noise, the mean of the convolutional noise and the variance of the convolutional noise. Generally, it is assumed that the convolutional noise is constant over each utterance and therefore its variance is assumed to be 0. 
         [0110]    It is also possible to estimate the delta and delta-delta terms of the mean and variance of the noise. The delta term is the first derivative with respect to time of the mean or variance and the delta-delta term is the second derivative with respect to time of the mean or variance. 
         [0111]    From Eq. 7; 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∑ 
                       y 
                       
                         ( 
                         
                           r 
                           m 
                         
                         ) 
                       
                     
                      
                     
                         
                     
                      
                     
                       = 
                       
                         
                           K 
                            
                           
                             
                               ∑ 
                               x 
                               
                                 ( 
                                 
                                   r 
                                   m 
                                 
                                 ) 
                               
                             
                              
                             
                                 
                             
                              
                             
                               K 
                               T 
                             
                           
                         
                         + 
                         
                           
                             ( 
                             
                               I 
                               - 
                               K 
                             
                             ) 
                           
                            
                           
                             
                               ∑ 
                               n 
                               
                                   
                               
                             
                              
                             
                                 
                             
                              
                             
                               
                                 ( 
                                 
                                   I 
                                   - 
                                   K 
                                 
                                 ) 
                               
                               T 
                             
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       ∑ 
                       yx 
                       
                         ( 
                         
                           r 
                           m 
                         
                         ) 
                       
                     
                      
                     
                       = 
                       
                         K 
                          
                         
                           ∑ 
                           x 
                           
                             ( 
                             
                               r 
                               m 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
             
               
                 
                   K 
                   = 
                   
                     ( 
                     
                       
                         
                           W 
                         
                         
                           0 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           W 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           W 
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0112]    As W is normally a full matrix, it is clear that both Σ y   (r     m     )  and Σ yx   (r     m     ) . have a block diagonal structure. According to Eq. (6), this results in A (r     m     )  and Σ h   (r     m     )  being block diagonal. 
         [0113]    Though providing good compensation for HMM, the block diagonal structure makes the adapted covariance matrices in Eq. (4) and Eq. (5) also block diagonal and the computational cost for decoding becomes extremely high. Diagonalising Σ h   (r     m     )  is able to make the covariance in Eq. (5) diagonal. This however does not work properly as it causes problems for the diagonal components in the covariance matrices of y. In practice, this problem can be solved by JUD or VTS-JUD of the preferred embodiment. 
         [0114]    Joint Uncertainty Decoding (JUD), Equation (5) is used and the covariance terms Σ y   (r     m     ) , Σ xy   (r     m     )  and Σ xy   (r     m     )  in the joint distribution are diagonalised. According to Eq. (6), this leads to a diagonal A (r     m     )  and diagonal Σ h   (r     m     )  in which the i th  elements are obtained as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       a 
                       i 
                       
                         ( 
                         
                           r 
                           m 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         σ 
                         
                           x 
                           , 
                           i 
                         
                         
                           
                             ( 
                             
                               r 
                               m 
                             
                             ) 
                           
                           2 
                         
                       
                       
                         σ 
                         
                           yx 
                           , 
                           i 
                         
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                    
                   
                     
                       σ 
                       
                         b 
                         , 
                         i 
                       
                       
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                         2 
                       
                     
                     = 
                     
                       
                         
                           a 
                           i 
                           
                             
                               ( 
                               
                                 r 
                                 m 
                               
                               ) 
                             
                             2 
                           
                         
                          
                         
                           σ 
                           
                             y 
                             , 
                             i 
                           
                           
                             
                               ( 
                               
                                 r 
                                 m 
                               
                               ) 
                             
                             2 
                           
                         
                       
                       - 
                       
                         σ 
                         
                           x 
                           , 
                           i 
                         
                         
                           
                             ( 
                             
                               r 
                               m 
                             
                             ) 
                           
                           2 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where σ x,i   (r     m     )     2   , σ y,i   (r     m     )     2    σ yx,i   (r     m     )  are the i th  diagonal element in Σ y   (r     m     ) , Σ xy   (r     m     )  and Σ yx   (r     m     ) , respectively. 
         [0115]    Then the compensation for JUD is fulfilled for each feature dimension independently: 
         [0000]    
       
         
           
             
               
                 
                   
                     p 
                      
                     
                       ( 
                       
                         y 
                          
                         m 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∏ 
                       i 
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                        
                       
                         
                           a 
                           i 
                           
                             ( 
                             
                               r 
                               m 
                             
                             ) 
                           
                         
                          
                         
                            
                            
                           
                             ( 
                             
                               
                                 
                                   
                                     
                                       
                                         
                                           a 
                                           i 
                                           
                                             ( 
                                             
                                               r 
                                               m 
                                             
                                             ) 
                                           
                                         
                                          
                                         
                                           ( 
                                           
                                             
                                               y 
                                               i 
                                             
                                             - 
                                             
                                               μ 
                                               
                                                 y 
                                                 , 
                                                 i 
                                               
                                               
                                                 ( 
                                                 
                                                   r 
                                                   m 
                                                 
                                                 ) 
                                               
                                             
                                           
                                           ) 
                                         
                                       
                                       + 
                                       
                                         μ 
                                         
                                           x 
                                           , 
                                           i 
                                         
                                         
                                           ( 
                                           
                                             r 
                                             m 
                                           
                                           ) 
                                         
                                       
                                     
                                     ; 
                                   
                                 
                               
                               
                                 
                                   
                                     
                                       μ 
                                       
                                         x 
                                         , 
                                         i 
                                       
                                       
                                         ( 
                                         m 
                                         ) 
                                       
                                     
                                     , 
                                     
                                       
                                         σ 
                                         
                                           x 
                                           , 
                                           i 
                                         
                                         
                                           
                                             ( 
                                             m 
                                             ) 
                                           
                                           2 
                                         
                                       
                                       + 
                                       
                                         σ 
                                         
                                           b 
                                           , 
                                           i 
                                         
                                         
                                           
                                             ( 
                                             
                                               r 
                                               m 
                                             
                                             ) 
                                           
                                           2 
                                         
                                       
                                     
                                   
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0116]    Clearly, compensation with JUD is highly efficient because it is based on the efficient form of Eq. (5) and only requires simple computation with scalars on each dimension. The diagonal A (r     m     )  however has negative impact on recognition performance as it gives poor compensation on HMM, especially on the mean vectors. 
         [0117]    In accordance with an embodiment of the present invention, the compensation is performed using a new adaptation formula Vector Taylor Series—Joint Uncertainty Decoding (VTS-JUD). VTS-JUD is employed to handle the problem of block-diagonal covariances. Different from JUD, VTS-JUD compensates HMM based on Eq. (4) and diagonalises the final adapted HMM: 
         [0000]        p ( y|m )= N ( y:B   (r     m     ) (μ x   (m)   −b   (r     m     ) ),diag( B ( B   (r     m     ) (Σ x   (m) +Σ b   (r     m     ) ) B   (r     m     )     T   ))  (12)
 
         [0118]    As B (r     m     )  is block diagonal, VTS-JUD gives good compensation on HMM means and the adapted covariance part is diagonalised, making the decoding process efficient. The drawback of VTS-JUD is that it has to adapt HMM mixture by mixture. This makes the adaptation less efficient compared to JUD. 
         [0119]    Both JUD and the new VTS-JUD are linked to the known Vector Taylor Series (VTS). 
         [0120]    VTS is a powerful method for model compensation. It works as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           p 
                            
                           
                             ( 
                             
                               y 
                                
                               m 
                             
                             ) 
                           
                         
                         = 
                         
                           N 
                           ( 
                           
                             
                               y 
                               ; 
                               
                                 μ 
                                 y 
                                 
                                   ( 
                                   m 
                                   ) 
                                 
                               
                             
                             , 
                             
                               diag 
                               ( 
                               
                                 ∑ 
                                 y 
                                 
                                   ( 
                                   m 
                                   ) 
                                 
                               
                                
                               
                                   
                               
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                            
                            
                           
                             ( 
                             
                               
                                 y 
                                 ; 
                                 
                                   
                                     B 
                                     
                                       ( 
                                       m 
                                       ) 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         μ 
                                         x 
                                         
                                           ( 
                                           m 
                                           ) 
                                         
                                       
                                       - 
                                       
                                         b 
                                         
                                           ( 
                                           m 
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                 
                               
                               , 
                               
                                 diag 
                                  
                                 
                                   ( 
                                   
                                     
                                       B 
                                       
                                         ( 
                                         m 
                                         ) 
                                       
                                     
                                      
                                     
                                       
                                         ∑ 
                                         x 
                                         
                                           ( 
                                           m 
                                           ) 
                                         
                                       
                                        
                                       
                                           
                                       
                                        
                                       
                                         B 
                                         
                                           
                                             ( 
                                             m 
                                             ) 
                                           
                                            
                                           T 
                                         
                                       
                                     
                                   
                                   ) 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0121]    Where μ y   (m)  and Σ y   (m)  are obtained from the first order Taylor expansion in Eq. (7). Thus, the first order Taylor expansion has to be performed on each mixture m to determine B (r     m     )  and the HMM needs to be adapted mixture by mixture. This impacts on the efficiency of this method. Using both equations (4) and (6) JUD and VTS-JUD can be reformulated as: 
         [0000]        p ( y|m )= N ( y:B   (r     m     ) (μ x   (m) −μ x   (r     m     ) )+μ y   (r     m     ) ,diag( B   (r     m     ) (Σ x   (m) −Σ x   (r     m     ) ) B   (r     m     )     T   +Σ y   (r     m     ) ))  (14)
 
         [0000]    where B (r     m     )  is diagonal for JUD and block-diagonal for VTS-JUD. 
         [0122]    From Eq. (14), VTS-JUD and JUD are actually the same except for the different structure employed for B (r     m     ) . When the number of regression classes equals to the number of mixtures, i.e. r m =m, B (r     m     )  is cancelled out and Eq. (14) becomes Eq. (13). In this case, VTS-JUD is the same as JUD and both techniques converge to VTS. Thus, VTS can be looked as a special case for JUD and VTS-JUD. In the normal case where the number of regression classes is much smaller than the number of mixtures, the three techniques are drifting away and behave differently. VTS-JUD and JUD only calculates transforms on each regression classes, making them much more efficient than VTS. JUD places emphasis on efficiency by using diagonal transforms, which results in the degradation of recognition performance. 
         [0123]    The VTS-JUD method in accordance with a preferred embodiment is more similar to VTS as they both apply block-diagonal transforms and require to compensate HMM mixture by mixture. Thus, VTS-JUD is expected to have a similar recognition performance as VTS but poorer efficiency compared to JUD. 
         [0124]    To address the efficiency issue the VTS-JUD distribution is mimicked by a further distribution in step S 57 . In this embodiment, the further distribution is provided by Predictive Constrained Maximum Likelihood Linear Regression (PCMLLR). This drawback is addressed by PCMLLR 
         [0125]    CMLLR [7] has been a popular method for model adaptation: 
         [0000]        p   c ( y|m )=| A   c   (r     m     )   |N ( A   c   (r     m     )   y+b   c   (r     m     ) ;μ x   (m) ,Σ x   (m) )  (15)
 
         [0126]    CMLLR transforms are usually estimated by maximising the likelihood on test utterance using standard expectation maximisation (EM) algorithm. Eq. (15) is very efficient for model compensation because all the transforms are on feature vectors. 
         [0127]    PCMLLR also uses Eq. (15) for adaptation. However it tries to find the right CMLLR transforms which make the CMLLR distribution best mimic the target distribution. The optimal transforms A c   (r     m     )  and b c   (r     m     )  are obtained by minimising the Kullback-Leibler divergence between the CMLLR distribution defined in Eq. (15) and the target distribution {tilde over (p)}(y|m) which is to be mimicked: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           ( 
                           
                             
                               A 
                               c 
                               
                                 ( 
                                 
                                   r 
                                   m 
                                 
                                 ) 
                               
                             
                             , 
                             
                               b 
                               c 
                               
                                 ( 
                                 
                                   r 
                                   m 
                                 
                                 ) 
                               
                             
                           
                           ) 
                         
                         = 
                           
                          
                         
                           arg 
                            
                           
                             
                               min 
                               
                                 
                                   A 
                                   c 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                                 , 
                                 
                                   b 
                                   c 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                               
                             
                              
                             
                               
                                 ∑ 
                                 
                                   m 
                                   ∈ 
                                   
                                     r 
                                     m 
                                   
                                 
                                 
                                     
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   P 
                                    
                                   
                                     ( 
                                     m 
                                     ) 
                                   
                                 
                                  
                                 
                                   ∫ 
                                   
                                     
                                       
                                         p 
                                         ~ 
                                       
                                        
                                       
                                         ( 
                                         
                                           y 
                                            
                                           m 
                                         
                                         ) 
                                       
                                     
                                      
                                     log 
                                      
                                     
                                       
                                         
                                           p 
                                           ~ 
                                         
                                          
                                         
                                           ( 
                                           
                                             y 
                                              
                                             m 
                                           
                                           ) 
                                         
                                       
                                       
                                         
                                           p 
                                           c 
                                         
                                          
                                         
                                           ( 
                                           
                                             y 
                                              
                                             m 
                                           
                                           ) 
                                         
                                       
                                     
                                      
                                     
                                        
                                       y 
                                     
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           arg 
                            
                           
                             
                               max 
                               
                                 
                                   A 
                                   c 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                                 , 
                                 
                                   b 
                                   c 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                               
                             
                              
                             
                               
                                 ∑ 
                                 
                                   m 
                                   ∈ 
                                   
                                     r 
                                     m 
                                   
                                 
                                 
                                     
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   P 
                                    
                                   
                                     ( 
                                     m 
                                     ) 
                                   
                                 
                                  
                                 
                                   ∫ 
                                   
                                     
                                       
                                         p 
                                         ~ 
                                       
                                        
                                       
                                         ( 
                                         
                                           y 
                                            
                                           m 
                                         
                                         ) 
                                       
                                     
                                      
                                     log 
                                      
                                     
                                         
                                     
                                      
                                     
                                       
                                         p 
                                         c 
                                       
                                        
                                       
                                         ( 
                                         
                                           y 
                                            
                                           m 
                                         
                                         ) 
                                       
                                     
                                      
                                     
                                        
                                       y 
                                     
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
         [0128]    Solving the above formulae, PCMLLR transformations have similar format as CMLLR: the i th  row in PCMLLR transforms is a function of the stats G i   (r     m     )  and k i   (r     m     ) . 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       G 
                       i 
                       
                         ( 
                         
                           r 
                           m 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           m 
                           ∈ 
                           
                             r 
                             m 
                           
                         
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           
                             γ 
                             
                               ( 
                               m 
                               ) 
                             
                           
                           
                             σ 
                             i 
                             
                               
                                 ( 
                                 m 
                                 ) 
                               
                               2 
                             
                           
                         
                          
                         
                           ( 
                           
                             
                               
                                 1 
                               
                               
                                 
                                   ɛ 
                                    
                                   
                                     { 
                                     
                                       
                                         y 
                                         T 
                                       
                                        
                                       m 
                                     
                                     } 
                                   
                                 
                               
                             
                             
                               
                                 
                                   ɛ 
                                    
                                   
                                     { 
                                     
                                       y 
                                        
                                       m 
                                     
                                     } 
                                   
                                 
                               
                               
                                 
                                   ɛ 
                                    
                                   
                                     { 
                                     
                                       
                                         yy 
                                         T 
                                       
                                        
                                       m 
                                     
                                     } 
                                   
                                 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       k 
                       i 
                       
                         ( 
                         
                           r 
                           m 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           m 
                           ∈ 
                           
                             r 
                             m 
                           
                         
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           
                             
                               γ 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                              
                             
                               μ 
                               i 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                           
                           
                             σ 
                             i 
                             
                               
                                 ( 
                                 m 
                                 ) 
                               
                               2 
                             
                           
                         
                          
                         
                           ( 
                           
                             
                               
                                 1 
                               
                               
                                 
                                   ɛ 
                                    
                                   
                                     { 
                                     
                                       
                                         y 
                                         T 
                                       
                                        
                                       m 
                                     
                                     } 
                                   
                                 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where the expectations are estimated from the target distribution {tilde over (p)}(y) and γ (m)  is the mixture occupation obtained from training. The stats G i   (r     m     )  and k i   (r     m     )  are known in CMLLR methods, see for example M. J. F. Gales, “Maximum Likelihood Linear transforms for HMM based Speech recognition” Computer Speech and Language, vol. 12 January (1998) section 2.2. 
         [0129]    Ideally, the target distribution should be the true distribution of y which is assumed to be Gaussian with mean {tilde over (μ)} y   (m)  and full covariance {tilde over (Σ)} y   (m)  and expectations ε in Eq. (17) are obtained as 
         [0000]      ε{ y|m}={tilde over (μ)}   y   (m)   ·ε{yy   T   |m}={tilde over (Σ)}   y   (m) +{tilde over (μ)} y   (m) {tilde over (μ)} y   (m)     T     (18)
 
         [0130]    Since true distribution of y is not available, in this embodiment VTS-JUD distribution is used due to its ability to apply block-diagonal transforms. Then the expectations in the statistics are obtained as: 
         [0000]      ε{ y|m}=B   (r     m     ) (μ x   (m)   −b   (r     m     ) )
 
         [0000]      ε{ yy   T   |m }=diag{ B   (r     m     ) (Σ x   (m) +Σ b   (r     m     ) ) B   (r     m     )     T     }+ε{y|m}ε{y   T   |m}   (19)
 
         [0131]    In Eq. (19), there is an option not to diagonalise the covariance part and use the block-diagonal covariance directly. This gives: 
         [0000]      ε{yy T   |m}=B   (r     m     ) (Σ x   (m) +Σ b   (r     m     ) ) B   (r     m     )     T     +ε{y|m}ε{y   T   |m}   (20)
 
         [0132]    As the full covariance {tilde over (Σ)} y   (m)  in the true distribution should ideally be used, the two forms in Eq. (19) and Eq. (20) give different approximations to the true statistics. Block-diagonal covariance in Eq. (20) has a structure closer to the full covariance. However, previous work suggests that the off-diagonal terms in the VIS adapted covariance are very sensitive to approximation errors. Since this also applies to VTS-JUD, using the block-diagonal covariance to approximate is not reliable. Instead, in the preferred embodiment, the diagonal covariance is used in Eq. (19) in order to give robust approximation to {tilde over (Σ)} y   (m) . 
         [0133]    The approximation errors are different dependent on whether VTS-JUD or VTS-JUD based PCMLLR is used. For VTS-JUD, the diagonal covariance is used for decoding as the covariance of HMM and the approximation errors directly influence the likelihood calculation. As a contrast, VTS-JUD based PCMLLR uses the diagonal covariance only for calculating the mean square of y. As the mean square also depends on ε{y|m}ε{y T |m} which sometimes dominates the off-diagonal terms, the approximation errors are expected to have much smaller impact on the final PCMLLR transforms A c   (r     m     )  and b c   (r     m     ) . Therefore VTS-JUD based PCMLLR are less sensitive to the approximation errors and can potentially bring better performance than VTS-JUD. 
         [0134]    For the sake of efficiency, the key part of the statistics is reformulated. For example, one of the statistics for G i   (r     m     )  can be changed to 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∑ 
                       
                         m 
                         ∈ 
                         
                           r 
                           m 
                         
                       
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         
                           γ 
                           
                             ( 
                             m 
                             ) 
                           
                         
                         
                           σ 
                           i 
                           
                             
                               ( 
                               m 
                               ) 
                             
                             2 
                           
                         
                       
                        
                       ɛ 
                        
                       
                         { 
                         
                           y 
                            
                           m 
                         
                         } 
                       
                     
                   
                   = 
                   
                     
                       
                         B 
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                       
                        
                       
                         β 
                         i 
                       
                     
                     - 
                     
                       
                         B 
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                       
                        
                       
                         b 
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                       
                        
                       
                         α 
                         i 
                       
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
             
               
                 
                   
                     α 
                     i 
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           m 
                           ∈ 
                           
                             r 
                             m 
                           
                         
                         
                             
                         
                       
                        
                       
                         
                           ( 
                           
                             
                               γ 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                             
                               σ 
                               i 
                               
                                 
                                   ( 
                                   m 
                                   ) 
                                 
                                 2 
                               
                             
                           
                           ) 
                         
                         · 
                         
                           B 
                           i 
                         
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           m 
                           ∈ 
                           
                             r 
                             m 
                           
                         
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         ( 
                         
                           
                             
                               γ 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                             
                               σ 
                               i 
                               
                                 
                                   ( 
                                   m 
                                   ) 
                                 
                                 2 
                               
                             
                           
                            
                           
                             μ 
                             x 
                             
                               ( 
                               m 
                               ) 
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
         [0135]    Obviously, α i  and β i  only need to be computed once in the beginning and cached. Then the statistics of PCMLLR can be efficiently obtained because transformations e.g. B (r     m     ) β i  only need to be applied once for each regression class. One exception for this is in the calculation of the second order statistics in G i   (r     m     ) . This requires the computation of B (r     m     ) Ω i B (r     m     )     T     
         [0000]    
       
         
           
             
               
                 
                   
                     Ω 
                     i 
                   
                   = 
                   
                     
                       ∑ 
                       
                         m 
                         ∈ 
                         
                           r 
                           m 
                         
                       
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       ( 
                       
                         
                           
                             γ 
                             
                               ( 
                               m 
                               ) 
                             
                           
                           
                             σ 
                             i 
                             
                               
                                 ( 
                                 m 
                                 ) 
                               
                               2 
                             
                           
                         
                          
                         
                           μ 
                           x 
                           
                             ( 
                             m 
                             ) 
                           
                         
                          
                         
                           μ 
                           x 
                           
                             
                               ( 
                               m 
                               ) 
                             
                             T 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
         [0136]    As Ω i  is full and this part needs to be calculated for each regression class and each dimension. Assuming there are R regression classes and n dimension in the feature vector, the cost for this part is O(Rn 4 ). An approximation can be made on this part by replacing σ i   (m)     2    with the averaged variance, i.e.: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         σ 
                         i 
                         
                           
                             ( 
                             m 
                             ) 
                           
                           2 
                         
                       
                       ≈ 
                       
                         
                           σ 
                           _ 
                         
                         i 
                         2 
                       
                     
                     = 
                     
                       
                         
                           ∑ 
                           
                             m 
                             ∈ 
                             
                               r 
                               m 
                             
                           
                           
                               
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             γ 
                             
                               ( 
                               m 
                               ) 
                             
                           
                            
                           
                             σ 
                             i 
                             
                               
                                 ( 
                                 m 
                                 ) 
                               
                               2 
                             
                           
                         
                       
                       
                         
                           ∑ 
                           
                             m 
                             ∈ 
                             
                               r 
                               m 
                             
                           
                           
                               
                           
                         
                          
                         
                             
                         
                          
                         
                           γ 
                           
                             ( 
                             m 
                             ) 
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   Then 
                 
               
               
                 
                   ( 
                   24 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       B 
                       
                         ( 
                         
                           r 
                           m 
                         
                         ) 
                       
                     
                      
                     
                       Ω 
                       i 
                     
                      
                     
                       B 
                       
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                         T 
                       
                     
                   
                   ≈ 
                   
                     
                       
                         B 
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                       
                       ( 
                       
                         
                           ∑ 
                           
                             m 
                             ∈ 
                             
                               r 
                               m 
                             
                           
                           
                               
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             γ 
                             
                               ( 
                               m 
                               ) 
                             
                           
                            
                           
                             μ 
                             x 
                             
                               ( 
                               m 
                               ) 
                             
                           
                            
                           
                             μ 
                             x 
                             
                               
                                 ( 
                                 m 
                                 ) 
                               
                               T 
                             
                           
                         
                       
                       ) 
                     
                      
                     
                       B 
                       
                         
                           ( 
                           
                             r 
                             m 
                           
                           ) 
                         
                         T 
                       
                     
                   
                 
               
               
                 
                   ( 
                   25 
                   ) 
                 
               
             
           
         
       
     
         [0137]    The computational cost for this part is then now reduced to O(Rn 3 ) because the matrix multiplication is only required once for each regression class. The overall cost is listed in table I. 
         [0000]    
       
         
               
               
               
               
             
           
               
                 TABLE 1 
               
               
                   
               
               
                 Method 
                 Statistics 
                 Transform Estimation 
                 Compensation 
               
               
                   
               
             
             
               
                 VTS 
                 — 
                 O(Mn 3 ) 
                 O(Mn 3  + Mn) 
               
               
                 JUD 
                 — 
                 O(Rn 3 ) 
                 O(RTn + Mn) 
               
               
                 VTS-JUD 
                 — 
                 O(Rn 3 ) 
                 O(Mn 3  + Mn 2 ) 
               
               
                 PCMLLR 
                 O(Rn 4 ) 
                 O(R(In 3  + n 4  + n 2 )) 
                 O(RTn 2 ) 
               
               
                 PCMLLR (approx.) 
                 O(Rn 3 ) 
                 O(R(In 3  + n 4  + n 2 )) 
                 O(RTn 2 ) 
               
               
                   
               
             
          
         
       
     
         [0138]    It is observed the cost of VTS-JUD based PCMLLR is independent of the HMM size M. As normally M&gt;&gt;R, VTS-JUD based PCMLLR is expected to be more efficient than others. 
         [0139]    Once the transform parameters have been estimated as above, the HMM can then be used with the modified parameters in step S  61  and the identified words may be output in step S 63 . 
         [0140]    In summary, the basic steps may be followed: 
         [0141]    1. The m-dependent terms e.g. 
         [0000]    
       
         
           
             
               ∑ 
               
                 m 
                 ∈ 
                 r 
               
               
                   
               
             
              
             
                 
             
              
             
               
                 
                   γ 
                   m 
                 
                 
                   σ 
                   
                     m 
                     , 
                     i 
                   
                   2 
                 
               
                
               
                   
               
                
               and 
                
               
                   
               
                
               
                 
                   ∑ 
                   
                     m 
                     ∈ 
                     r 
                   
                   
                       
                   
                 
                  
                 
                     
                 
                  
                 
                   
                     
                       γ 
                       m 
                     
                     
                       σ 
                       
                         m 
                         , 
                         i 
                       
                       2 
                     
                   
                    
                   
                     μ 
                     m 
                   
                 
               
             
           
         
       
     
         [0000]    may be calculated and cached first—this only needs to be performed once. 
         [0142]    2. Perform noise estimation and VTS-JUD transforms (A r , b r , Σ b   r ) 
         [0143]    3. Calculate statistics G i   (r     m     )  and k i   (r     m     ) . As per equation (17) and 
         [0144]    4, Estimate PCMLLR transforms A c   (r     m     )  and b c   (r     m     )  and compensate model using equation (15). 
         [0145]      FIG. 6  is a flow chart of a method in accordance with a further embodiment of the present invention. Here the method uses adaptive training. 
         [0146]    Adaptive training has been widely used for speech recognition, especially for normalising speaker difference in training database. The HMM trained through adaptive training is called canonical model which has proven to give better acoustic modelling than the classical ML trained HMM. 
         [0147]    The idea of adaptive training can be easily applied for normalising noise differences in training database. This can be achieved either by feature-based techniques or by model-based joint compensation techniques. It is generally accepted that model based compensation is more powerful than feature based compensation. Therefore model based adaptive training is expected to perform better than feature based adaptive training. In previous model based training techniques, JUD based adaptive training (JAT), is introduced. It uses Eq. (5) for compensation and then finds the optimal HMM parameters {circumflex over (M)}=({circumflex over (μ)} x   (m) ,{circumflex over (Σ)} x   (m) ) by maximising the EM auxiliary function: 
         [0000]    
       
         
           
             
               
                 
                   
                     Q 
                      
                     
                       ( 
                       
                         
                           M 
                           ^ 
                         
                         · 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         m 
                         , 
                         s 
                         , 
                         t 
                       
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         γ 
                         t 
                         
                           ( 
                           
                             m 
                             , 
                             s 
                           
                           ) 
                         
                       
                        
                       ln 
                        
                       
                          
                         
                           A 
                           
                             ( 
                             
                               r 
                               m 
                             
                             ) 
                           
                         
                          
                       
                        
                       
                         N 
                         ( 
                         
                           
                             
                               A 
                               
                                 ( 
                                 
                                   r 
                                   m 
                                 
                                 ) 
                               
                             
                              
                             y 
                           
                           , 
                           
                             
                               + 
                               
                                 b 
                                 
                                   ( 
                                   
                                     r 
                                     m 
                                   
                                   ) 
                                 
                               
                             
                             ; 
                             
                               
                                 μ 
                                 ′ 
                               
                               x 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                           
                           , 
                           
                             
                               ∑ 
                               x 
                               
                                 ⋀ 
                                 
                                   ( 
                                   m 
                                   ) 
                                 
                               
                             
                              
                             
                                 
                             
                              
                             
                               + 
                               
                                 ∑ 
                                 b 
                                 
                                   ( 
                                   
                                     r 
                                     m 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                          
                         
                             
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   26 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where M is the HMM parameters from the last EM iteration and used for obtaining the posterior probability γ i   (m,s)  on state s and mixture m. 
         [0148]    As VTS is a special case of JUD, it can be easily shown that JAT becomes the VTS based adaptive training (VAT) when the number of mixtures equals to the number of regression classes. Generally speaking, VAT gives better modelling on training data than JAT because VTS is more powerful than JUD for noise compensation. However, both for JAT and VAT, the objective functions have to be optimised (fully or partially) by gradient decent algorithm which is not trivial, making the training process very long. Furthermore, in order to make the compensation for training and testing consistent, JUD is normally used for decoding when JAT HMM is in place and VTS is adopted with VAT HMM. This compromises decoding performance as JUD has issues on using non-diagonal transforms in decoding and VTS has problems on its efficiency. 
         [0149]    VTS-JUD based PCMLLR provides a good solution for adapting the HMM. It is faster than VTS and better than JUD as block-diagonal transforms can be easily applied. Therefore, this paper proposes to apply VTS-JUD based PCMLLR for adaptive training (PAT). As PCMLLR uses CMLLR as compensation formula, the objective function of PAT is the same as the objective function used in CMLLR based speaker adaptive training: 
         [0000]    
       
         
           
             
               
                 
                   
                     Q 
                      
                     
                       ( 
                       
                         
                           ℳ 
                           ^ 
                         
                         · 
                         ℳ 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         m 
                         , 
                         s 
                         , 
                         t 
                       
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         γ 
                         t 
                         
                           ( 
                           
                             m 
                             , 
                             s 
                           
                           ) 
                         
                       
                        
                       ln 
                        
                       
                          
                         
                           A 
                           c 
                           
                             ( 
                             
                               r 
                               m 
                             
                             ) 
                           
                         
                          
                       
                        
                       
                         N 
                         ( 
                         
                           
                             
                               
                                 
                                   A 
                                   c 
                                   
                                     ( 
                                     
                                       r 
                                       m 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   y 
                                   t 
                                 
                               
                               + 
                               
                                 b 
                                 c 
                                 
                                   ( 
                                   
                                     r 
                                     m 
                                   
                                   ) 
                                 
                               
                             
                             ; 
                             
                               
                                 μ 
                                 ′ 
                               
                               x 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                           
                           , 
                           
                             ∑ 
                             x 
                             
                               ⋀ 
                               
                                 ( 
                                 m 
                                 ) 
                               
                             
                           
                         
                          
                         
                             
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   27 
                   ) 
                 
               
             
           
         
       
     
         [0000]    and most importantly there exists closed-form solution for HMM updates. For example, the HMM mean is obtained as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       μ 
                       ^ 
                     
                     x 
                     
                       ( 
                       m 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         t 
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           γ 
                           t 
                           
                             ( 
                             
                               m 
                               , 
                               s 
                             
                             ) 
                           
                         
                          
                         
                           ( 
                           
                             
                               
                                 A 
                                 c 
                                 
                                   ( 
                                   
                                     r 
                                     m 
                                   
                                   ) 
                                 
                               
                                
                               
                                 y 
                                 t 
                               
                             
                             + 
                             
                               b 
                               
                                 ( 
                                 
                                   r 
                                   m 
                                 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                     
                     
                       
                         ∑ 
                         t 
                         
                             
                         
                       
                        
                       
                           
                       
                        
                       
                         γ 
                         t 
                         
                           ( 
                           m 
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   28 
                   ) 
                 
               
             
           
         
       
     
         [0150]    The training procedure for PAT is 
         [0151]    1) Run standard ML training for HMM and the ML-HMM is used as the initial model 
         [0152]    2) For each training utterance, estimate noise parameters and calculate JUD transforms by Eq. (8) and Eq. (6) as shown in step S 73   
         [0153]    3) Calculate PCMLLR transforms A c   (r     m     )  and b c   (r     m     )  based on Eq. (19) and Eq. (17) as shown in step S 75   
         [0154]    4) Given the PCMLLR transforms for all the utterances, update HMM parameters by Eq. (28) as shown in steps S 77  and S 79   
         [0155]    5) Go to step 2 S 73  for more iterations with the newly estimated HMM 
         [0156]    The noise estimation part for PAT in step 2 is flexible. As used in VAT, classical VTS based EM noise estimation can be applied here. However, in the implementation in accordance with the present embodiment, a different method, JUD based EM noise estimation, is adopted. Compared to the VTS based method, this technique also finds the optimal noise parameters by maximising the likelihood on the test utterance but the noise corruption is modelled by JUD instead of VTS. The auxiliary function for JUD based noise estimation is 
         [0000]    
       
         
           
             
               
                 
                   
                     ( 
                     
                       
                         
                           μ 
                           ^ 
                         
                         n 
                       
                       , 
                       
                         
                           ∑ 
                           n 
                           ⋀ 
                         
                          
                         
                             
                         
                          
                         
                           , 
                           
                             
                               μ 
                               ^ 
                             
                             h 
                           
                         
                       
                     
                     ) 
                   
                   = 
                   
                     arg 
                      
                     
                       
                         max 
                         
                           
                             
                               μ 
                               ^ 
                             
                             n 
                           
                           , 
                           
                             
                               ∑ 
                               n 
                               ⋀ 
                             
                              
                             
                               , 
                               
                                 
                                   μ 
                                   ^ 
                                 
                                 h 
                               
                             
                           
                         
                       
                        
                       
                         
                           ∑ 
                           
                             m 
                             , 
                             s 
                             , 
                             t 
                           
                           
                               
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             γ 
                             t 
                             
                               ( 
                               
                                 m 
                                 , 
                                 s 
                               
                               ) 
                             
                           
                            
                           ln 
                            
                           
                              
                             
                               A 
                               
                                 ( 
                                 
                                   r 
                                   m 
                                 
                                 ) 
                               
                             
                              
                           
                            
                           
                             N 
                             ( 
                             
                               
                                 
                                   
                                     
                                       A 
                                       
                                         ( 
                                         
                                           r 
                                           m 
                                         
                                         ) 
                                       
                                     
                                      
                                     
                                       y 
                                       
                                         ( 
                                         t 
                                         ) 
                                       
                                     
                                   
                                   + 
                                   
                                     b 
                                     
                                       ( 
                                       
                                         r 
                                         m 
                                       
                                       ) 
                                     
                                   
                                 
                                 ; 
                                 
                                   μ 
                                   x 
                                   
                                     ( 
                                     m 
                                     ) 
                                   
                                 
                               
                               , 
                               
                                 
                                   ∑ 
                                   x 
                                   
                                     ( 
                                     m 
                                     ) 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   + 
                                   
                                     ∑ 
                                     b 
                                     
                                       ( 
                                       
                                         r 
                                         m 
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                              
                             
                                 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   29 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where JUD transforms are functions of noise parameters ({circumflex over (μ)} n ,{circumflex over (Σ)} n ,{circumflex over (μ)} h ). Noise estimation with JUD follows a same iterative procedure as the VTS based noise estimation but it is much faster because transforms are only calculated on regression class level. Our experiments indicate the JUD based noise estimation is able to achieve almost the same accuracy on noise estimation compared to the VTS based technique. Furthermore, as VTS-JUD is applied in PCMLLR for model compensation in PAT, using JUD for noise estimation makes the whole PAT process consistent and better performance is expected. A feature based adaptive training technique has been previously presented by using SPLICE to transform all the features in training database. with a set of linear transforms. Although PAT also compensates feature vectors based on a set of linear transforms, it has major differences from the SPLICE based technique. First, feature based technique like SPLICE applies the transforms on noisy feature in one go and use the enhanced feature for decoding. As a contrast, CMLLR transforms in PAT are model dependent, i.e. same feature may use different transforms based on which HMM mixture the feature is scored on. 
         [0157]    It has been shown that model-dependent transforms are able to provide enhanced flexibility and much better performance for compensation than pure feature based techniques. Second, the CMLLR transforms generated in PAT are supposed to mimic the behaviour of model based adaptation technique VTS-JUD. This can never be achieved by feature based adaptive training. Finally, the transforms used in SPLICE are fixed and normally pre-trained on certain training data. They are only used to update HMM. In PAT, the transforms are actually related to HMM, i.e. their generation depends on HMM parameters. Therefore PAT transforms can be jointly optimised with HMM methods giving a better fit to the training data. 
         [0158]    Experiments were conducted on Toshiba in-car tasks which are recorded in real driving conditions with phone numbers (PH), 4 digits (4D), command control (CC) and city names (CN). Each task includes two noisy conditions i.e. engine-on (EN) and highway driving (HW). The EN condition contains 4401 utterances and has an average SNR 35 dB, whereas the HW condition contains 4582 sentences with SNR around 18 dB. The front-end employed in this paper is 39 dimension MFCC. Each feature vector consists of 13-dimensional static features with the zeroth coefficient and their delta and delta-delta components. Two training sets are used. One is for clean HMM training including 120-hour clean speech from Wall Street Journal. The other is for multi-condition training (MTR) and adaptive training, including 312 hours of data from Wall Street Journal, TIDIGITS, TIMIT and internally collected noisy training data. 
         [0159]    All the HMMs trained are triphone with 650 states. There are 12 mixtures for each speech state in the HMM and 24 mixtures for each silence state, making the overall number of mixtures in the HMM around 8000. When VTS-JUD based PCMLLR or JUD is in place for model adaptation, 64 regression classes are employed. Word error rate (WER) averaged on the two noise conditions with clean training are provided in table II. In this case, JUD based EM noise estimation is used to estimate noise parameters for VTS, VTS-JUD, JUD and PCMLLR. It is observed that VTS is able to give fairly good compensation for noise by reducing the averaged WER to 4.6%. This is however at the expense of increased computational cost. When diagonal transforms are used in JUD, the performance drops to 5.0% as the diagonal transformations give poor compensation. VTS-JUD implemented as Eq. (12) is very powerful with a performance almost as good as VTS, indicating the importance of using non-diagonal transformation on HMM mean. 
         [0160]    As the only difference between VTS and VTS-JUD here is the number of transforms used −8000 for VTS and 64 for VTS-JUD, this result indicates reducing the number of transforms does not have big impact on recognition performance. PCMLLR results are given in table III. Although using VTS as the target distribution in PCMLLR is as costly as using VTS directly, its result is also included here as a reference. When the block-diagonal structure is used for PCMLLR transforms, it is observed that the proposed VTS-JUD based PCMLLR reduces WER to 4.1% which is comparable to VTS based PCMLLR (4.0%). When diagonal structure is applied for PCMLLR transforms, degradation is observed, especially on highway conditions. This indicates that the block-diagonal structure is essential for low SNR environment. Additionally, no matter what adaptation techniques are employed, using it in conjunction with PCMLLR always provides better results than using it alone. Specifically, VTS based PCMLLR outperforms VTS and VTS-JUD based PCMLLR is superior to VTS-JUD. This shows that VTS-JUD based PCMLLR is able to beat VTS-JUD on recognition performance. Finally the approximation presented in Eq. (25) is also evaluated. Although some degradation is observed, the overall performance is still better than VTS. 
         [0161]    Table IV provides the results with multi-condition training data. VAT was implemented by using VTS for model compensation together with the VTS based noise estimation in both training and recognition. Compared to the ML training, VAT improves the performance to 2.5% and PAT is able to beat VAT with an even better performance 2.2%. Considering its efficiency, PAT seems to be the best adaptive training technique so far for noise compensation. 
         [0000]    
       
         
               
               
               
               
               
               
               
               
               
               
             
           
               
                 TABLE II 
               
               
                   
               
               
                 Method 
                 PH_EN 
                 PH_HW 
                 4D_EN 
                 4D_HW 
                 CC_EN 
                 CC_HW 
                 CN_EN 
                 CN_HW 
                 Average 
               
               
                   
               
             
             
               
                 Clean baseline 
                 7.1 
                 76.7  
                 9.5 
                 70.2  
                 3.8 
                 91.6  
                 18.9  
                 100.7  
                 47.3  
               
               
                 VTS 
                 1.0 
                 3.5 
                 1.3 
                 3.3 
                 0.8 
                 1.9 
                 5.7 
                 19.2 
                 4.6 
               
               
                 JUD 
                 1.1 
                 4.2 
                 1.1 
                 3.6 
                 0.8 
                 2.0 
                 6.1 
                 20.9 
                 5.0 
               
               
                 VTS-JUD 
                 1.0 
                 3.3 
                 1.2 
                 3.3 
                 0.8 
                 1.8 
                 5.7 
                 19.5 
                 4.6 
               
               
                   
               
             
          
         
       
     
         [0162]    Averaged wer (%) of each task for different methods with clean HMM training where JUD based methods use 64 regression classes 
         [0000]    
       
         
               
               
               
               
               
               
               
               
               
               
             
           
               
                 TABLE III 
               
               
                   
               
               
                 Method 
                 PH_EN 
                 PH_HW 
                 4D_EN 
                 4D_HW 
                 CC_EN 
                 CC_HW 
                 CN_EN 
                 CN_HW 
                 Average 
               
               
                   
               
             
             
               
                 PCMLLR(VTS) 
                 0.9 
                 3.1 
                 1.2 
                 2.7 
                 0.8 
                 1.5 
                 5.2 
                 16.7 
                 4.0 
               
               
                 Diag PCMLLR(VTS-JUD) 
                 1.1 
                 4.8 
                 1.0 
                 3.9 
                 0.7 
                 2.1 
                 5.7 
                 17.0 
                 4.5 
               
               
                 PCMLLR(VTS-JUD) 
                 0.9 
                 3.3 
                 1.2 
                 2.7 
                 0.8 
                 1.6 
                 5.1 
                 17.1 
                 4.1 
               
               
                 PCMLLR(VTS-JUD) - approx. 
                 0.9 
                 3.6 
                 1.2 
                 3.4 
                 0.8 
                 1.6 
                 5.4 
                 19.0 
                 4.5 
               
               
                   
               
             
          
         
       
     
         [0163]    Averaged WER (%) of each task for PCMLLR with clean HMM training where PCMLLR uses 64 regression classes 
         [0000]    
       
         
               
               
               
               
               
               
               
               
               
               
             
           
               
                 TABLE IV 
               
               
                   
               
               
                 Method 
                 PH_EN 
                 PH_HW 
                 4D_EN 
                 4D_HW 
                 CC_EN 
                 CC_HW 
                 CN_EN 
                 CN_HW 
                 Average 
               
               
                   
               
             
             
               
                 MTR baseline 
                 0.9 
                 3.9 
                 0.6 
                 2.8 
                 1.0 
                 2.0 
                 4.1 
                 14.6 
                 3.7 
               
               
                 VAT 
                 0.5 
                 1.4 
                 0.5 
                 1.2 
                 0.7 
                 1.3 
                 3.9 
                 10.5 
                 2.5 
               
               
                 PAT 
                 0.6 
                 1.5 
                 0.3 
                 0.9 
                 0.7 
                 1.3 
                 3.9 
                  8.7 
                 2.2 
               
               
                   
               
             
          
         
       
     
         [0164]    Averaged WER (%) of each task for different methods with MTR training where JUD based methods use 64 regression classes