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) ) {
/* 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);
}
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;
}
/* 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);
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);
}
/* 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(®Heap, "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(®Heap, sizeof(UttInfo));
fbInfo = (FBInfo *) New(®Heap, 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, ®Heap, &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();
}
}