hutil.c

实现HMM算法

/* ----------------------------------------------------------- */
/*                                                             */
/*                          ___                                */
/*                       |_| | |_/   SPEECH                    */
/*                       | | | | \   RECOGNITION               */
/*                       =========   SOFTWARE                  */ 
/*                                                             */
/*                                                             */
/* ----------------------------------------------------------- */
/* developed at:                                               */
/*                                                             */
/*      Speech Vision and Robotics group                       */
/*      Cambridge University Engineering Department            */
/*      http://svr-www.eng.cam.ac.uk/                          */
/*                                                             */
/*      Entropic Cambridge Research Laboratory                 */
/*      (now part of Microsoft)                                */
/*                                                             */
/* ----------------------------------------------------------- */
/*         Copyright: Microsoft Corporation                    */
/*          1995-2000 Redmond, Washington USA                  */
/*                    http://www.microsoft.com                 */
/*                                                             */
/*              2002  Cambridge University                     */
/*                    Engineering Department                   */
/*                                                             */
/*   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      **    */
/*                                                             */
/* ----------------------------------------------------------- */
/*         File: HUtil.c      HMM utility routines             */
/* ----------------------------------------------------------- */

char *hutil_version = "!HVER!HUtil:   3.3 [CUED 28/04/05]";
char *hutil_vc_id = "$Id: HUtil.c,v 1.2 2005/07/22 10:17:02 mjfg Exp $";

#include "HShell.h"
#include "HMem.h"
#include "HMath.h"
#include "HSigP.h"
#include "HAudio.h"
#include "HWave.h"
#include "HVQ.h"
#include "HParm.h"
#include "HLabel.h"
#include "HModel.h"
#include "HUtil.h"

/* --------------------------- Trace Flags ------------------------- */

#define T_TOP  0001       /* Top Level tracing */
#define T_ITM  0002       /* Item List tracing */
#define T_OCC  0004       /* Occupancy statistics tracing */

static int trace = 0;
static Boolean parsePhysicalHMM = FALSE;

static MemHeap setHeap;
static MemHeap itemHeap;

/* --------------------------- Initialisation ---------------------- */

static ConfParam *cParm[MAXGLOBS];      /* config parameters */
static int nParm = 0;

/* EXPORT->InitUtil: initialise configuration parameters */
void InitUtil(void)
{
   int i;

   Register(hutil_version,hutil_vc_id);
   nParm = GetConfig("HUTIL", TRUE, cParm, MAXGLOBS);
   if (nParm>0){
      if (GetConfInt(cParm,nParm,"TRACE",&i)) trace = i;
   }
   CreateHeap(&itemHeap,"HUtil: ItemList Heap",MHEAP,sizeof(ItemRec),
              1.0,200,8000);
   CreateHeap(&setHeap,"HUtil: IntSet Heap",MSTAK,1,1.0,2000,16000);
}

/* EXPORT->ResetUtilItemList: frees all the memory from the ItemList heap */
void ResetUtilItemList()
{
   DeleteHeap(&itemHeap);
   CreateHeap(&itemHeap,"HUtil: ItemList Heap",MHEAP,sizeof(ItemRec),
             1.0,200,8000);
}

/* EXPORT->SetParsePhysicalHMM: only parse physical HMMs */
void SetParsePhysicalHMM(Boolean parse)
{
   parsePhysicalHMM = parse;
}

/* -------------------- Clone Routines ------------------------ */

/* CloneSVector: return a clone of given matrix */
SVector CloneSVector(MemHeap *hmem, SVector s, Boolean sharing)
{
   SVector t;  /* the target */
   
   if (s==NULL) return NULL;
   if (GetUse(s)>0 && sharing) {
      IncUse(s);
      return s;
   }
   t = CreateSVector(hmem,VectorSize(s));
   CopyVector(s,t);
   return t;
}

/* CloneSMatrix: return a clone of given Matrix */
SMatrix CloneSMatrix(MemHeap *hmem, SMatrix s, Boolean sharing)
{
   SMatrix t;  /* the target */
   
   if (s==NULL) return NULL;
   if (GetUse(s)>0 && sharing) {
      IncUse(s);
      return s;
   }
   t = CreateSMatrix(hmem,NumRows(s),NumCols(s));
   CopyMatrix(s,t);
   return t;
}

/* CloneSTriMat: return a clone of given TriMat */
STriMat CloneSTriMat(MemHeap *hmem, STriMat s, Boolean sharing)
{
   STriMat t;  /* the target */
   
   if (s==NULL) return NULL;
   if (GetUse(s)>0 && sharing) {
      IncUse(s);
      return s;
   }
   t = CreateSTriMat(hmem,TriMatSize(s));
   CopyTriMat(s,t);
   return t;
}

/* CloneMixPDF: return a clone of given MixPDF */
MixPDF *CloneMixPDF(HMMSet *hset, MixPDF *s, Boolean sharing)
{
   MixPDF *t;
   
   if (s->nUse>0 && sharing) { 
      ++s->nUse;
      return s;
   }
   t = (MixPDF*)New(hset->hmem,sizeof(MixPDF));
   t->nUse = 0; t->hook = NULL; t->gConst = s->gConst;
   t->mean = CloneSVector(hset->hmem,s->mean,sharing);
   t->ckind = s->ckind;
   switch(s->ckind) {
   case DIAGC: 
   case INVDIAGC: 
      t->cov.var = CloneSVector(hset->hmem,s->cov.var,sharing);
      break;
   case FULLC:
   case LLTC:
      t->cov.inv = CloneSTriMat(hset->hmem,s->cov.inv,sharing);
      break;
   case XFORMC:
      t->cov.xform = CloneSMatrix(hset->hmem,s->cov.xform,sharing);
      break;
   }
   return t;
}

/* CloneStream: return a clone of given stream */
MixtureVector CloneStream(HMMSet *hset, StreamElem *ste, Boolean sharing)
{
   int m,M;
   MixtureElem *sme,*tme;
   MixtureVector mv;

   M = ste->nMix;
   if (hset->hsKind == PLAINHS || hset->hsKind == SHAREDHS){
      tme = (MixtureElem *)New(hset->hmem,M*sizeof(MixtureElem));
      mv.cpdf = tme-1; sme = ste->spdf.cpdf + 1;
      for (m=1; m<=M; m++,sme++,tme++){
         tme->weight = sme->weight;
         tme->mpdf = 
            (MixWeight(hset,tme->weight)>MINMIX)?CloneMixPDF(hset,sme->mpdf,sharing):NULL;
      }
   } else if (hset->hsKind == TIEDHS) {
      mv.tpdf = CreateVector(hset->hmem,M);
      CopyVector(ste->spdf.tpdf,mv.tpdf);
   } else {
      mv.dpdf = CreateShortVec(hset->hmem,M);
      CopyShortVec(ste->spdf.dpdf,mv.dpdf);
   }
   return mv;
}

/* CloneState: return a clone of given State */
StateInfo *CloneState(HMMSet *hset, StateInfo *ssi, Boolean sharing)
{
   StateInfo *tsi;  /* the target */
   StreamElem *tste,*sste;
   int s,S;
   
   if (ssi->nUse>0 && sharing) { 
      ++ssi->nUse;
      return ssi;
   }
   S = hset->swidth[0];
   tsi = (StateInfo *)New(hset->hmem,sizeof(StateInfo));
   tsi->nUse = 0; tsi->hook = NULL;
   tste = (StreamElem *)New(hset->hmem,S*sizeof(StreamElem));
   tsi->pdf = tste-1; sste = ssi->pdf + 1;
   for (s=1; s<=S; s++,tste++,sste++){
      tste->nMix = sste->nMix; 
      tste->hook = NULL;
      tste->spdf = CloneStream(hset,sste,sharing);
   }
   tsi->dur     = CloneSVector(hset->hmem,ssi->dur,sharing);
   tsi->weights = CloneSVector(hset->hmem,ssi->weights,sharing);
   return tsi;
}

/* EXPORT->CloneHMM: copy src HMM into tgt.  If sharing, then macros are shared */
void CloneHMM(HLink src, HLink tgt, Boolean sharing)
{
   StateElem *s,*t;
   int i;
   HMMSet *hset = src->owner;
   
   tgt->owner = src->owner;
   tgt->numStates = src->numStates;
   tgt->dur = CloneSVector(hset->hmem,src->dur,sharing);
   tgt->transP = CloneSMatrix(hset->hmem,src->transP,sharing);
   t = (StateElem *)New(hset->hmem,(tgt->numStates-2)*sizeof(StateElem));
   tgt->svec = t-2; s = src->svec+2;
   for (i=2; i<tgt->numStates; i++,s++,t++)
      t->info = CloneState(hset,s->info,sharing);
   tgt->hook = NULL; tgt->nUse = 0;
}

/* -------------------- Mapping Routines ------------------------ */

/* EXPORT->NewHMMScan:  create new HMM scan record */
void NewHMMScan(HMMSet *hset, HMMScanState *hss)
{
   hss->hset = hset;
   hss->S = hset->swidth[0];
   hss->isCont = (hset->hsKind == PLAINHS) || (hset->hsKind == SHAREDHS);
   hss->h = -1;
   hss->mac=NULL;
   if (!GoNextHMM(hss))
      HError(7220,"NewHMMScan: cannot find any physical HMMs to scan");
}

/* EXPORT->EndHMMScan: terminate scan and restore nUse flags */
void EndHMMScan(HMMScanState *hss)
{
   ClearSeenFlags(hss->hset,CLR_ALL);
   hss->hmm = NULL; hss->se = NULL; hss->ste = NULL; hss->me = NULL;
}

/* EXPORT->GoNextHMM: Move to next unseen HMM in HMM set */
Boolean GoNextHMM(HMMScanState *hss)
{
   int M;
   MLink mac;

   mac = hss->mac ? hss->mac->next : NULL;
   if (mac==NULL) hss->h++;
   for (;hss->h<MACHASHSIZE;hss->h++)
      for (mac=((mac==NULL)?hss->hset->mtab[hss->h]:mac);
           mac!=NULL;mac=mac->next) {
         if (mac->type == 'h') {
            hss->mac = mac;
            hss->hmm = (HLink)mac->structure;
            hss->N = hss->hmm->numStates;
            hss->se = hss->hmm->svec+2; hss->i=2;
            hss->si = hss->se->info;
            hss->ste = hss->si->pdf+1; hss->s=1;
            M = hss->ste->nMix;
            hss->M = (M<0)?-M:M; hss->m=1;
            if (hss->isCont){
               hss->me = hss->ste->spdf.cpdf+1;
               hss->mp = hss->me->mpdf;
            } else if  (hss->hset->hsKind == TIEDHS) {
               hss->mp = hss->hset->tmRecs[hss->s].mixes[hss->m];
               hss->me = NULL;
            }
            return TRUE;
         }
      }
   hss->hmm = NULL;
   return FALSE;
}

/* EXPORT->GoNextState: move to next unseen state */
Boolean GoNextState(HMMScanState *hss, Boolean noSkip)
{
   Boolean stepping = FALSE, ok = TRUE;
   int M;
   
   while (IsSeen(hss->si->nUse) && ok){
      if (hss->i < hss->N-1) {
         ++hss->i; ++hss->se; stepping = TRUE;
         hss->si = hss->se->info;
      } else if (noSkip)
         return FALSE;
      else{
         stepping = FALSE;
         ok = GoNextHMM(hss); 
      }
   }
   if (ok) {
      Touch(&hss->si->nUse);
      if (stepping){
         hss->ste = hss->si->pdf+1; hss->s=1;
         M = hss->ste->nMix;
         hss->M = (M<0)?-M:M; hss->m=1;
         if (hss->isCont){
            hss->me = hss->ste->spdf.cpdf+1;
            hss->mp = hss->me->mpdf;
         } else if  (hss->hset->hsKind == TIEDHS) {
            hss->mp = hss->hset->tmRecs[hss->s].mixes[1];
            hss->me = NULL;
         }
      }
      return TRUE;
   }
   hss->se = NULL;
   return FALSE;
}

/* EXPORT->GoNextStream: move to next unseen stream */
Boolean GoNextStream(HMMScanState *hss, Boolean noSkip)
{
   Boolean stepping = FALSE, ok = TRUE;
   int M;
   
   while (IsSeen(hss->ste->nMix) && ok){
      if (hss->s < hss->S) {
         ++hss->s; ++hss->ste; stepping = TRUE;
      } else if (noSkip)
         return FALSE;
      else{
         stepping = FALSE;    
         ok = GoNextState(hss,FALSE);
      }
   }
   if (ok) {
      Touch(&hss->ste->nMix);
      if (stepping) {
         M = hss->ste->nMix;
         hss->M = (M<0)?-M:M; hss->m=1;
         if (hss->isCont){
            hss->me = hss->ste->spdf.cpdf+1;
            hss->mp = hss->me->mpdf;
         } else if  (hss->hset->hsKind == TIEDHS) {
            hss->mp = hss->hset->tmRecs[hss->s].mixes[1];
            hss->me = NULL;
         }
      }
      return TRUE;
   }
   hss->ste = NULL;
   return FALSE;
}

/* EXPORT->GoNextMix: move to next unseen mixture component */
Boolean GoNextMix(HMMScanState *hss, Boolean noSkip)
{
   Boolean ok = TRUE;
   
   if (hss->isCont || (hss->hset->hsKind == TIEDHS)) {
      while (IsSeen(hss->mp->nUse) && ok){
         if (hss->m < hss->M) {
            ++hss->m; 
            if (hss->isCont) {
               ++hss->me; 
               hss->mp = hss->me->mpdf;
            } else {
               hss->mp = hss->hset->tmRecs[hss->s].mixes[hss->m];
               hss->me = NULL;
            }
         } else if (noSkip)
            return FALSE;
         else
            ok = GoNextStream(hss,FALSE);
      }
      if (ok) {
         Touch(&hss->mp->nUse);
         return TRUE;
      }
   } else { /* There are no components in a DISCRETEHS system - use GoNextStream instead */
      HError(7231,"GoNextMix: Cannot specify mixture components unless continuous");
   }
   hss->me = NULL;
   return FALSE;
}

/* ----------------------- DiagC conversions ----------------------------- */

/* minimum and max values used in conversions */
#define MINVAR 1E-30
#define MAXVAR 1E+30

/* EXPORT->ConvDiagC Convert Diagonal Covariance Kind
  Converts all the HMMs in hset to INVDIAGC from DIAGC
  or vice versa. If convData is TRUE then each variance element is
  replaced by its reciprocal（倒数） - otherwise only the CovKind in each HMM
  is changed and no data conversions are performed. */
void ConvDiagC(HMMSet *hset, Boolean convData)
{
   HMMScanState hss;
   SVector v;
   int k;

   if (hset->hsKind == DISCRETEHS || hset->hsKind == TIEDHS) 
      return;
   NewHMMScan(hset, &hss);
   while (GoNextMix(&hss,FALSE)) {
      if (hss.mp->ckind == DIAGC || hss.mp->ckind == INVDIAGC){
         hss.mp->ckind = (hss.mp->ckind == DIAGC)?INVDIAGC:DIAGC;
         if (convData){
            v = hss.mp->cov.var;
            if (! IsSeenV(v)) {
               for (k=1; k<=hset->swidth[hss.s]; k++) {
                  if (v[k] > MAXVAR) v[k] = MAXVAR;
                  if (v[k] < MINVAR) v[k] = MINVAR;
                  v[k] = 1/v[k];
               }
               TouchV(v);
            }
         }
      }
   }
   EndHMMScan(&hss);
   ClearSeenFlags(hset,CLR_ALL);
}

/* EXPORT->ConvDiagC Convert Diagonal Covariance Kind
   Converts all the HMMs in hset to DIAGC from INVDIAGC 将HMM集合中所有的HMM的方差从逆对角转换成对角*/
void ForceDiagC(HMMSet *hset)
{
   HMMScanState hss;
   SVector v;
   int k;