HError(999,"Can only update linear transforms OR model parameters!");

      xfInfo.useOutXForm = TRUE;

      /* This initialises things - temporary hack - THINK!! */

      CreateAdaptXForm(hset, "tmp");

   } 



   

   /* initialise and  pass information to the forward backward library */

   InitialiseForBack(fbInfo, x, hset, uFlags, pruneInit, pruneInc,

                     pruneLim, minFrwdP);



   if (parMode != 0) {

      ConvLogWt(hset);

   }

   /* 2-model reestimation */

   if (al_hmmUsed){

       if (trace&T_TOP)

           printf("2-model re-estimation enabled\n");

       /* load alignment HMM set */

       CreateHMMSet(&al_hset,&hmmStack,TRUE);

       xfInfo.al_hset = &al_hset;

       if (xfInfo.alXFormExt == NULL) xfInfo.alXFormExt = xfInfo.inXFormExt;

       /* load multiple MMFs */

       if (strlen(al_hmmMMF) > 0 ) {

           char *p,*q;

           Boolean eos;

           p=q=al_hmmMMF;

           for(;;) {

               eos = (*p=='\0');

               if ( ( isspace((int) *p) || *p == '\0' ) && (q!=p) ) {
Exemple #2
0
/* EXPORT->MAPUpdateModels: update all models and save them in newDir if set,
   new files have newExt if set */
void MAPUpdateModels(HMMSet *hset, UPDSet uFlags)
{
  HMMScanState hss;
  HLink hmm;
  int px,nmapped=0,totM;
  long n;

  if (hset->logWt == TRUE) HError(999,"HMap: requires linear weights");

  /* Intialise a few global variables */
  SetVFloor( hset, vFloor, minVar);
  maxM = MaxMixInSet(hset);
  totM = TotMixInSet(hset);
  S = hset->swidth[0];

  if (hset->hsKind == TIEDHS){ /* TIEDHS - update mu & var once per HMMSet */
    HError(999,"TIEDHS kind not currently supported in MAP estimation");
  }

  NewHMMScan(hset,&hss);
  px=1;
  do {   
    hmm = hss.hmm;
    n = (long)hmm->hook;
    if (n<minEgs && !(trace&T_UPD))
      HError(-2331,"UpdateModels: %s[%d] copied: only %d egs\n",
	     HMMPhysName(hset,hmm),px,n);
    if (n>=minEgs && n>0) {
      if (uFlags & UPTRANS)
	HError(999,"No support for MAP updating transition probabilities");
      if (maxM>1 && uFlags & UPMIXES)
	UpdateWeights(hset,px,hmm);
      if (hset->hsKind != TIEDHS){
	if (uFlags & UPVARS)
	  UpdateVars(hset,px,hmm);
	if (uFlags & UPMEANS)
	  nmapped += UpdateMeans(hset,px,hmm);
	if (uFlags & (UPMEANS|UPVARS))
	  FixGConsts(hmm);
      }  
    }
    px++;
  } while (GoNextHMM(&hss));
  EndHMMScan(&hss);
  if (trace&T_TOP) {
    printf("Observed components (means) %d of %d: %.2f\n",nmapped,totM,100*(float)nmapped/(float)totM);
    if (nFloorVar > 0)
      printf("Total %d floored variance elements in %d different mixes\n",
	     nFloorVar,nFloorVarMix);
    fflush(stdout);
  }
   
  /* Reset vfloor */
  ResetVFloor(hset,vFloor);
}
Exemple #3
0
void Initialise(char *hmmListFn)
{   
   /* Stacks for global structures requiring memory allocation */
   CreateHeap(&aSetStack,"ASetStore", MSTAK, 1, 0.0, 1000, 1000);
   CreateHeap(&sSetStack,"SSetStore", MSTAK, 1, 0.0, 1000, 1000);
   CreateHeap(&wsStack,"WsStore", MSTAK, 1, 0.0, 1000, 1000);
   CreateHeap(&labIdStack,"LabIdStore", MSTAK, 1, 0.0, 1000, 1000);
   CreateHeap(&wtAccStack,"WtAccStore", MSTAK, 1, 0.0, 1000, 1000);
   
   /* Load HMMs and init HMMSet related global variables */
   if(MakeHMMSet( &hset, hmmListFn )<SUCCESS)
      HError(2429,"Initialise: MakeHMMSet failed");
   if(LoadHMMSet( &hset,hmmDir,newExt)<SUCCESS)
      HError(2429,"Initialise: LoadHMMSet failed");
   AttachAccs(&hset, &gstack,uFlags);
   ZeroAccs(&hset,uFlags);   
   nPhyHmms = hset.numPhyHMM;
   nLogHmms = hset.numLogHMM;
   vSize = hset.vecSize;
   nStreams = hset.swidth[0];
   maxMixes = MaxMixInSet(&hset);
   maxStates = MaxStatesInSet(&hset);
   hsKind = hset.hsKind;

   /* Store for mix weights accs from each input acc file */
   CreateWtStore(&wtAccStack);

   if ((hsKind != TIEDHS) && (hsKind != DISCRETEHS))
      HError(2421,"Initialise: HMM's must be full Tied Mixture or Discrete");

   if (trace&T_TOP) {
      printf("HSmooth  Updating: ");
      if (uFlags&UPTRANS) printf("Transitions "); 
      if (uFlags&UPMEANS) printf("Means "); 
      if (uFlags&UPVARS)  printf("Variances "); 
      if (uFlags&UPMIXES && maxMixes>1)  printf("MixWeights "); 
      printf("\n ");
      printf("   Max Steps: %d, Epsilon : %f, Max Mixes: %d\n",
             maxStep,epsilon,maxMixes);
      printf("%d Logical/%d Physical Models Loaded, VecSize=%d\n",nLogHmms,nPhyHmms,vSize);
      fflush(stdout);
   }

   SetVFloor( &hset, vFloor, minVar);

   aSet=(HLink *)New(&aSetStack, nPhyHmms*sizeof(HLink));
   --aSet;

   sSet=(StreamElem **)New(&sSetStack, nPhyHmms*sizeof(StreamElem *));
   --sSet;   
}
Exemple #4
0
/* EXPORT->PItemList: parse items in item list setting ilist and type */
char *PItemList(ILink *ilist, char *type, HMMSet *hset,
                Source *s, Boolean itrace)
{
   int rtrace;

   /* Initialise static variables */
   rtrace=trace;
   if (itrace)
      trace|=T_ITM;
   source = s;
   maxMixes = MaxMixInSet(hset);
   maxStates = MaxStatesInSet(hset);
   position=pattern;
   *position=0;

   /* Parse item set */
   ReadCh();
   SkipSpaces();
   if (ch != '{')
      EdError("{ expected");
   ReadCh();
   PItemSet(ilist,type,hset);
   SkipSpaces();
   while (ch == ',') {
      ReadCh();
      PItemSet(ilist,type,hset);
      SkipSpaces();
   }
   if (ch != '}')
      EdError("} expected");

   if (trace & T_ITM)
      fflush(stdout);
   trace=rtrace;

   return(pattern);
}
  xf = xfInfo.paXForm;

  if ((xfInfo.paXForm != NULL) && !(uFlags&UPXFORM)) {

    while (xf != NULL) {

       if ((xf->xformSet->xkind != CMLLR) && (xf->xformSet->xkind != SEMIT))

	HError(999,"SAT only supported with SEMIT/CMLLR transforms");

      xf = xf->parentXForm;

    }

  }

}



int main(int argc, char *argv[])

{

   char *datafn=NULL;

   char *datafn2=NULL;

   char *s;

   char *scriptFile;

   char datafn1[MAXSTRLEN];

   char newFn[MAXSTRLEN];

   FILE *f;

   UttInfo *utt;            /* utterance information storage */

   FBInfo *fbInfo;          /* forward-backward information storage */

   HMMSet hset;             /* Set of HMMs to be re-estimated */

   Source src;

   float tmpFlt;

   int tmpInt;

   int numUtt,spUtt=0;



   void Initialise(FBInfo *fbInfo, MemHeap *x, HMMSet *hset, char *hmmListFn);

   void DoForwardBackward(FBInfo *fbInfo, UttInfo *utt, char *datafn, char *datafn2);

   void UpdateModels(HMMSet *hset, ParmBuf pbuf2);

   void StatReport(HMMSet *hset);

   

   if(InitShell(argc,argv,herest_version,herest_vc_id)<SUCCESS)

      HError(2300,"HERest: InitShell failed");

   InitMem();    InitMath();

   InitSigP();   InitAudio();

   InitWave();   InitVQ();

   InitLabel();  InitModel();

   if(InitParm()<SUCCESS)  

      HError(2300,"HERest: InitParm failed");

   InitTrain();

   InitUtil();   InitFB();

   InitAdapt(&xfInfo); InitMap();



   if (!InfoPrinted() && NumArgs() == 0)

      ReportUsage();

   if (NumArgs() == 0) Exit(0);

   al_hmmDir[0] = '\0'; al_hmmExt[0] = '\0'; 

   al_hmmMMF[0] = '\0'; al_hmmLst[0] = '\0'; 

   up_hmmMMF[0] = '\0';

   CreateHeap(&hmmStack,"HmmStore", MSTAK, 1, 1.0, 50000, 500000);

   SetConfParms(); 

   CreateHMMSet(&hset,&hmmStack,TRUE);

   CreateHeap(&uttStack,   "uttStore",    MSTAK, 1, 0.5, 100,   1000);

   utt = (UttInfo *) New(&uttStack, sizeof(UttInfo));

   CreateHeap(&fbInfoStack,   "FBInfoStore",  MSTAK, 1, 0.5, 100 ,  1000 );

   fbInfo = (FBInfo *) New(&fbInfoStack, sizeof(FBInfo));

   CreateHeap(&accStack,   "accStore",    MSTAK, 1, 1.0, 50000,   500000);



   while (NextArg() == SWITCHARG) {

      s = GetSwtArg();

      if (strlen(s)!=1) 

         HError(2319,"HERest: Bad switch %s; must be single letter",s);

      switch(s[0]){

      case 'b':

         if (NextArg()!=STRINGARG)

            HError(2319,"HERest: script file expected");

         scriptFile = GetStrArg(); break;
                       printf("Loading alignment HMM set %s\n",q);

                   }

                   AddMMF(&al_hset,q);

                   if (eos)

                       break;

                   q=p+1;

               }

               p++;

           }

       }

       if (strlen(al_hmmLst) > 0 ) 

           MakeHMMSet(&al_hset, al_hmmLst );

       else /* use same hmmList */

           MakeHMMSet(&al_hset, hmmListFn );

       if (strlen(al_hmmDir) > 0 )

           LoadHMMSet(&al_hset,al_hmmDir,al_hmmExt);

       else

           LoadHMMSet(&al_hset,NULL,NULL);



       /* switch model set */

       UseAlignHMMSet(fbInfo,x,&al_hset);

       if (parMode != 0) {

	  ConvDiagC(&al_hset,TRUE);

	  ConvLogWt(&al_hset);

       }



       /* and echo status */

       if (trace&T_TOP) { 

           if (strlen(al_hmmDir) > 0 )

               printf(" HMM Dir %s",al_hmmDir);

           if (strlen(al_hmmExt) > 0 )

               printf(" Ext %s",al_hmmExt);
Exemple #7
0
void Initialise(void)
{
   /* load HMM mmf */
   if (MakeHMMSet(&hmset, GetStrArg()) < SUCCESS)
      HError(9928, "Initialise: MakeHMMSet failed");
   if (LoadHMMSet(&hmset, hmmDir, hmmExt) < SUCCESS)
      HError(9928, "Initialise: LoadHMMSet failed");
   if (hmset.hsKind == DISCRETEHS)
      HError(9999, "Initialise: Only continuous model is surpported");
   ConvDiagC(&hmset, TRUE);

   if (trace & T_TOP) {
      PrintrFlags();
      printf("HMMSet is ");
      switch (hmset.hsKind) {
      case PLAINHS:
         printf("PLAIN\n");
         break;
      case SHAREDHS:
         printf("SHARED\n");
         break;
      case TIEDHS:
         printf("TIED\n");
         break;
      default:
         HError(9999, "Initialise: Only continuous model is supported");
      }

      printf("%d Logical/%d Physical Models Loaded, VecSize=%d\n", hmset.numLogHMM, hmset.numPhyHMM, hmset.vecSize);
      if (hmset.numFiles > 0)
         printf("%d MMF input files\n", hmset.numFiles);
      fflush(stdout);
   }

   /* load duration mmf */
   if (!stateAlign) {
      if (MakeHMMSet(&dmset, GetStrArg()) < SUCCESS)
         HError(9928, "Initialise: MakeHMMSet failed");
      if (LoadHMMSet(&dmset, dmDir, dmExt) < SUCCESS)
         HError(9928, "Initialise: LoadHMMSet failed");
      if (hmset.hsKind == DISCRETEHS)
         HError(9999, "Initialise: Only continuous duration model mmf is surpported");
      ConvDiagC(&dmset, TRUE);

      if (trace & T_TOP) {
         printf("DurationModelSet is ");
         switch (dmset.hsKind) {
         case PLAINHS:
            printf("PLAIN\n");
            break;
         case SHAREDHS:
            printf("SHARED\n");
            break;
         case TIEDHS:
            printf("TIED\n");
            break;
         default:
            HError(9999, "Initialise: Only continuous model is supported");
         }

         printf("%d Logical/%d Physical Models Loaded, VecSize=%d\n", dmset.numLogHMM, dmset.numPhyHMM, dmset.vecSize);
         if (dmset.numFiles > 0)
            printf("%d MMF input files\n", dmset.numFiles);
         fflush(stdout);
      }
   }

   /* setup GenInfo */
   genInfo->genMem = &genStack;
   genInfo->hset = &hmset;
   genInfo->dset = &dmset;
   genInfo->maxStates = MaxStatesInSet(&hmset);
   genInfo->maxMixes = MaxMixInSet(&hmset);
   genInfo->speakRate = speakRate;
   genInfo->MSDthresh = MSDthresh;
   genInfo->modelAlign = modelAlign;
   genInfo->stateAlign = stateAlign;
   genInfo->frameRate = frameRate;

   CheckGenSetUp();

   /* setup EM-based parameter generation */
   AttachAccs(&hmset, &gstack, (UPDSet) 0);
   ZeroAccs(&hmset, (UPDSet) 0);

   if (!stateAlign) {
      AttachAccs(&dmset, &gstack, (UPDSet) 0);
      ZeroAccs(&dmset, (UPDSet) 0);
   }

   if (type != CHOLESKY)
      InitialiseForBack(fbInfo, &fbInfoStack, &hmset, (UPDSet) 0, ((useHMMFB || stateAlign) ? NULL : &dmset), (UPDSet) 0, pruneInit, pruneInc, pruneLim, minFrwdP, useAlign, FALSE);

   /* handle input xform */
   xfInfo_hmm.inFullC = xfInfo_dur.inFullC = TRUE;

   /* semi-tied case */
   if (hmset.semiTied != NULL) {
      SetXForm(&hmset, NULL, hmset.semiTied);
      ApplyHMMSetXForm(&hmset, hmset.semiTied, TRUE);
   }

   /* linear weight -> log weight */
   ConvLogWt(&hmset);
}
Exemple #8
0
/* Initialise: set up global data structures */
void Initialise(void)
{
   Boolean eSep;
   int s;

   /* Load hmms, convert to inverse DiagC */
   if(MakeHMMSet(&hset,hmmListFn)<SUCCESS) 
      HError(3228,"Initialise: MakeHMMSet failed");
   if(LoadHMMSet(&hset,hmmDir,hmmExt)<SUCCESS) 
      HError(3228,"Initialise: LoadHMMSet failed");
   ConvDiagC(&hset,TRUE);
   
   /* Create observation and storage for input buffer */
   SetStreamWidths(hset.pkind,hset.vecSize,hset.swidth,&eSep);
   obs=MakeObservation(&gstack,hset.swidth,hset.pkind,
                       hset.hsKind==DISCRETEHS,eSep);

   /* sort out masks just in case using adaptation */
   if (xfInfo.inSpkrPat == NULL) xfInfo.inSpkrPat = xfInfo.outSpkrPat; 
   if (xfInfo.paSpkrPat == NULL) xfInfo.paSpkrPat = xfInfo.outSpkrPat; 

   if (xfInfo.useOutXForm || (update>0)) {
      CreateHeap(&regHeap,   "regClassStore",  MSTAK, 1, 0.5, 1000, 8000 );
      /* This initialises things - temporary hack - THINK!! */
      CreateAdaptXForm(&hset, "tmp");
      /* initialise structures for the f-b frame-state alignment pass */
      utt = (UttInfo *) New(&regHeap, sizeof(UttInfo));
      fbInfo = (FBInfo *) New(&regHeap, sizeof(FBInfo));
      /* initialise a recogniser for frame/state alignment purposes */
      alignpsi=InitPSetInfo(&hset);
      alignvri=InitVRecInfo(alignpsi,1,TRUE,FALSE);
      SetPruningLevels(alignvri,0,genBeam,-LZERO,0.0,tmBeam);
      InitUttInfo(utt, FALSE);
      InitialiseForBack(fbInfo, &regHeap, &hset,
                        (UPDSet) (UPXFORM), genBeam*2.0, genBeam*2.0, 
                        genBeam*4.0+1.0, 10.0);
      utt->twoDataFiles = FALSE;
      utt->S = hset.swidth[0]; 
      AttachPreComps(&hset,hset.hmem);
   }
    
   CreateHeap(&bufHeap,"Input Buffer heap",MSTAK,1,0.0,50000,50000);
   CreateHeap(&repHeap,"Replay Buffer heap",MSTAK,1,0.0,50000,50000);
   
   maxM = MaxMixInSet(&hset);
   for (s=1; s<=hset.swidth[0]; s++)
      maxMixInS[s] = MaxMixInSetS(&hset, s);
   if (trace&T_TOP) {
      printf("Read %d physical / %d logical HMMs\n",
             hset.numPhyHMM,hset.numLogHMM);  fflush(stdout);
   }
   
   /* Initialise recogniser */
   if (nToks>1) nBeam=genBeam;
   psi=InitPSetInfo(&hset);
   vri=InitVRecInfo(psi,nToks,models,states);

   /* Read dictionary and create storage for lattice */
   InitVocab(&vocab);   
   if(ReadDict(dictFn,&vocab)<SUCCESS) 
      HError(3213, "Main: ReadDict failed");
   CreateHeap(&ansHeap,"Lattice heap",MSTAK,1,0.0,4000,4000);
   if (trace & T_MEM){
      printf("Memory State After Initialisation\n");
      PrintAllHeapStats();
   }
}