discmods.tex

该压缩包为最新版htk的源代码,htk是现在比较流行的语音处理软件,请有兴趣的朋友下载使用

%/* ----------------------------------------------------------- */
%/*                                                             */
%/*                          ___                                */
%/*                       |_| | |_/   SPEECH                    */
%/*                       | | | | \   RECOGNITION               */
%/*                       =========   SOFTWARE                  */ 
%/*                                                             */
%/*                                                             */
%/* ----------------------------------------------------------- */
%/*         Copyright: Microsoft Corporation                    */
%/*          1995-2000 Redmond, Washington USA                  */
%/*                    http://www.microsoft.com                */
%/*                                                             */
%/*   Use of this software is governed by a License Agreement   */
%/*    ** See the file License for the Conditions of Use  **    */
%/*    **     This banner notice must not be removed      **    */
%/*                                                             */
%/* ----------------------------------------------------------- */
%
% HTKBook - Steve Young 15/11/95
%

\mychap{Discrete and Tied-Mixture Models}{discmods}

\sidepic{Tool.disc}{80}{ 
Most of the discussion so far has focussed on using \HTK\
to model sequences of continuous-valued vectors.  In contrast, this chapter
is mainly concerned with using \HTK\ to model sequences of discrete
symbols.  
Discrete symbols arise naturally in modelling many types of
data, for example, letters and words, bitmap images, and DNA sequences.
Continuous signals can also be converted to discrete symbol sequences
by using a quantiser and in particular, speech vectors can be
\textit{vector quantised} as described in section~\ref{s:vquant}.
In all cases, \HTK\ expects a set of $N$ discrete symbols to be represented by
the contiguous sequence of integer numbers from 1 to $N$.
}\index{discrete HMMs}

In \HTK\ discrete probabilities are regarded as being closely analogous
to the mixture weights of a continuous density system.  As a consequence,
the representation and processing of discrete HMMs shares a great deal
with continuous density models.  It follows from this that most of the
principles and practice developed already are equally applicable to
discrete systems.  As a consequence, this chapter can be quite brief.

The first topic covered concerns building HMMs for discrete
symbol sequences.  The use of discrete HMMs with speech is then
presented.  The tool \htool{HQuant} is described and the method
of converting continuous speech vectors to discrete symbols is
reviewed.  This is 
followed by a brief discussion of tied-mixture systems which can be 
regarded as a compromise between continuous and discrete density systems.
Finally, the use of the \HTK\ tool \htool{HSmooth} for
parameter smoothing by deleted interpolation is presented.

\mysect{Modelling Discrete Sequences}{discseq}

Building HMMs for discrete symbol sequences is essentially the same
as described previously for continuous density systems. 
Firstly, a prototype HMM definition must be specified in order
to fix the model topology.  For example, the following
is a 3 state ergodic HMM in which the emitting states
are fully connected.
\begin{verbatim}
    ~o <DISCRETE> <StreamInfo> 1 1 
    ~h "dproto"
    <BeginHMM>
       <NumStates> 5 
       <State> 2 <NumMixes> 10
          <DProb> 5461*10
       <State> 3 <NumMixes> 10
          <DProb> 5461*10
       <State> 4 <NumMixes> 10
          <DProb> 5461*10
       <TransP> 5
           0.0 1.0 0.0 0.0 0.0
           0.0 0.3 0.3 0.3 0.1
           0.0 0.3 0.3 0.3 0.1
           0.0 0.3 0.3 0.3 0.1
           0.0 0.0 0.0 0.0 0.0
    <EndHMM>
\end{verbatim}
As described in chapter~\ref{c:HMMDefs}, the notation for discrete
HMMs borrows heavily on that used for continuous density models
by equating mixture components with symbol indices.  Thus,
this definition assumes that each training data sequence contains
a single stream of symbols indexed from 1 to 10.  In this example,
all symbols in each state have been set to be equally likely\footnote{
Remember that discrete probabilities are scaled such that
32767 is equivalent to a probability of 0.000001 and 0 is 
equivalent to a probability of 1.0
}.  If prior information is available then this can of course be used
to set these initial values.

The training data needed to build a discrete HMM can take one of two forms. It
can either be discrete (\texttt{SOURCEKIND=DISCRETE}) in which case it consists
of a sequence of 2-byte integer symbol indices.  Alternatively, it can consist
of continuous parameter vectors with an associated VQ codebook.  This latter
case is dealt with in the next section.  Here it will be assumed that the data
is symbolic and that it is therefore stored in discrete form.\index{discrete
data} Given a set of training files listed in the script file
\texttt{train.scp}, an initial HMM could be estimated using
\begin{verbatim}
    HInit -T 1 -w 1.0 -o dhmm -S train.scp -M hmm0 dproto
\end{verbatim}
This use of \htool{HInit} is identical to that which would be
used for building whole word HMMs where no associated label file is
assumed and the whole of each training sequence is used to estimate
the HMM parameters.  Its effect is to read in the prototype
stored in the file \texttt{dproto} and then use the training examples
to estimate initial values for the output distributions
and transition probabilities.  This is done by firstly uniformly 
segmenting the data and for each segment counting the number of occurrences
of each symbol.  These counts are then normalised to provide output distributions
for each state.  \htool{HInit} then uses the Viterbi algorithm to resegment
the data and recompute the parameters.  This is repeated until convergence
is achieved or an upper limit on the iteration count is reached.
The transition probabilities at each step are estimated simply by
counting the number of times that each transition is made in the Viterbi alignments
and normalising.  The final model is renamed \texttt{dhmm} and stored in
the directory \texttt{hmm0}.

When building discrete HMMs, it is important to floor the discrete
probabilites so that no symbol has a zero probability.  This is 
achieved using the \texttt{-w} option which specifies a floor value
as a multiple of a global constant called \texttt{MINMIX} whose
value is $10^{-5}$. 

The initialised HMM created by \htool{HInit} 
can then be further refined if desired by using \htool{HRest}
to perform Baum-Welch re-estimation.  It would be invoked in a similar
way to the above except that there is now no need to rename the model.
For example,
\begin{verbatim}
    HRest -T 1 -w 1.0 -S train.scp -M hmm1 hmm0/dhmm
\end{verbatim}
would read in the model stored in \texttt{hmm0/dhmm} and write out a new
model of the same name to the directory \texttt{hmm1}.

\mysect{Using Discrete Models with Speech}{speechvq}

As noted in section~\ref{s:vquant}, discrete HMMs can be used to model
speech by using a vector quantiser to map continuous density vectors into
discrete symbols.  A vector quantiser depends on a so-called \textit{codebook} 
which defines a set of partitions of the vector space.  Each partition
is represented by the mean value of the speech vectors belonging
to that partition and optionally  a variance representing the spread.
Each incoming speech vector is then
matched with each partition and assigned the index corresponding
to the partition which is closest using a Mahanalobis distance metric.

In \HTK\ such a codebook can be built using the tool \htool{HQuant}.  This tool
takes as input a set of continuous speech vectors, clusters them and uses
the centroid and optionally the variance of each cluster to define
the partitions.  \htool{HQuant} can build both linear and tree structured
codebooks.  To build a linear codebook, all training vectors are initially
placed in one cluster and the mean calculated.  The mean is then perturbed
to give two means and the training vectors are partitioned according to
which mean is nearest to them.  The means are then recalculated and the
data is repartitioned.  At each cycle, the total distortion (i.e. total
distance between the cluster members and the mean) is recorded and repartitioning
continues until there is no significant reduction in distortion.  The whole
process then repeats by perturbing the mean of the cluster with the highest
distortion.  This continues until the required number of clusters have been
found.

Since all training vectors are reallocated at every cycle, this is an
expensive algorithm to compute.  The maximum number of iterations within
any single cluster increment can be limited using the configuration
variable \texttt{MAXCLUSTITER}\index{maxclustiter@\texttt{MAXCLUSTITER}} 
and although this can speed-up the computation
significantly, the overall training process is still computationally expensive.
Once built, vector quantisation is performed by scanning all codebook
entries and finding the nearest entry.  Thus, if a large codebook is used,
the run-time VQ look-up operation can also be expensive.

As an alternative to building a linear codebook, a tree-structured codebook
can be used.  The algorithm for this is essentially the same as above
except that every cluster is split at each stage so that the first cluster
is split into two, they are split into four and so on.  At each stage, the
means are recorded so that when using the codebook for vector quantising
a fast binary search can be used to find the appropriate leaf cluster.
Tree-structured codebooks are much faster to build since there is no
repeated reallocation of vectors and much faster in use since only $O(\log_2 N)$
distance need to be computed where $N$ is the size of the codebook.
Unfortunately, however, tree-structured codebooks will normally incur higher 
VQ distortion for a given codebook size.

When delta and acceleration coefficients are used, it is usually best
to split the data into multiple streams (see section~\ref{s:streams}.
In this case, a separate codebook is built for each stream.

As an example, the following invocation of \htool{HQuant} would
generate a linear codebook in the file \texttt{linvq} using
the data stored in the files listed in \texttt{vq.scp}.  
\begin{verbatim}
   HQuant -C config -s 4 -n 3 64 -n 4 16 -S vq.scp linvq
\end{verbatim}
Here the configuration file \texttt{config} specifies the \texttt{TARGETKIND}
as being \texttt{MFCC\_E\_D\_A} i.e.\ static coefficients plus deltas plus
accelerations plus energy.  The \texttt{-s} options requests that this
parameterisation be split into
4 separate streams.  By default, each individual codebook has 256 entries, however,
the \texttt{-n} option can be used to specify alternative sizes.

If a tree-structured codebook was wanted rather than a linear codebook,
the \texttt{-t} option would be set.
Also the default is to use Euclidean distances both for building the
codebook and for subsequent coding.  Setting the \texttt{-d} option
causes a diagonal covariance Mahalanobis metric to be used and 
the \texttt{-f} option causes a full covariance Mahalanobis metric
to be used.

\index{hcopy@\htool{HCopy}}
\sidefig{vqtohmm}{55}{VQ Processing}{-4}{
Once the codebook is built, normal speech vector files can be 
converted to discrete files using \htool{HCopy}.  
This was explained 
previously in section~\ref{s:vquant}.  The basic mechanism is to
add the qualifier \texttt{\_V} to the 
\texttt{TARGETKIND}.\index{qualifiers!aaav@\texttt{\_V}}  This causes
\htool{HParm} to append a codebook index to each constructed observation