s3pid_t
mdef_phone_id(mdef_t * m,
s3cipid_t ci, s3cipid_t lc, s3cipid_t rc, word_posn_t wpos)
{
ph_lc_t *lcptr;
ph_rc_t *rcptr;
s3cipid_t newl, newr;
assert(m);
assert((ci >= 0) && (ci < m->n_ciphone));
assert((lc >= 0) && (lc < m->n_ciphone));
assert((rc >= 0) && (rc < m->n_ciphone));
assert((wpos >= 0) && (wpos < N_WORD_POSN));
if (((lcptr =
find_ph_lc(m->wpos_ci_lclist[wpos][(int) ci], lc)) == NULL)
|| ((rcptr = find_ph_rc(lcptr->rclist, rc)) == NULL)) {
/* Not found; backoff to silence context if non-silence filler context */
if (NOT_S3CIPID(m->sil))
return BAD_S3PID;
newl = m->ciphone[(int) lc].filler ? m->sil : lc;
newr = m->ciphone[(int) rc].filler ? m->sil : rc;
if ((newl == lc) && (newr == rc))
return BAD_S3PID;
return (mdef_phone_id(m, ci, newl, newr, wpos));
}
return (rcptr->pid);
}
static int32
dict_read(FILE * fp, dict_t * d)
{
lineiter_t *li;
char **wptr;
s3cipid_t *p;
int32 lineno, nwd;
s3wid_t w;
int32 i, maxwd;
size_t stralloc, phnalloc;
maxwd = 512;
p = (s3cipid_t *) ckd_calloc(maxwd + 4, sizeof(*p));
wptr = (char **) ckd_calloc(maxwd, sizeof(char *)); /* Freed below */
lineno = 0;
stralloc = phnalloc = 0;
for (li = lineiter_start(fp); li; li = lineiter_next(li)) {
lineno++;
if (0 == strncmp(li->buf, "##", 2)
|| 0 == strncmp(li->buf, ";;", 2))
continue;
if ((nwd = str2words(li->buf, wptr, maxwd)) < 0) {
/* Increase size of p, wptr. */
nwd = str2words(li->buf, NULL, 0);
assert(nwd > maxwd); /* why else would it fail? */
maxwd = nwd;
p = (s3cipid_t *) ckd_realloc(p, (maxwd + 4) * sizeof(*p));
wptr = (char **) ckd_realloc(wptr, maxwd * sizeof(*wptr));
}
if (nwd == 0) /* Empty line */
continue;
/* wptr[0] is the word-string and wptr[1..nwd-1] the pronunciation sequence */
if (nwd == 1) {
E_ERROR("Line %d: No pronunciation for word %s; ignored\n",
lineno, wptr[0]);
continue;
}
/* Convert pronunciation string to CI-phone-ids */
for (i = 1; i < nwd; i++) {
p[i - 1] = dict_ciphone_id(d, wptr[i]);
if (NOT_S3CIPID(p[i - 1])) {
E_ERROR("Line %d: Bad ciphone: %s; word %s ignored\n",
lineno, wptr[i], wptr[0]);
break;
}
}
if (i == nwd) { /* All CI-phones successfully converted to IDs */
w = dict_add_word(d, wptr[0], p, nwd - 1);
if (NOT_S3WID(w))
E_ERROR
("Line %d: dict_add_word (%s) failed (duplicate?); ignored\n",
lineno, wptr[0]);
else {
stralloc += strlen(d->word[w].word);
phnalloc += d->word[w].pronlen * sizeof(s3cipid_t);
}
}
}
E_INFO("Allocated %d KiB for strings, %d KiB for phones\n",
(int)stralloc / 1024, (int)phnalloc / 1024);
ckd_free(p);
ckd_free(wptr);
return 0;
}
/*ARCHAN, to allow backward compatibility -lm, -lmctlfn coexists. This makes the current implmentation more complicated than necessary. */
void kb_init (kb_t *kb)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
lm_t *lm;
lmset_t *lmset;
s3cipid_t sil, ci;
s3wid_t w;
int32 i, n, n_lc;
wordprob_t *wp;
s3cipid_t *lc;
bitvec_t lc_active;
char *str;
int32 cisencnt;
int32 j;
/* Initialize the kb structure to zero, just in case */
memset(kb, 0, sizeof(*kb));
kb->kbcore = NULL;
kb->kbcore = kbcore_init (cmd_ln_float32 ("-logbase"),
cmd_ln_str("-feat"),
cmd_ln_str("-cmn"),
cmd_ln_str("-varnorm"),
cmd_ln_str("-agc"),
cmd_ln_str("-mdef"),
cmd_ln_str("-dict"),
cmd_ln_str("-fdict"),
"", /* Hack!! Hardwired constant
for -compsep argument */
cmd_ln_str("-lm"),
cmd_ln_str("-lmctlfn"),
cmd_ln_str("-lmdumpdir"),
cmd_ln_str("-fillpen"),
cmd_ln_str("-senmgau"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_float32("-uw"),
cmd_ln_str("-mean"),
cmd_ln_str("-var"),
cmd_ln_float32("-varfloor"),
cmd_ln_str("-mixw"),
cmd_ln_float32("-mixwfloor"),
cmd_ln_str("-subvq"),
cmd_ln_str("-gs"),
cmd_ln_str("-tmat"),
cmd_ln_float32("-tmatfloor"));
if(kb->kbcore==NULL){
E_FATAL("Initialization of kb failed\n");
}
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
lm = kbcore_lm(kbcore);
lmset=kbcore_lmset(kbcore);
d2p = kbcore_dict2pid(kbcore);
if (NOT_S3WID(dict_startwid(dict)) || NOT_S3WID(dict_finishwid(dict)))
E_FATAL("%s or %s not in dictionary\n", S3_START_WORD, S3_FINISH_WORD);
if(lmset){
for(i=0;i<kbcore_nlm(kbcore);i++){
if (NOT_S3LMWID(lm_startwid(lmset[i].lm)) || NOT_S3LMWID(lm_finishwid(lmset[i].lm)))
E_FATAL("%s or %s not in LM %s\n", S3_START_WORD, S3_FINISH_WORD,lmset[i].name);
}
}else if(lm){
if (NOT_S3LMWID(lm_startwid(lm)) || NOT_S3LMWID(lm_finishwid(lm)))
E_FATAL("%s or %s not in LM\n", S3_START_WORD, S3_FINISH_WORD);
}
/* Check that HMM topology restrictions are not violated */
if (tmat_chk_1skip (kbcore->tmat) < 0)
E_FATAL("Tmat contains arcs skipping more than 1 state\n");
/*
* Unlink <s> and </s> between dictionary and LM, to prevent their
* recognition. They are merely dummy words (anchors) at the beginning
* and end of each utterance.
*/
if(lmset){
for(i=0;i<kbcore_nlm(kbcore);i++){
lm_lmwid2dictwid(lmset[i].lm, lm_startwid(lmset[i].lm)) = BAD_S3WID;
lm_lmwid2dictwid(lmset[i].lm, lm_finishwid(lmset[i].lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
lmset[i].lm->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
lmset[i].lm->dict2lmwid[w] = BAD_S3LMWID;
}
}else if(lm){ /* No LM is set at this point*/
lm_lmwid2dictwid(lm, lm_startwid(lm)) = BAD_S3WID;
lm_lmwid2dictwid(lm, lm_finishwid(lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
}
sil = mdef_silphone (kbcore_mdef (kbcore));
if (NOT_S3CIPID(sil))
E_FATAL("Silence phone '%s' not in mdef\n", S3_SILENCE_CIPHONE);
kb->sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->rec_sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->ssid_active = (int32 *) ckd_calloc (mdef_n_sseq(mdef), sizeof(int32));
kb->comssid_active = (int32 *) ckd_calloc (dict2pid_n_comsseq(d2p), sizeof(int32));
/* Build set of all possible left contexts */
lc = (s3cipid_t *) ckd_calloc (mdef_n_ciphone(mdef) + 1, sizeof(s3cipid_t));
lc_active = bitvec_alloc (mdef_n_ciphone (mdef));
for (w = 0; w < dict_size (dict); w++) {
ci = dict_pron (dict, w, dict_pronlen(dict, w) - 1);
if (! mdef_is_fillerphone (mdef, (int)ci))
bitvec_set (lc_active, ci);
}
ci = mdef_silphone(mdef);
bitvec_set (lc_active, ci);
for (ci = 0, n_lc = 0; ci < mdef_n_ciphone(mdef); ci++) {
if (bitvec_is_set (lc_active, ci))
lc[n_lc++] = ci;
}
lc[n_lc] = BAD_S3CIPID;
E_INFO("Building lextrees\n");
/* Get the number of lexical tree*/
kb->n_lextree = cmd_ln_int32 ("-Nlextree");
if (kb->n_lextree < 1) {
E_ERROR("No. of ugtrees specified: %d; will instantiate 1 ugtree\n",
kb->n_lextree);
kb->n_lextree = 1;
}
/* ARCHAN: This code was rearranged in s3.4 implementation of dynamic LM */
/* Build active word list */
wp = (wordprob_t *) ckd_calloc (dict_size(dict), sizeof(wordprob_t));
if(lmset){
kb->ugtreeMulti = (lextree_t **) ckd_calloc (kbcore_nlm(kbcore)*kb->n_lextree, sizeof(lextree_t *));
/* Just allocate pointers*/
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for(i=0;i<kbcore_nlm(kbcore);i++){
E_INFO("Creating Unigram Table for lm %d name %s\n",i,lmset[i].name);
n=0;
for(j=0;j<dict_size(dict);j++){ /*try to be very careful again */
wp[j].wid=-1;
wp[j].prob=-1;
}
n = lm_ug_wordprob (lmset[i].lm, dict,MAX_NEG_INT32, wp);
E_INFO("Size of word table after unigram + words in class: %d.\n",n);
if (n < 1)
E_FATAL("%d active words in %s\n", n,lmset[i].name);
n = wid_wordprob2alt(dict,wp,n);
E_INFO("Size of word table after adding alternative prons: %d.\n",n);
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
for (j = 0; j < kb->n_lextree; j++) {
kb->ugtreeMulti[i*kb->n_lextree+j] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtreeMulti[i*kb->n_lextree+j]) = 0;
E_INFO("Lextrees (%d) for lm %d name %s, %d nodes(ug)\n",
kb->n_lextree, i, lmset[i].name,lextree_n_node(kb->ugtreeMulti[i*kb->n_lextree+j]));
}
}
}else if (lm){
E_INFO("Creating Unigram Table\n");
n=0;
n = lm_ug_wordprob (lm, dict,MAX_NEG_INT32, wp);
E_INFO("Size of word table after unigram + words in class: %d\n",n);
if (n < 1)
E_FATAL("%d active words\n", n);
n = wid_wordprob2alt (dict, wp, n); /* Add alternative pronunciations */
/* Retain or remove unigram probs from lextree, depending on option */
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
/* Create the desired no. of unigram lextrees */
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for (i = 0; i < kb->n_lextree; i++) {
kb->ugtree[i] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtree[i]) = 0;
}
E_INFO("Lextrees(%d), %d nodes(ug)\n",
kb->n_lextree, lextree_n_node(kb->ugtree[0]));
}
/* Create filler lextrees */
/* ARCHAN : only one filler tree is supposed to be build even for dynamic LMs */
n = 0;
for (i = dict_filler_start(dict); i <= dict_filler_end(dict); i++) {
if (dict_filler_word(dict, i)) {
wp[n].wid = i;
wp[n].prob = fillpen (kbcore->fillpen, i);
n++;
}
}
kb->fillertree = (lextree_t **)ckd_calloc(kb->n_lextree,sizeof(lextree_t*));
for (i = 0; i < kb->n_lextree; i++) {
kb->fillertree[i] = lextree_build (kbcore, wp, n, NULL);
lextree_type (kb->fillertree[i]) = -1;
}
ckd_free ((void *) wp);
ckd_free ((void *) lc);
bitvec_free (lc_active);
E_INFO("Lextrees(%d), %d nodes(filler)\n",
kb->n_lextree,
lextree_n_node(kb->fillertree[0]));
if (cmd_ln_int32("-lextreedump")) {
if(lmset){
E_FATAL("Currently, doesn't support -lextreedump for multiple-LMs\n");
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "UGTREE %d\n", i);
lextree_dump (kb->ugtree[i], dict, stderr);
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "FILLERTREE %d\n", i);
lextree_dump (kb->fillertree[i], dict, stderr);
}
fflush (stderr);
}
kb->ascr = ascr_init (mgau_n_mgau(kbcore_mgau(kbcore)),
kbcore->dict2pid->n_comstate);
kb->beam = beam_init (cmd_ln_float64("-subvqbeam"),
cmd_ln_float64("-beam"),
cmd_ln_float64("-pbeam"),
cmd_ln_float64("-wbeam"));
E_INFO("Beam= %d, PBeam= %d, WBeam= %d, SVQBeam= %d\n",
kb->beam->hmm, kb->beam->ptrans, kb->beam->word, kb->beam->subvq);
/*Sections of optimization related parameters*/
kb->ds_ratio=cmd_ln_int32("-ds");
E_INFO("Down Sampling Ratio = %d\n",kb->ds_ratio);
kb->rec_bstcid=-1;
kb->skip_count=0;
kb->cond_ds=cmd_ln_int32("-cond_ds");
E_INFO("Conditional Down Sampling Parameter = %d\n",kb->cond_ds);
if(kb->cond_ds>0&&kb->kbcore->gs==NULL) E_FATAL("Conditional Down Sampling require the use of Gaussian Selection map\n");
kb->gs4gs=cmd_ln_int32("-gs4gs");
E_INFO("GS map would be used for Gaussian Selection? = %d\n",kb->gs4gs);
kb->svq4svq=cmd_ln_int32("-svq4svq");
E_INFO("SVQ would be used as Gaussian Score ?= %d\n",kb->svq4svq);
kb->ci_pbeam=-1*logs3(cmd_ln_float32("-ci_pbeam"));
E_INFO("CI phone beam to prune the number of parent CI phones in CI-base GMM Selection = %d\n",kb->ci_pbeam);
if(kb->ci_pbeam>10000000){
E_INFO("Virtually no CI phone beam is applied now. (ci_pbeam>1000000)\n");
}
kb->wend_beam=-1*logs3(cmd_ln_float32("-wend_beam"));
E_INFO("Word-end pruning beam: %d\n",kb->wend_beam);
kb->pl_window=cmd_ln_int32("-pl_window");
E_INFO("Phoneme look-ahead window size = %d\n",kb->pl_window);
kb->pl_window_start=0;
kb->pl_beam=logs3(cmd_ln_float32("-pl_beam"));
E_INFO("Phoneme look-ahead beam = %d\n",kb->pl_beam);
for(cisencnt=0;cisencnt==mdef->cd2cisen[cisencnt];cisencnt++)
;
kb->cache_ci_senscr=(int32**)ckd_calloc_2d(kb->pl_window,cisencnt,sizeof(int32));
kb->cache_best_list=(int32*)ckd_calloc(kb->pl_window,sizeof(int32));
kb->phn_heur_list=(int32*)ckd_calloc(mdef_n_ciphone (mdef),sizeof(int32));
if ((kb->feat = feat_array_alloc(kbcore_fcb(kbcore),S3_MAX_FRAMES)) == NULL)
E_FATAL("feat_array_alloc() failed\n");
kb->vithist = vithist_init(kbcore, kb->beam->word, cmd_ln_int32("-bghist"));
ptmr_init (&(kb->tm_sen));
ptmr_init (&(kb->tm_srch));
ptmr_init (&(kb->tm_ovrhd));
kb->tot_fr = 0;
kb->tot_sen_eval = 0.0;
kb->tot_gau_eval = 0.0;
kb->tot_hmm_eval = 0.0;
kb->tot_wd_exit = 0.0;
kb->hmm_hist_binsize = cmd_ln_int32("-hmmhistbinsize");
if(lmset)
n = ((kb->ugtreeMulti[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
else
n = ((kb->ugtree[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
n /= kb->hmm_hist_binsize;
kb->hmm_hist_bins = n+1;
kb->hmm_hist = (int32 *) ckd_calloc (n+1, sizeof(int32)); /* Really no need for +1 */
/* Open hypseg file if specified */
str = cmd_ln_str("-hypseg");
kb->matchsegfp = NULL;
if (str) {
#ifdef SPEC_CPU_WINDOWS
if ((kb->matchsegfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchsegfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
str = cmd_ln_str("-hyp");
kb->matchfp = NULL;
if (str) {
#ifdef SPEC_CPU_WINDOWS
if ((kb->matchfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
}
void kb_init (kb_t *kb)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
lm_t *lm;
s3cipid_t sil, ci;
s3wid_t w;
int32 i, n, n_lc;
wordprob_t *wp;
s3cipid_t *lc;
bitvec_t lc_active;
char *str;
/* Initialize the kb structure to zero, just in case */
memset(kb, 0, sizeof(*kb));
kb->kbcore = kbcore_init (cmd_ln_float32 ("-logbase"),
"1s_c_d_dd", /* Hack!! Hardwired constant
for -feat argument */
cmd_ln_str("-cmn"),
cmd_ln_str("-varnorm"),
cmd_ln_str("-agc"),
cmd_ln_str("-mdef"),
cmd_ln_str("-dict"),
cmd_ln_str("-fdict"),
"", /* Hack!! Hardwired constant
for -compsep argument */
cmd_ln_str("-lm"),
cmd_ln_str("-fillpen"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_float32("-uw"),
cmd_ln_str("-mean"),
cmd_ln_str("-var"),
cmd_ln_float32("-varfloor"),
cmd_ln_str("-mixw"),
cmd_ln_float32("-mixwfloor"),
cmd_ln_str("-subvq"),
cmd_ln_str("-tmat"),
cmd_ln_float32("-tmatfloor"));
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
lm = kbcore_lm(kbcore);
d2p = kbcore_dict2pid(kbcore);
if (NOT_S3WID(dict_startwid(dict)) || NOT_S3WID(dict_finishwid(dict)))
E_FATAL("%s or %s not in dictionary\n", S3_START_WORD, S3_FINISH_WORD);
if (NOT_S3LMWID(lm_startwid(lm)) || NOT_S3LMWID(lm_finishwid(lm)))
E_FATAL("%s or %s not in LM\n", S3_START_WORD, S3_FINISH_WORD);
/* Check that HMM topology restrictions are not violated */
if (tmat_chk_1skip (kbcore->tmat) < 0)
E_FATAL("Tmat contains arcs skipping more than 1 state\n");
/*
* Unlink <s> and </s> between dictionary and LM, to prevent their
* recognition. They are merely dummy words (anchors) at the beginning
* and end of each utterance.
*/
lm_lmwid2dictwid(lm, lm_startwid(lm)) = BAD_S3WID;
lm_lmwid2dictwid(lm, lm_finishwid(lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
sil = mdef_silphone (kbcore_mdef (kbcore));
if (NOT_S3CIPID(sil))
E_FATAL("Silence phone '%s' not in mdef\n", S3_SILENCE_CIPHONE);
E_INFO("Building lextrees\n");
kb->sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->ssid_active = (int32 *) ckd_calloc (mdef_n_sseq(mdef), sizeof(int32));
kb->comssid_active = (int32 *) ckd_calloc (dict2pid_n_comsseq(d2p),
sizeof(int32));
/* Build active word list */
wp = (wordprob_t *) ckd_calloc (dict_size(dict), sizeof(wordprob_t));
n = lm_ug_wordprob (lm, MAX_NEG_INT32, wp);
if (n < 1)
E_FATAL("%d active words\n", n);
n = wid_wordprob2alt (dict, wp, n); /* Add alternative pronunciations */
/* Retain or remove unigram probs from lextree, depending on option */
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
/* Build set of all possible left contexts */
lc = (s3cipid_t *) ckd_calloc (mdef_n_ciphone(mdef) + 1, sizeof(s3cipid_t));
lc_active = bitvec_alloc (mdef_n_ciphone (mdef));
for (w = 0; w < dict_size (dict); w++) {
ci = dict_pron (dict, w, dict_pronlen(dict, w) - 1);
if (! mdef_is_fillerphone (mdef, (int)ci))
bitvec_set (lc_active, ci);
}
ci = mdef_silphone(mdef);
bitvec_set (lc_active, ci);
for (ci = 0, n_lc = 0; ci < mdef_n_ciphone(mdef); ci++) {
if (bitvec_is_set (lc_active, ci))
lc[n_lc++] = ci;
}
lc[n_lc] = BAD_S3CIPID;
/* Create the desired no. of unigram lextrees */
kb->n_lextree = cmd_ln_int32 ("-Nlextree");
if (kb->n_lextree < 1) {
E_ERROR("No. of ugtrees specified: %d; will instantiate 1 ugtree\n",
kb->n_lextree);
kb->n_lextree = 1;
}
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for (i = 0; i < kb->n_lextree; i++) {
kb->ugtree[i] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtree[i]) = 0;
}
bitvec_free (lc_active);
ckd_free ((void *) lc);
/* Create filler lextrees */
n = 0;
for (i = dict_filler_start(dict); i <= dict_filler_end(dict); i++) {
if (dict_filler_word(dict, i)) {
wp[n].wid = i;
wp[n].prob = fillpen (kbcore->fillpen, i);
n++;
}
}
kb->fillertree = (lextree_t **)ckd_calloc(kb->n_lextree,sizeof(lextree_t*));
for (i = 0; i < kb->n_lextree; i++) {
kb->fillertree[i] = lextree_build (kbcore, wp, n, NULL);
lextree_type (kb->fillertree[i]) = -1;
}
ckd_free ((void *) wp);
E_INFO("Lextrees(%d), %d nodes(ug), %d nodes(filler)\n",
kb->n_lextree, lextree_n_node(kb->ugtree[0]),
lextree_n_node(kb->fillertree[0]));
if (cmd_ln_int32("-lextreedump")) {
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "UGTREE %d\n", i);
lextree_dump (kb->ugtree[i], dict, stderr);
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "FILLERTREE %d\n", i);
lextree_dump (kb->fillertree[i], dict, stderr);
}
fflush (stderr);
}
kb->ascr = ascr_init (mgau_n_mgau(kbcore_mgau(kbcore)),
kbcore->dict2pid->n_comstate);
kb->beam = beam_init (cmd_ln_float64("-subvqbeam"),
cmd_ln_float64("-beam"),
cmd_ln_float64("-pbeam"),
cmd_ln_float64("-wbeam"));
E_INFO("Beam= %d, PBeam= %d, WBeam= %d, SVQBeam= %d\n",
kb->beam->hmm, kb->beam->ptrans, kb->beam->word, kb->beam->subvq);
if ((kb->feat = feat_array_alloc(kbcore_fcb(kbcore),S3_MAX_FRAMES)) == NULL)
E_FATAL("feat_array_alloc() failed\n");
kb->vithist = vithist_init(kbcore, kb->beam->word, cmd_ln_int32("-bghist"));
ptmr_init (&(kb->tm_sen));
ptmr_init (&(kb->tm_srch));
kb->tot_fr = 0;
kb->tot_sen_eval = 0.0;
kb->tot_gau_eval = 0.0;
kb->tot_hmm_eval = 0.0;
kb->tot_wd_exit = 0.0;
kb->hmm_hist_binsize = cmd_ln_int32("-hmmhistbinsize");
n = ((kb->ugtree[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
n /= kb->hmm_hist_binsize;
kb->hmm_hist_bins = n+1;
kb->hmm_hist = (int32 *) ckd_calloc (n+1, sizeof(int32)); /* Really no need for +1 */
/* Open hypseg file if specified */
str = cmd_ln_str("-hypseg");
kb->matchsegfp = NULL;
if (str) {
#ifdef WIN32
if ((kb->matchsegfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchsegfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
}
static int32
dict_read(FILE * fp, dict_t * d)
{
char line[16384], **wptr;
s3cipid_t p[4096];
int32 lineno, nwd;
s3wid_t w;
int32 i, maxwd;
s3cipid_t ci;
int32 ph;
maxwd = 4092;
wptr = (char **) ckd_calloc(maxwd, sizeof(char *)); /* Freed below */
lineno = 0;
while (fgets(line, sizeof(line), fp) != NULL) {
lineno++;
if (line[0] == '#') /* Comment line */
continue;
if ((nwd = str2words(line, wptr, maxwd)) < 0)
E_FATAL("str2words(%s) failed; Increase maxwd from %d\n", line,
maxwd);
if (nwd == 0) /* Empty line */
continue;
/* wptr[0] is the word-string and wptr[1..nwd-1] the pronunciation sequence */
if (nwd == 1) {
E_ERROR("Line %d: No pronunciation for word %s; ignored\n",
lineno, wptr[0]);
continue;
}
{char * fin;
float proba=0.0;
int deca=0;
proba=strtod(wptr[1],&fin);
if (fin !=wptr[1])
deca=1;
else
proba=0.0;
/* Convert pronunciation string to CI-phone-ids */
for (i = 1; i < nwd-deca; i++) {
p[i - 1] = dict_ciphone_id(d, wptr[i+deca]);
if (NOT_S3CIPID(p[i - 1])) {
E_ERROR("Line %d: Bad ciphone: %s; word %s ignored\n",
lineno, wptr[i], wptr[0]);
break;
}
}
if (i == nwd-deca) { /* All CI-phones successfully converted to IDs */
w = dict_add_word(d, wptr[0], p, nwd - 1-deca);
if (NOT_S3WID(w))
E_ERROR
("Line %d: dict_add_word (%s) failed (duplicate?); ignored\n",
lineno, wptr[0]);
d->word[w].proba=proba;
}
}
}
if (d->lts_rules) {
#if 1 /* Until we allow user to put in a mapping of the phoneset from LTS to the phoneset from mdef,
The checking will intrusively stop the recognizer. */
for (ci = 0; ci < mdef_n_ciphone(d->mdef); ci++) {
if (!mdef_is_fillerphone(d->mdef, ci)) {
for (ph = 0; cmu6_lts_phone_table[ph] != NULL; ph++) {
/* E_INFO("%s %s\n",cmu6_lts_phone_table[ph],mdef_ciphone_str(d->mdef,ci)); */
if (!strcmp
(cmu6_lts_phone_table[ph],
mdef_ciphone_str(d->mdef, ci)))
break;
}
if (cmu6_lts_phone_table[ph] == NULL) {
E_FATAL
("A phone in the model definition doesn't appear in the letter to sound ",
"rules. \n This is case we don't recommend user to ",
"use the built-in LTS. \n Please kindly turn off ",
"-lts_mismatch\n");
}
}
}
#endif
}
static void
parse_tri_line(mdef_t * m, const char *line, s3pid_t p)
{
int32 wlen;
char word[1024];
const char *lp;
s3cipid_t ci, lc, rc;
word_posn_t wpos = WORD_POSN_BEGIN;
lp = line;
/* Read base phone name */
if (sscanf(lp, "%s%n", word, &wlen) != 1)
E_FATAL("Missing base phone name: %s\n", line);
lp += wlen;
ci = mdef_ciphone_id(m, word);
if (NOT_S3CIPID(ci))
E_FATAL("Unknown base phone: %s\n", line);
/* Read lc */
if (sscanf(lp, "%s%n", word, &wlen) != 1)
E_FATAL("Missing left context: %s\n", line);
lp += wlen;
lc = mdef_ciphone_id(m, word);
if (NOT_S3CIPID(lc))
E_FATAL("Unknown left context: %s\n", line);
/* Read rc */
if (sscanf(lp, "%s%n", word, &wlen) != 1)
E_FATAL("Missing right context: %s\n", line);
lp += wlen;
rc = mdef_ciphone_id(m, word);
if (NOT_S3CIPID(rc))
E_FATAL("Unknown right context: %s\n", line);
/* Read tripone word-position within word */
if ((sscanf(lp, "%s%n", word, &wlen) != 1) || (word[1] != '\0'))
E_FATAL("Missing or bad word-position spec: %s\n", line);
lp += wlen;
switch (word[0]) {
case 'b':
wpos = WORD_POSN_BEGIN;
break;
case 'e':
wpos = WORD_POSN_END;
break;
case 's':
wpos = WORD_POSN_SINGLE;
break;
case 'i':
wpos = WORD_POSN_INTERNAL;
break;
default:
E_FATAL("Bad word-position spec: %s\n", line);
}
/* Read filler attribute, if present. Must match base phone attribute */
if (sscanf(lp, "%s%n", word, &wlen) != 1)
E_FATAL("Missing filler attribute field: %s\n", line);
lp += wlen;
if (((strcmp(word, "filler") == 0) && (m->ciphone[(int) ci].filler)) ||
((strcmp(word, "n/a") == 0) && (!m->ciphone[(int) ci].filler))) {
/* Everything is fine */
}
else
E_FATAL("Bad filler attribute field: %s\n", line);
triphone_add(m, ci, lc, rc, wpos, p);
/* Parse remainder of line: transition matrix and state->senone mappings */
parse_tmat_senmap(m, line, lp - line, p);
}
s3pid_t
mdef_phone_id_nearest(mdef_t * m,
s3cipid_t b, s3cipid_t l, s3cipid_t r,
word_posn_t pos)
{
word_posn_t tmppos;
s3pid_t p;
s3cipid_t newl, newr;
char *wpos_name;
assert(m);
assert((b >= 0) && (b < m->n_ciphone));
assert((pos >= 0) && (pos < N_WORD_POSN));
if ((NOT_S3CIPID(l)) || (NOT_S3CIPID(r)))
return ((s3pid_t) b);
assert((l >= 0) && (l < m->n_ciphone));
assert((r >= 0) && (r < m->n_ciphone));
p = mdef_phone_id(m, b, l, r, pos);
if (IS_S3PID(p))
return p;
/* Exact triphone not found; backoff to other word positions */
for (tmppos = 0; tmppos < N_WORD_POSN; tmppos++) {
if (tmppos != pos) {
p = mdef_phone_id(m, b, l, r, tmppos);
if (IS_S3PID(p))
return p;
}
}
/* Nothing yet; backoff to silence phone if non-silence filler context */
if (IS_S3CIPID(m->sil)) {
newl = m->ciphone[(int) l].filler ? m->sil : l;
newr = m->ciphone[(int) r].filler ? m->sil : r;
if ((newl != l) || (newr != r)) {
p = mdef_phone_id(m, b, newl, newr, pos);
if (IS_S3PID(p))
return p;
for (tmppos = 0; tmppos < N_WORD_POSN; tmppos++) {
if (tmppos != pos) {
p = mdef_phone_id(m, b, newl, newr, tmppos);
if (IS_S3PID(p))
return p;
}
}
}
}
/* Nothing yet; backoff to base phone */
if ((m->n_phone > m->n_ciphone) && (!m->ciphone[(int) b].filler)) {
wpos_name = WPOS_NAME;
#if 0
E_WARN("Triphone(%s,%s,%s,%c) not found; backing off to CIphone\n",
mdef_ciphone_str(m, b),
mdef_ciphone_str(m, l),
mdef_ciphone_str(m, r), wpos_name[pos]);
#endif
}
return ((s3pid_t) b);
}
