htrain.c

隐马尔科夫模型工具箱

       break;
     default:
       HError(7170,"CreateVaAcc: bad cov kind %d",ck);
     }
     va[count].occ = 0.0;
     ++vaC;
   }
   return va;
}

/* CreateTrAcc: create an accumulator for transition counts */
static TrAcc *CreateTrAcc(MemHeap *x, int numStates, int nPara)
{
   TrAcc *ta;
   int count;
   ta = (TrAcc *) New(x,sizeof(TrAcc)*nPara);
   for(count=0;count<nPara;count++){
     ta[count].tran = CreateMatrix(x,numStates,numStates);
     ZeroMatrix(ta[count].tran);
     ta[count].occ = CreateVector(x,numStates);
     ZeroVector(ta[count].occ);
     ++trC;
   }
   return ta;
}

/* CreateWtAcc: create an accumulator for mixture weights */
static WtAcc *CreateWtAcc(MemHeap *x, int nMix, int nPara)
{
   WtAcc *wa;
   int count;
   wa = (WtAcc *) New(x,sizeof(WtAcc)*nPara);
   for(count=0;count<nPara;count++){
     wa[count].c = CreateVector(x,nMix);
     ZeroVector(wa[count].c);
     wa[count].occ = 0.0;
     wa[count].time = -1; wa[count].prob = LZERO;
     ++wtC;
   }
   return wa;
}

/* CreatePreComp: create a struct for precomputed probs */
static PreComp *CreatePreComp(MemHeap *x)
{
   PreComp *p;
   
   p = (PreComp *) New(x,sizeof(PreComp));
   p->time = -1; p->prob = LZERO;
   ++prC;
   return p;
}

/* TMAttachAccs: attach accumulators to tied mixes in hset */
void TMAttachAccs(HMMSet *hset, MemHeap *x, int nPara)
{
   int size,s,m,nStreams;
   TMixRec tmRec;
   MixPDF *mp;
   
   nStreams = hset->swidth[0];
   for (s=1;s<=nStreams;s++){
      size = hset->swidth[s];
      tmRec = hset->tmRecs[s];
      for (m=1;m<=tmRec.nMix;m++){
         mp = tmRec.mixes[m];
         SetHook(mp->mean,CreateMuAcc(x,size,nPara));
         SetHook(mp->cov.var,CreateVaAcc(x,size,mp->ckind,nPara));
      }
   }
}



/* EXPORT->AttachAccs: attach accumulators to hset */
void AttachAccs(HMMSet *hset, MemHeap *x){ AttachAccsParallel(hset,x,1); }
void AttachAccsParallel(HMMSet *hset, MemHeap *x, int nPara)
{
   HMMScanState hss;
   StreamElem *ste;
   HLink hmm;
   int size;

   muC=vaC=trC=wtC=prC=0;
   NewHMMScan(hset,&hss);
   do {
      hmm = hss.hmm;
      hmm->hook = (void *)0;  /* used as numEg counter */
      while (GoNextState(&hss,TRUE)) {
         while (GoNextStream(&hss,TRUE)) {
            ste = hss.ste;
            ste->hook = CreateWtAcc(x,hss.M, nPara);
            size = hset->swidth[hss.s];
            if (hss.isCont)                     /* PLAINHS or SHAREDHS */
               while (GoNextMix(&hss,TRUE)) {
                  if (DoPreComps(hset->hsKind))
                     hss.mp->hook = CreatePreComp(x);
                  if (!IsSeenV(hss.mp->mean)) {
                     SetHook(hss.mp->mean,CreateMuAcc(x,size,nPara));
                     TouchV(hss.mp->mean);
                  }
                  if (!IsSeenV(hss.mp->cov.var)) {
                     SetHook(hss.mp->cov.var,
                             CreateVaAcc(x,size,hss.mp->ckind,nPara));
                     TouchV(hss.mp->cov.var);
                  }
               }
         }
      }
      if (!IsSeenV(hmm->transP)) {
         SetHook(hmm->transP,CreateTrAcc(x,hmm->numStates,nPara));
         TouchV(hmm->transP);       
      }
   } while (GoNextHMM(&hss));
   EndHMMScan(&hss);
   
   if (hset->hsKind==TIEDHS)    
      TMAttachAccs(hset, x, nPara);
   if (trace&T_NAC)
      printf("AttachAccs: %d mu, %d va, %d tr, %d wt, %d pr\n",
             muC,vaC,trC,wtC,prC);
}

/* TMZeroAccs: zero all accs attached to tied mixes in given HMMSet */
void TMZeroAccs(HMMSet *hset, int start, int end)
{
   TMixRec tmRec;
   int i,m,s,nStreams;
   MixPDF* mp;
   MuAcc *ma;
   VaAcc *va;
      
   nStreams = hset->swidth[0];
   for (s=1;s<=nStreams;s++){
      tmRec = hset->tmRecs[s];
      for (m=1;m<=tmRec.nMix;m++){
         mp = tmRec.mixes[m];
         ma = (MuAcc *)GetHook(mp->mean);
         va = (VaAcc *)GetHook(mp->cov.var);
         for(i=start;i<=end;i++){ 
	   ZeroVector(ma[i].mu); ma[i].occ = 0.0; 
	   switch(mp->ckind){
	   case DIAGC:
	   case INVDIAGC:
	     ZeroVector(va[i].cov.var);
	     break;
	   case FULLC:
	     ZeroTriMat(va[i].cov.inv);
	     break;
	   default:
	     HError(7170,"TMZeroAccs: bad cov kind %d",
		    mp->ckind);
	   }
	   va[i].occ = 0.0;
	 }
      }
   }
}

/*  EXPORT->ZeroAccs: zero all accumulators in given HMM set */
void ZeroAccs(HMMSet *hset){ ZeroAccsParallel(hset,1); }

void ZeroAccsParallel(HMMSet *hset, int nPara)
{
   HMMScanState hss;
   StreamElem *ste;
   HLink hmm;
   TrAcc *ta;
   WtAcc *wa;
   MuAcc *ma;
   VaAcc *va;
   PreComp *p;
   int i,start,end;
   if(nPara>0){start=0;end=nPara-1;}else{start=end=-nPara;}
   NewHMMScan(hset,&hss);
   do {
      hmm = hss.hmm;
      hmm->hook = (void *)0;  /* used as numEg counter */
      while (GoNextState(&hss,TRUE)) {
         while (GoNextStream(&hss,TRUE)) {
            ste = hss.ste;
            wa = (WtAcc *)ste->hook;
            for(i=start;i<=end;i++){
	      ZeroVector(wa[i].c); wa[i].occ = 0.0;
	      wa[i].time = -1; wa[i].prob = LZERO;
	    }
            if (hss.isCont)
               while (GoNextMix(&hss,TRUE)) {
		  if (DoPreComps(hset->hsKind)){
		     p = (PreComp *)hss.mp->hook;  
		     p->time = -1; p->prob = LZERO;
                  }
                  if (!IsSeenV(hss.mp->mean)) {
                     ma = (MuAcc *)GetHook(hss.mp->mean);
		     for(i=start;i<=end;i++){
		       ZeroVector(ma[i].mu); ma[i].occ = 0.0;
		     }
		     TouchV(hss.mp->mean);
                  }
                  if (!IsSeenV(hss.mp->cov.var)) {
		     va = (VaAcc *)GetHook(hss.mp->cov.var);
		     for(i=start;i<=end;i++){
		       switch(hss.mp->ckind){
		       case DIAGC:
		       case INVDIAGC:
			 ZeroVector(va[i].cov.var);
			 break;
		       case FULLC:
			 ZeroTriMat(va[i].cov.inv);
			 break;
		       default:
			 HError(7170,"ShowAccs: bad cov kind %d",
				hss.mp->ckind);
		       }
		       va[i].occ = 0.0;
		     }
                     TouchV(hss.mp->cov.var);
                  }
               }
          
         }
      }
      if (!IsSeenV(hmm->transP)) {
         ta = (TrAcc *)GetHook(hmm->transP);
	 for(i=start;i<=end;i++){
	   ZeroMatrix(ta[i].tran);
	   ZeroVector(ta[i].occ);
	 }
         TouchV(hmm->transP);       
      }
   } while (GoNextHMM(&hss));
   EndHMMScan(&hss);
   if (hset->hsKind==TIEDHS)   
      TMZeroAccs(hset,start,end);
}

/* TMShowAccs: show accs attached to tied mixes in hset */
void TMShowAccs(HMMSet *hset, int index)
{
   int m,s,nStreams;
   MixPDF* mp;
   const int mw=12;
   TMixRec tmRec;
   MuAcc *ma;
   VaAcc *va;
   
   nStreams = hset->swidth[0];
   for (s=1;s<=nStreams;s++){
      tmRec = hset->tmRecs[s];
      printf("Tied Mixtures for Stream %d\n",s);
      for (m=1;m<=tmRec.nMix;m++){
         mp = tmRec.mixes[m];
         printf("   mix %d\n",m);
         ma = (MuAcc *)GetHook(mp->mean);
         printf("    mean occ=%f\n",ma[index].occ);
         ShowVector("    means=",ma[index].mu,mw);

         va = (VaAcc *)GetHook(mp->cov.var);
         printf("    var occ=%f\n",va[index].occ);
         switch(mp->ckind){
         case DIAGC:
         case INVDIAGC:
            ShowVector("    vars=",va[index].cov.var,mw);
            break;
         case FULLC:
            ShowTriMat("    covs=",va[index].cov.inv,mw,mw);
            break;
         default:
            HError(7170,"TMShowAccs: bad cov kind %d",
                   mp->ckind);
         }
      }
   }
}

/* EXPORT->ShowAccs: show accs attached to hset */
void ShowAccs(HMMSet *hset){ ShowAccsParallel(hset, 0); }

void ShowAccsParallel(HMMSet *hset, int index)
{
   const int mw=12;
   HMMScanState hss;
   StreamElem *ste;
   HLink hmm;
   TrAcc *ta;
   WtAcc *wa;
   MuAcc *ma;
   VaAcc *va;

   NewHMMScan(hset,&hss);
   do {
      hmm = hss.hmm;
      printf("%s\n",hss.mac->id->name);
      while (GoNextState(&hss,TRUE)) {
         printf(" state %d\n",hss.i);
         while (GoNextStream(&hss,TRUE)) {
            ste = hss.ste;
            printf("  stream %d\n",hss.s);
            if (ste->hook != NULL) {
               wa = (WtAcc *)ste->hook;
               printf("   wt occ=%f\n",wa[index].occ);
               ShowVector("   wts=",wa[index].c,mw);
            }
            if (hss.isCont)
               while (GoNextMix(&hss,TRUE)) {
                  printf("   mix %d\n",hss.m);
                  if (!IsSeenV(hss.mp->mean)) {
                     ma = (MuAcc *)GetHook(hss.mp->mean);
                     printf("    mean occ=%f\n",ma[index].occ);
                     ShowVector("    means=",ma[index].mu,mw);
                     TouchV(hss.mp->mean);
                  }
                  if (!IsSeenV(hss.mp->cov.var)) {
                     va = (VaAcc *)GetHook(hss.mp->cov.var);
                     printf("    var occ=%f\n",va[index].occ);
                     switch(hss.mp->ckind){
                     case DIAGC:
                     case INVDIAGC:
                        ShowVector("    vars=",va[index].cov.var,mw);
                        break;
                     case FULLC:
                        ShowTriMat("    covs=",va[index].cov.inv,mw,mw);
                        break;
                     default:
                        HError(7170,"ShowAccs: bad cov kind %d",
                               hss.mp->ckind);
                     }
                     TouchV(hss.mp->cov.var);
                  }
               }
         }
      }
      if (!IsSeenV(hmm->transP)) {
         ta = (TrAcc *)GetHook(hmm->transP);
         ShowVector("  tr oc",ta[index].occ,mw);
         ShowMatrix("  trs",ta[index].tran,mw,mw);
         TouchV(hmm->transP);       
      }
   } while (GoNextHMM(&hss));
   EndHMMScan(&hss);
   
   if (hset->hsKind==TIEDHS)    
      TMShowAccs(hset, index);
}

/* EXPORT->AttachPreComps: attach PreComps to hset */
void AttachPreComps(HMMSet *hset, MemHeap *x)
{
   HMMScanState hss;
   StreamElem *ste;
   HLink hmm;

   prC=0; wtC=0;
   NewHMMScan(hset,&hss);
   do {
      hmm = hss.hmm;
      hmm->hook = (void *)0;  /* used as numEg counter */
      while (GoNextState(&hss,TRUE)) {
         while (GoNextStream(&hss,TRUE)) {
            ste = hss.ste;
            ste->hook = CreateWtAcc(x,hss.M, 1);
            if (hss.isCont)                     /* PLAINHS or SHAREDHS */
               while (GoNextMix(&hss,TRUE)) {
                  if (DoPreComps(hset->hsKind))
                     hss.mp->hook = CreatePreComp(x);
               }
         }
      }
   } while (GoNextHMM(&hss));
   EndHMMScan(&hss);
   if (trace&T_NAC)
      printf("AttachPreComps:  %d wt, %d pr\n",wtC,prC);
}

/* EXPORT->ResetPreComps: reset the precomputed prob fields in hset */
void ResetPreComps(HMMSet *hset)
{
   StreamElem *ste;
   HMMScanState hss;
   WtAcc *wa;
   PreComp *p;
   
   NewHMMScan(hset,&hss);
   do {
      while (GoNextState(&hss,TRUE)) {
         while (GoNextStream(&hss,TRUE)) {
            ste = hss.ste;
            wa = (WtAcc *)ste->hook;
            wa->time = -1; wa->prob = LZERO;
            if (hss.isCont)
               while (GoNextMix(&hss,TRUE)) {
                  p = (PreComp *)hss.mp->hook;
                  p->time = -1; p->prob = LZERO;
               }
         }
      }
   } while (GoNextHMM(&hss));
   EndHMMScan(&hss);
}

/* EXPORT->ResetHMMPreComps: reset the precomputed prob fields in hmm */
void ResetHMMPreComps(HLink hmm, int nStreams)
{
   StateElem *se;
   StreamElem *ste;
   MixtureElem *me;
   WtAcc *wa;
   PreComp *p;
   int i,s,m,nStates,nMixes;

   nStates = hmm->numStates;
   se = hmm->svec+2;
   for (i=2; i<nStates; i++,se++){
      ste = se->info->pdf+1;
      for (s=1;s<=nStreams; s++,ste++){
         wa = (WtAcc *)ste->hook; nMixes = ste->nMix;
         if (wa != NULL) {
            wa->time = -1; wa->prob = LZERO;
            me = ste->spdf.cpdf+1;
            for (m=1; m<=nMixes; m++,me++){
               p = (PreComp *)me->mpdf->hook;
               p->time = -1; p->prob = LZERO;
            }
         }
      }
   }
}

/* DumpPName: dump physical HMM name */
static void DumpPName(FILE *f, char *pname)
{
   WriteString(f,pname,DBL_QUOTE);
   fprintf(f,"\n");
}

/* DumpWtAcc: dump wt acc to file f */
static void DumpWtAcc(FILE *f, WtAcc *wa)
{
   WriteVector(f,wa->c,ldBinary);
   WriteFloat(f,&(wa->occ),1,ldBinary);
   if (!ldBinary) fprintf(f,"\n");
}

/* DumpMuAcc: dump mean acc to file f */
static void DumpMuAcc(FILE *f, MuAcc *ma)
{
   WriteVector(f,ma->mu,ldBinary);
   WriteFloat(f,&(ma->occ),1,ldBinary);
   if (!ldBinary) fprintf(f,"\n");