glist_t
srch_FLAT_FWD_gen_hyp(void *srch /**< a pointer of srch_t */
)
{
srch_t *s;
srch_FLAT_FWD_graph_t *fwg;
srch_hyp_t *tmph, *hyp;
glist_t ghyp, rhyp;
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
if (s->exit_id == -1)
s->exit_id = lat_final_entry(fwg->lathist, kbcore_dict(s->kbc), fwg->n_frm,
s->uttid);
if (NOT_S3LATID(s->exit_id)) {
E_INFO("lattice ID: %d\n", s->exit_id);
E_ERROR("%s: NO RECOGNITION\n", s->uttid);
return NULL;
}
else {
/* BAD_S3WID => Any right context */
lattice_backtrace(fwg->lathist, s->exit_id, BAD_S3WID, &hyp,
s->kbc->lmset->cur_lm, kbcore_dict(s->kbc),
fwg->ctxt, s->kbc->fillpen);
ghyp = NULL;
for (tmph = hyp; tmph; tmph = tmph->next) {
ghyp = glist_add_ptr(ghyp, (void *) tmph);
}
rhyp = glist_reverse(ghyp);
return rhyp;
}
}
glist_t
srch_FLAT_FWD_nbest_impl(void *srch, /**< A void pointer to a search structure */
dag_t * dag)
{
srch_t *s;
srch_FLAT_FWD_graph_t *fwg;
float32 bestpathlw;
float64 lwf;
char str[2000];
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
assert(fwg->lathist);
if (!(cmd_ln_exists_r(kbcore_config(fwg->kbcore), "-nbestdir")
&& cmd_ln_str_r(kbcore_config(fwg->kbcore), "-nbestdir")))
return NULL;
ctl_outfile(str, cmd_ln_str_r(kbcore_config(fwg->kbcore), "-nbestdir"),
cmd_ln_str_r(kbcore_config(fwg->kbcore), "-nbestext"),
(s->uttfile ? s->uttfile : s->uttid), s->uttid,
cmd_ln_boolean_r(kbcore_config(fwg->kbcore), "-build_outdirs"));
bestpathlw = cmd_ln_float32_r(kbcore_config(fwg->kbcore), "-bestpathlw");
lwf = bestpathlw ? (bestpathlw / cmd_ln_float32_r(kbcore_config(fwg->kbcore), "-lw")) : 1.0;
flat_fwd_dag_add_fudge_edges(fwg,
dag,
cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-dagfudge"),
cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-min_endfr"),
(void *) fwg->lathist, s->kbc->dict);
/* Bypass filler nodes */
if (!dag->filler_removed) {
/* If Viterbi search terminated in filler word coerce final DAG node to FINISH_WORD */
if (dict_filler_word(s->kbc->dict, dag->end->wid))
dag->end->wid = s->kbc->dict->finishwid;
dag_remove_unreachable(dag);
if (dag_bypass_filler_nodes(dag, lwf, s->kbc->dict, s->kbc->fillpen) < 0)
E_ERROR("maxedge limit (%d) exceeded\n", dag->maxedge);
}
dag_compute_hscr(dag, kbcore_dict(s->kbc), kbcore_lm(s->kbc), lwf);
dag_remove_bypass_links(dag);
dag->filler_removed = 0;
nbest_search(dag, str, s->uttid, lwf,
kbcore_dict(s->kbc),
kbcore_lm(s->kbc), kbcore_fillpen(s->kbc)
);
return NULL;
}
int32 vithist_utt_begin (vithist_t *vh, kbcore_t *kbc)
{
vithist_entry_t *ve;
lm_t *lm;
dict_t *dict;
lm = kbcore_lm(kbc);
dict = kbcore_dict(kbc);
assert (vh->n_entry == 0);
assert (vh->entry[0] == NULL);
assert (vh->lwidlist == NULL);
/* Create an initial dummy <s> entry. This is the root for the utterance */
ve = vithist_entry_alloc (vh);
ve->wid = dict_startwid(dict);
ve->sf = -1;
ve->ef = -1;
ve->ascr = 0;
ve->lscr = 0;
ve->score = 0;
ve->pred = -1;
ve->type = 0;
ve->valid = 1;
ve->lmstate.lm3g.lwid[0] = lm_startwid(lm);
ve->lmstate.lm3g.lwid[1] = BAD_S3LMWID;
vh->n_frm = 0;
vh->frame_start[0] = 1;
vh->bestscore[0] = MAX_NEG_INT32;
vh->bestvh[0] = -1;
return 0;
}
int32
srch_FLAT_FWD_dag_dump(void *srch, dag_t *dag)
{
char str[2048];
srch_t *s;
srch_FLAT_FWD_graph_t *fwg;
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
assert(fwg->lathist);
ctl_outfile(str,
cmd_ln_str_r(kbcore_config(fwg->kbcore), "-outlatdir"),
cmd_ln_str_r(kbcore_config(fwg->kbcore), "-latext"),
(s->uttfile ? s->uttfile : s->uttid), s->uttid,
cmd_ln_boolean_r(kbcore_config(fwg->kbcore), "-build_outdirs"));
E_INFO("Writing lattice file: %s\n", str);
latticehist_dag_write(fwg->lathist,
str,
dag, kbcore_lm(s->kbc),
kbcore_dict(s->kbc), fwg->ctxt,
s->kbc->fillpen);
return SRCH_SUCCESS;
}
void vithist_dump (vithist_t *vh, int32 frm, kbcore_t *kbc, FILE *fp)
{
int32 b, l, i, j;
dict_t *dict;
lm_t *lm;
vithist_entry_t *ve;
s3lmwid_t lwid;
int32 sf, ef;
dict = kbcore_dict (kbc);
lm = kbcore_lm (kbc);
if (frm >= 0) {
sf = frm;
ef = frm;
fprintf (fp, "VITHIST frame %d #entries %d\n",
frm, vh->frame_start[sf+1] - vh->frame_start[sf]);
} else {
sf = 0;
ef = vh->n_frm - 1;
fprintf (fp, "VITHIST #frames %d #entries %d\n", vh->n_frm, vh->n_entry);
}
fprintf (fp, "\t%7s %5s %5s %11s %9s %8s %7s %4s Word (LM-state)\n",
"Seq/Val", "SFrm", "EFrm", "PathScr", "SegAScr", "SegLScr", "Pred", "Type");
for (i = sf; i <= ef; i++) {
fprintf (fp, "%5d BS: %11d BV: %8d\n", i, vh->bestscore[i], vh->bestvh[i]);
for (j = vh->frame_start[i]; j < vh->frame_start[i+1]; j++) {
/* This entry */
b = VITHIST_ID2BLK(j);
l = VITHIST_ID2BLKOFFSET (j);
ve = vh->entry[b] + l;
fprintf (fp, "\t%c%6d %5d %5d %11d %9d %8d %7d %4d %s",
(ve->valid ? ' ' : '*'), j,
ve->sf, ve->ef, ve->score, ve->ascr, ve->lscr, ve->pred, ve->type,
dict_wordstr (dict, ve->wid));
fprintf (fp, " (%s", lm_wordstr (lm, ve->lmstate.lm3g.lwid[0]));
lwid = ve->lmstate.lm3g.lwid[1];
if (IS_S3LMWID(lwid))
fprintf (fp, ", %s", lm_wordstr (lm, lwid));
fprintf (fp, ")\n");
}
if (j == vh->frame_start[i])
fprintf (fp, "\n");
}
#if 0
if (vh->lwidlist)
vithist_lmstate_dump (vh, kbc, fp);
#endif
fprintf (fp, "END_VITHIST\n");
fflush (fp);
}
void vithist_rescore (vithist_t *vh, kbcore_t *kbc,
s3wid_t wid, int32 ef, int32 score, int32 pred, int32 type)
{
vithist_entry_t *pve, tve;
s3lmwid_t lwid;
int32 se, fe;
int32 i;
assert (vh->n_frm == ef);
pve = vh->entry[VITHIST_ID2BLK(pred)] + VITHIST_ID2BLKOFFSET(pred);
/* Create a temporary entry with all the info currently available */
tve.wid = wid;
tve.sf = pve->ef + 1;
tve.ef = ef;
tve.type = type;
tve.valid = 1;
tve.ascr = score - pve->score;
if (pred == 0) { /* Special case for the initial <s> entry */
se = 0;
fe = 1;
} else {
se = vh->frame_start[pve->ef];
fe = vh->frame_start[pve->ef + 1];
}
if (dict_filler_word (kbcore_dict(kbc), wid)) {
tve.lscr = fillpen (kbcore_fillpen(kbc), wid);
tve.score = score + tve.lscr;
tve.pred = pred;
tve.lmstate.lm3g = pve->lmstate.lm3g;
vithist_enter (vh, kbc, &tve);
} else {
lwid = kbcore_dict2lmwid (kbc, wid);
tve.lmstate.lm3g.lwid[0] = lwid;
for (i = se; i < fe; i++) {
pve = vh->entry[VITHIST_ID2BLK(i)] + VITHIST_ID2BLKOFFSET(i);
if (pve->valid) {
tve.lscr = lm_tg_score (kbcore_lm(kbc),
pve->lmstate.lm3g.lwid[1],
pve->lmstate.lm3g.lwid[0],
lwid);
tve.score = pve->score + tve.ascr + tve.lscr;
if ((tve.score - vh->wbeam) >= vh->bestscore[vh->n_frm]) {
tve.pred = i;
tve.lmstate.lm3g.lwid[1] = pve->lmstate.lm3g.lwid[0];
vithist_enter (vh, kbc, &tve);
}
}
}
}
}
int
srch_FLAT_FWD_dump_vithist(void *srch)
{
srch_t *s;
srch_FLAT_FWD_graph_t *fwg;
char file[8192];
FILE *bptfp;
/* Check if bptable should be dumped (for debugging) */
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
assert(fwg->lathist);
sprintf(file, "%s/%s.bpt", cmd_ln_str_r(kbcore_config(fwg->kbcore), "-bptbldir"), s->uttid);
if ((bptfp = fopen(file, "w")) == NULL) {
E_ERROR("fopen(%s,w) failed; using stdout\n", file);
bptfp = stdout;
}
latticehist_dump(fwg->lathist, bptfp, kbcore_dict(s->kbc), fwg->ctxt, 0);
if (bptfp != stdout)
fclose(bptfp);
return SRCH_SUCCESS;
}
int32 live_get_partialhyp(int32 endutt)
{
int32 id, nwds;
glist_t hyp;
gnode_t *gn;
hyp_t *h;
dict_t *dict;
dict = kbcore_dict (kb->kbcore);
if (endutt)
id = vithist_utt_end(kb->vithist, kb->kbcore);
else
id = vithist_partialutt_end(kb->vithist, kb->kbcore);
if (id > 0) {
hyp = vithist_backtrace(kb->vithist,id);
for (gn = hyp,nwds=0; gn; gn = gnode_next(gn),nwds++) {
h = (hyp_t *) gnode_ptr (gn);
if (parthyp[nwds].word != NULL) {
ckd_free(parthyp[nwds].word);
parthyp[nwds].word = NULL;
}
parthyp[nwds].word = strdup(dict_wordstr(dict, h->id));
parthyp[nwds].sf = h->sf;
parthyp[nwds].ef = h->ef;
parthyp[nwds].ascr = h->ascr;
parthyp[nwds].lscr = h->lscr;
}
if (parthyp[nwds].word != NULL){
ckd_free(parthyp[nwds].word);
parthyp[nwds].word = NULL;
}
/* Free hyplist */
for (gn = hyp; gn && (gnode_next(gn)); gn = gnode_next(gn)) {
h = (hyp_t *) gnode_ptr (gn);
ckd_free ((void *) h);
}
glist_free (hyp);
} else {
nwds = 0;
if (parthyp[nwds].word != NULL) {
ckd_free(parthyp[nwds].word);
parthyp[nwds].word = NULL;
}
}
return(nwds);
}
int
srch_FLAT_FWD_select_active_gmm(void *srch)
{
kbcore_t *kbc;
s3wid_t w;
whmm_t *h;
int32 st;
s3pid_t p;
s3senid_t *senp;
ascr_t *ascr;
srch_FLAT_FWD_graph_t *fwg;
srch_t *s;
mdef_t *mdef;
dict_t *dict;
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
ascr = s->ascr;
kbc = s->kbc;
mdef = kbcore_mdef(kbc);
dict = kbcore_dict(kbc);
ascr_clear_sen_active(ascr);
/* Flag active senones */
for (w = 0; w < dict->n_word; w++) {
for (h = fwg->whmm[w]; h; h = h->next) {
if (hmm_is_mpx(h)) {
for (st = 0; st < hmm_n_emit_state(h); ++st) {
p = hmm_mpx_ssid(h, st);
if (p == -1)
break; /* All subsequent ones are also inactive */
senp = mdef->sseq[p];
ascr->sen_active[senp[st]] = 1;
}
}
else {
p = hmm_nonmpx_ssid(h);
senp = mdef->sseq[p];
for (st = 0; st < hmm_n_emit_state(h); ++st)
ascr->sen_active[senp[st]] = 1;
}
}
}
return SRCH_SUCCESS;
}
int
srch_FLAT_FWD_end(void *srch)
{
srch_FLAT_FWD_graph_t *fwg;
srch_t *s;
kbcore_t *kbc;
dict_t *dict;
stat_t *st;
whmm_t *h, *nexth;
s3wid_t w;
lm_t *lm;
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
kbc = s->kbc;
dict = kbcore_dict(kbc);
st = s->stat;
lm = s->kbc->lmset->cur_lm;
fwg->lathist->frm_latstart[fwg->n_frm] = fwg->lathist->n_lat_entry; /* Add sentinel */
pctr_increment(fwg->ctr_latentry, fwg->lathist->n_lat_entry);
/* Free whmm search structures */
for (w = 0; w < dict->n_word; w++) {
for (h = fwg->whmm[w]; h; h = nexth) {
nexth = h->next;
whmm_free(h);
}
fwg->whmm[w] = NULL;
}
if (fwg->n_word_cand > 0) {
word_cand_free(fwg->word_cand);
fwg->n_word_cand = 0;
}
lm_cache_stats_dump(lm);
lm_cache_reset(lm);
fwd_timing_dump(fwg);
return SRCH_SUCCESS;
}
dag_t *
srch_FLAT_FWD_gen_dag(void *srch, /**< a pointer of srch_t */
glist_t hyp)
{
srch_t *s;
srch_FLAT_FWD_graph_t *fwg;
dag_t *dag;
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
dag =
latticehist_dag_build(fwg->lathist, hyp, kbcore_dict(s->kbc),
kbcore_lm(s->kbc), fwg->ctxt, s->kbc->fillpen,
s->exit_id, kbcore_config(s->kbc), kbcore_logmath(s->kbc));
return dag;
}
/** ARCHAN: Dangerous! Mixing global and local */
static void
dump_fwd_dbg_info(srch_FLAT_FWD_graph_t * fwg, fwd_dbg_t * fd,
ascr_t * ascr, int32 bestscr, int32 whmm_thresh,
int32 word_thresh, int32 * senscr)
{
whmm_t *h;
int32 n_frm;
kbcore_t *kbc;
tmat_t *tmat;
dict_t *dict;
mdef_t *mdef;
n_frm = fwg->n_frm;
kbc = fwg->kbcore;
dict = kbcore_dict(kbc);
tmat = kbcore_tmat(kbc);
mdef = kbcore_mdef(kbc);
/* Dump bestscore and pruning thresholds if any detailed tracing specified */
if (((fd->hmm_dump_sf < n_frm) && (n_frm < fd->hmm_dump_ef)) ||
((fd->word_dump_sf < n_frm) && (n_frm < fd->word_dump_ef)) ||
(IS_S3WID(fd->trace_wid) && fwg->whmm[fd->trace_wid])) {
printf
("[%4d]: >>>> bestscore= %11d, whmm-thresh= %11d, word-thresh= %11d\n",
n_frm, bestscr, whmm_thresh, word_thresh);
}
/* Dump all active HMMs or words, if indicated */
if (fd->hmm_dump_sf < n_frm && n_frm < fd->hmm_dump_ef)
dump_all_whmm(fwg, fwg->whmm, n_frm, ascr->senscr);
else if (fd->word_dump_sf < n_frm && n_frm < fd->word_dump_ef)
dump_all_word(fwg, fwg->whmm);
/* Trace active HMMs for specified word, if any */
if (IS_S3WID(fd->trace_wid)) {
for (h = fwg->whmm[fd->trace_wid]; h; h = h->next)
dump_whmm(fd->trace_wid, h, senscr, tmat, n_frm, dict,
mdef);
}
}
int32 live_get_partialhyp(int32 endutt)
{
int32 id, nwds;
glist_t hyp;
gnode_t *gn;
hyp_t *h;
dict_t *dict;
dict = kbcore_dict (kb->kbcore);
if (endutt)
id = vithist_utt_end(kb->vithist, kb->kbcore);
else
id = vithist_partialutt_end(kb->vithist, kb->kbcore);
if (id > 0) {
hyp = vithist_backtrace(kb->vithist,id);
for (gn = hyp,nwds=0; gn; gn = gnode_next(gn),nwds++) {
h = (hyp_t *) gnode_ptr (gn);
if (parthyp[nwds].word != NULL) {
ckd_free(parthyp[nwds].word);
parthyp[nwds].word = NULL;
}
/* 20040905 L Galescu <*****@*****.**>
* Report noise? If not, replace with silence word. */
if ((cmd_ln_int32("-reportfill") == 0) &&
dict_filler_word(dict, h->id))
parthyp[nwds].word = strdup(dict_wordstr(dict, dict->silwid));
else
parthyp[nwds].word = strdup(dict_wordstr(dict, h->id));
/* 20040901 L Galescu <*****@*****.**>
* Choice to report alternative pronunciations or not. */
if (cmd_ln_int32("-reportpron") == 0)
dict_word2basestr(parthyp[nwds].word);
parthyp[nwds].sf = h->sf;
parthyp[nwds].ef = h->ef;
parthyp[nwds].ascr = h->ascr;
parthyp[nwds].lscr = h->lscr;
}
if (parthyp[nwds].word != NULL){
ckd_free(parthyp[nwds].word);
parthyp[nwds].word = NULL;
}
parthyplen = nwds;
/* Free hyplist */
for (gn = hyp; gn && (gnode_next(gn)); gn = gnode_next(gn)) {
h = (hyp_t *) gnode_ptr (gn);
ckd_free ((void *) h);
}
glist_free (hyp);
} else if (id == 0) {
nwds = 0;
if (parthyp[nwds].word != NULL) {
ckd_free(parthyp[nwds].word);
parthyp[nwds].word = NULL;
}
parthyplen = nwds;
} else {
/* lgalescu 2004/10/13: nothing changed; we return the same hyp that was there before */
}
return(parthyplen);
}
/* Update kb w/ new dictionary and new LM.
* assumes: single-LM kbcore (before & after)
* requires: updating kbcore
* Lucian Galescu, 08/11/2005
*/
void kb_update_lm(kb_t *kb, char *dictfile, char *lmfile)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
lm_t *lm;
s3cipid_t ci;
s3wid_t w;
int32 i, n, n_lc;
wordprob_t *wp;
s3cipid_t *lc;
bitvec_t lc_active;
/*** clean up ***/
vithist_t *vithist = kb->vithist;
if (kb->fillertree)
ckd_free ((void *)kb->fillertree);
if (kb->hmm_hist)
ckd_free ((void *)kb->hmm_hist);
/* vithist */
if (vithist) {
ckd_free ((void *) vithist->entry);
ckd_free ((void *) vithist->frame_start);
ckd_free ((void *) vithist->bestscore);
ckd_free ((void *) vithist->bestvh);
ckd_free ((void *) vithist->lms2vh_root);
ckd_free ((void *) kb->vithist);
}
/*** re-initialize ***/
kb->kbcore = kbcore_update_lm(kb->kbcore,
dictfile,
cmd_ln_str("-fdict"),
"", /* Hack!! Hardwired constant for -compsep argument */
lmfile,
cmd_ln_str("-fillpen"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_float32("-uw"));
if(kb->kbcore==NULL){
E_FATAL("Updating kbcore failed\n");
}
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(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);
}
/*
* 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(lm){
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;
}
/* 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 (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")) {
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->vithist = vithist_init(kbcore, kb->beam->word, cmd_ln_int32("-bghist"));
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 */
}
int32 vithist_utt_end (vithist_t *vh, kbcore_t *kbc)
{
int32 f, i, b, l;
int32 sv, nsv, scr, bestscore, bestvh, vhid;
vithist_entry_t *ve, *bestve=0;
s3lmwid_t endwid;
lm_t *lm;
dict_t *dict;
/* Find last frame with entries in vithist table */
for (f = vh->n_frm-1; f >= 0; --f) {
sv = vh->frame_start[f]; /* First vithist entry in frame f */
nsv = vh->frame_start[f+1]; /* First vithist entry in next frame (f+1) */
if (sv < nsv)
break;
}
if (f < 0)
return -1;
if (f != vh->n_frm-1)
E_ERROR("No word exit in frame %d, using exits from frame %d\n", vh->n_frm-1, f);
/* Terminate in a final </s> node (make this optional?) */
lm = kbcore_lm (kbc);
endwid = lm_finishwid (lm);
bestscore = MAX_NEG_INT32;
bestvh = -1;
for (i = sv; i < nsv; i++) {
b = VITHIST_ID2BLK (i);
l = VITHIST_ID2BLKOFFSET (i);
ve = vh->entry[b] + l;
scr = ve->score;
scr += lm_tg_score (lm, ve->lmstate.lm3g.lwid[1], ve->lmstate.lm3g.lwid[0], endwid);
if (bestscore < scr) {
bestscore = scr;
bestvh = i;
bestve = ve;
}
}
assert (bestvh >= 0);
dict = kbcore_dict (kbc);
if (f != vh->n_frm-1) {
E_ERROR("No word exit in frame %d, using exits from frame %d\n", vh->n_frm-1, f);
/* Add a dummy silwid covering the remainder of the utterance */
assert (vh->frame_start[vh->n_frm-1] == vh->frame_start[vh->n_frm]);
vh->n_frm -= 1;
vithist_rescore (vh, kbc, dict_silwid (dict), vh->n_frm, bestve->score, bestvh, -1);
vh->n_frm += 1;
vh->frame_start[vh->n_frm] = vh->n_entry;
return vithist_utt_end (vh, kbc);
}
/* Create an </s> entry */
vhid = vh->n_entry;
ve = vithist_entry_alloc (vh);
ve->wid = dict_finishwid (dict);
ve->sf = (bestve->ef == BAD_S3FRMID) ? 0 : bestve->ef + 1;
ve->ef = vh->n_frm;
ve->ascr = 0;
ve->lscr = bestscore - bestve->score;
ve->score = bestscore;
ve->pred = bestvh;
ve->type = 0;
ve->valid = 1;
ve->lmstate.lm3g.lwid[0] = endwid;
ve->lmstate.lm3g.lwid[1] = ve->lmstate.lm3g.lwid[0];
return vhid;
}
int
srch_FLAT_FWD_begin(void *srch)
{
srch_FLAT_FWD_graph_t *fwg;
srch_t *s;
kbcore_t *kbc;
int32 w, ispipe;
char str[1024];
FILE *fp;
dict_t *dict;
s = (srch_t *) srch;
fwg = (srch_FLAT_FWD_graph_t *) s->grh->graph_struct;
kbc = s->kbc;
dict = kbcore_dict(kbc);
assert(fwg);
ptmr_reset(&(fwg->tm_hmmeval));
ptmr_reset(&(fwg->tm_hmmtrans));
ptmr_reset(&(fwg->tm_wdtrans));
latticehist_reset(fwg->lathist);
/* If input lattice file containing word candidates to be searched specified; use it */
if (fwg->word_cand_dir) {
ctl_outfile(str, fwg->word_cand_dir, fwg->latfile_ext,
(s->uttfile ? s->uttfile : s->uttid), s->uttid,
cmd_ln_boolean_r(kbcore_config(s->kbc), "-build_outdirs"));
E_INFO("Reading input lattice: %s\n", str);
if ((fp = fopen_compchk(str, &ispipe)) == NULL)
E_ERROR("fopen_compchk(%s) failed; running full search\n",
str);
else {
if ((fwg->n_word_cand =
word_cand_load(fp, fwg->word_cand, dict,
s->uttid)) <= 0) {
E_ERROR("Bad or empty lattice file: %s; ignored\n", str);
word_cand_free(fwg->word_cand);
fwg->n_word_cand = 0;
}
else
E_INFO("%d lattice entries read\n", fwg->n_word_cand);
fclose_comp(fp, ispipe);
}
}
if (fwg->n_word_cand > 0)
latticehist_n_cand(fwg->lathist) = fwg->n_word_cand;
/* Enter all pronunciations of startwid (begin silence) */
fwg->n_frm = -1;
for (w = dict->startwid; IS_S3WID(w); w = dict->word[w].alt)
word_enter(fwg, w, 0, BAD_S3LATID,
dict->word[dict->silwid].ciphone[dict->
word[dict->silwid].
pronlen - 1]);
fwg->renormalized = 0;
fwg->n_frm = 0;
#if 0
E_INFO("After\n");
dump_all_whmm(fwg, fwg->whmm, fwg->n_frm, fwg->n_state, NULL);
#endif
return SRCH_SUCCESS;
}
/*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, cmd_ln_t *config)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
int32 cisencnt;
/* STRUCTURE: Initialize the kb structure to zero, just in case */
memset(kb, 0, sizeof(*kb));
kb->kbcore = kbcore_init(config);
if (kb->kbcore == NULL)
E_FATAL("Initialization of kb failed\n");
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
d2p = kbcore_dict2pid(kbcore);
err_set_debug_level(cmd_ln_int32_r(config, "-debug"));
/* STRUCTURE INITIALIZATION: Initialize the beam data structure */
if (cmd_ln_exists_r(config, "-ptranskip")) {
kb->beam = beam_init(cmd_ln_float64_r(config, "-beam"),
cmd_ln_float64_r(config, "-pbeam"),
cmd_ln_float64_r(config, "-wbeam"),
cmd_ln_float64_r(config, "-wend_beam"),
cmd_ln_int32_r(config, "-ptranskip"), mdef_n_ciphone(mdef),
kbcore->logmath
);
/* REPORT : Report the parameters in the beam data structure */
if (REPORT_KB)
beam_report(kb->beam);
}
/* STRUCTURE INITIALIZATION: Initialize the fast GMM computation data structure */
if (cmd_ln_exists_r(config, "-ci_pbeam")) {
kb->fastgmm = fast_gmm_init(cmd_ln_int32_r(config, "-ds"),
cmd_ln_int32_r(config, "-cond_ds"),
cmd_ln_int32_r(config, "-dist_ds"),
cmd_ln_int32_r(config, "-gs4gs"),
cmd_ln_int32_r(config, "-svq4svq"),
cmd_ln_float64_r(config, "-subvqbeam"),
cmd_ln_float64_r(config, "-ci_pbeam"),
cmd_ln_float64_r(config, "-tighten_factor"),
cmd_ln_int32_r(config, "-maxcdsenpf"),
mdef->n_ci_sen,
kbcore->logmath);
/* REPORT : Report the parameters in the fast_gmm_t data struture */
if (REPORT_KB)
fast_gmm_report(kb->fastgmm);
}
/* STRUCTURE INITIALIZATION: Initialize the phoneme lookahead data structure */
if (cmd_ln_exists_r(config, "-pl_beam")) {
kb->pl = pl_init(cmd_ln_int32_r(config, "-pheurtype"),
cmd_ln_float64_r(config, "-pl_beam"), mdef_n_ciphone(mdef),
kbcore->logmath
);
/* REPORT : Report the parameters in the pl_t data struture */
if (REPORT_KB)
pl_report(kb->pl);
}
/* STRUCTURE INITIALIZATION: Initialize the acoustic score data structure */
{
int32 pl_window = 1;
if (cmd_ln_exists_r(config, "-pl_window"))
pl_window = cmd_ln_int32_r(config, "-pl_window");
for (cisencnt = 0; cisencnt == mdef->cd2cisen[cisencnt]; cisencnt++) ;
kb->ascr = ascr_init(kbcore_n_mgau(kbcore),
kb->kbcore->dict2pid->n_comstate,
mdef_n_sseq(mdef),
dict2pid_n_comsseq(d2p),
pl_window, cisencnt);
if (REPORT_KB)
ascr_report(kb->ascr);
}
/* Initialize the front end if -adcin is specified */
if (cmd_ln_exists_r(config, "-adcin") && cmd_ln_boolean_r(config, "-adcin")) {
if ((kb->fe = fe_init_auto_r(config)) == NULL) {
E_FATAL("fe_init_auto_r() failed\n");
}
}
/* STRUCTURE INITIALIZATION : The feature vector */
if ((kb->feat =
feat_array_alloc(kbcore_fcb(kbcore), S3_MAX_FRAMES)) == NULL)
E_FATAL("feat_array_alloc() failed\n");
/* STRUCTURE INITIALIZATION : The statistics for the search */
kb->stat = stat_init();
/* STRUCTURE INITIALIZATION : The adaptation routines of the search */
kb->adapt_am = adapt_am_init();
if (cmd_ln_str_r(config, "-mllr")) {
kb_setmllr(cmd_ln_str_r(config, "-mllr"), cmd_ln_str_r(config, "-cb2mllr"), kb);
}
/* CHECK: make sure when (-cond_ds) is specified, a Gaussian map is also specified */
if (cmd_ln_int32_r(config, "-cond_ds") > 0 && kb->kbcore->gs == NULL)
E_FATAL
("Conditional Down Sampling require the use of Gaussian Selection map\n");
/* MEMORY ALLOCATION : Word best score and exit */
/* Open hypseg file if specified */
kb->matchsegfp = kb->matchfp = NULL;
kb->matchsegfp = file_open(cmd_ln_str_r(config, "-hypseg"));
kb->matchfp = file_open(cmd_ln_str_r(config, "-hyp"));
if (cmd_ln_exists_r(config, "-hmmdump"))
kb->hmmdumpfp = cmd_ln_int32_r(config, "-hmmdump") ? stderr : NULL;
/* STRUCTURE INITIALIZATION : The search data structure, done only
after kb is initialized kb is acted as a clipboard. */
if (cmd_ln_exists_r(config, "-op_mode")) {
/* -op_mode, if set (i.e. not -1), takes precedence over -mode. */
if (cmd_ln_int32_r(config, "-op_mode") != -1)
kb->op_mode = cmd_ln_int32_r(config, "-op_mode");
else
kb->op_mode = srch_mode_str_to_index(cmd_ln_str_r(config, "-mode"));
E_INFO("SEARCH MODE INDEX %d\n", kb->op_mode);
if ((kb->srch = (srch_t *) srch_init(kb, kb->op_mode)) == NULL) {
E_FATAL("Search initialization failed. Forced exit\n");
}
if (REPORT_KB) {
srch_report(kb->srch);
}
}
}
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);
}
}
int
ld_record_hyps(live_decoder_t * _decoder, int _end_utt)
{
int32 id;
int32 i = 0;
glist_t hyp_list;
gnode_t *node;
srch_hyp_t *hyp;
char *hyp_strptr = 0;
char *hyp_str = 0;
srch_hyp_t **hyp_segs = 0;
int hyp_seglen = 0;
int hyp_strlen = 0;
int finish_wid = 0;
kb_t *kb = 0;
dict_t *dict;
int rv;
assert(_decoder != NULL);
ld_free_hyps(_decoder);
kb = &_decoder->kb;
dict = kbcore_dict(_decoder->kbcore);
id = _end_utt ?
vithist_utt_end(kb->vithist, _decoder->kbcore) :
vithist_partialutt_end(kb->vithist, _decoder->kbcore);
if (id < 0) {
E_WARN("Failed to retrieve viterbi history.\n");
return LD_ERROR_INTERNAL;
}
/** record the segment length and the overall string length */
hyp_list = vithist_backtrace(kb->vithist, id, dict);
finish_wid = dict_finishwid(dict);
for (node = hyp_list; node != NULL; node = gnode_next(node)) {
hyp = (srch_hyp_t *) gnode_ptr(node);
hyp_seglen++;
if (!dict_filler_word(dict, hyp->id) && hyp->id != finish_wid) {
hyp_strlen +=
strlen(dict_wordstr(dict, dict_basewid(dict, hyp->id))) +
1;
}
}
if (hyp_strlen == 0) {
hyp_strlen = 1;
}
/** allocate array to hold the segments and/or decoded string */
hyp_str = (char *) ckd_calloc(hyp_strlen, sizeof(char));
hyp_segs =
(srch_hyp_t **) ckd_calloc(hyp_seglen + 1, sizeof(srch_hyp_t *));
if (hyp_segs == NULL || hyp_str == NULL) {
E_WARN("Failed to allocate storage for hypothesis.\n");
rv = LD_ERROR_OUT_OF_MEMORY;
goto ld_record_hyps_cleanup;
}
/** iterate thru to fill in the array of segments and/or decoded string */
i = 0;
hyp_strptr = hyp_str;
for (node = hyp_list; node != NULL; node = gnode_next(node), i++) {
hyp = (srch_hyp_t *) gnode_ptr(node);
hyp_segs[i] = hyp;
hyp->word = dict_wordstr(dict, dict_basewid(dict, hyp->id));
if (!dict_filler_word(dict, hyp->id) && hyp->id != finish_wid) {
strcat(hyp_strptr,
dict_wordstr(dict, dict_basewid(dict, hyp->id)));
hyp_strptr += strlen(hyp_strptr);
*hyp_strptr = ' ';
hyp_strptr += 1;
}
}
glist_free(hyp_list);
hyp_str[hyp_strlen - 1] = '\0';
hyp_segs[hyp_seglen] = 0;
_decoder->hyp_frame_num = _decoder->num_frames_decoded;
_decoder->hyp_segs = hyp_segs;
_decoder->hyp_str = hyp_str;
return LD_SUCCESS;
ld_record_hyps_cleanup:
if (hyp_segs != NULL) {
ckd_free(hyp_segs);
}
if (hyp_str != NULL) {
ckd_free(hyp_segs);
}
if (hyp_list != NULL) {
for (node = hyp_list; node != NULL; node = gnode_next(node)) {
if ((hyp = (srch_hyp_t *) gnode_ptr(node)) != NULL) {
ckd_free(hyp);
}
}
}
return rv;
}
int
ld_utt_hyps(live_decoder_t *decoder, char **hyp_str, hyp_t ***hyp_segs)
{
int32 id;
int32 i = 0;
glist_t hyp_list;
gnode_t *node;
hyp_t *hyp;
dict_t *dict;
char *hyp_strptr;
kb_t *kb = &decoder->kb;
if (decoder->ld_state == LD_STATE_ENDED) {
if (hyp_segs) {
*hyp_segs = kb->hyp_segs;
}
if (hyp_str) {
*hyp_str = kb->hyp_str;
}
return 0;
}
else {
kb_freehyps(kb);
}
dict = kbcore_dict (decoder->kbcore);
id = vithist_partialutt_end(kb->vithist, decoder->kbcore);
if (id >= 0) {
hyp_list = vithist_backtrace(kb->vithist, id);
/* record the segment length and the overall string length */
for (node = hyp_list; node; node = gnode_next(node)) {
hyp = (hyp_t *)gnode_ptr(node);
if (hyp_segs) {
kb->hyp_seglen++;
}
if (hyp_str) {
if (!dict_filler_word(dict, hyp->id) &&
hyp->id != dict_finishwid(dict)) {
kb->hyp_strlen +=
strlen(dict_wordstr(dict, dict_basewid(dict, hyp->id))) + 1;
}
}
}
/* allocate array to hold the segments and/or decoded string */
if (hyp_segs) {
kb->hyp_segs = (hyp_t **)ckd_calloc(kb->hyp_seglen, sizeof(hyp_t *));
}
if (hyp_str) {
kb->hyp_str = (char *)ckd_calloc(kb->hyp_strlen+1, sizeof(char));
}
/* iterate thru to fill in the array of segments and/or decoded string */
i = 0;
if (hyp_str) {
hyp_strptr = kb->hyp_str;
}
for (node = hyp_list; node; node = gnode_next(node), i++) {
hyp = (hyp_t *)gnode_ptr(node);
if (hyp_segs) {
kb->hyp_segs[i] = hyp;
}
if (hyp_str) {
strcat(hyp_strptr, dict_wordstr(dict, dict_basewid(dict, hyp->id)));
hyp_strptr += strlen(hyp_strptr);
strcat(hyp_strptr, " ");
hyp_strptr += 1;
}
}
glist_free(hyp_list);
if (hyp_str) {
kb->hyp_str[kb->hyp_strlen - 1] = '\0';
}
}
if (hyp_segs) {
*hyp_segs = kb->hyp_segs;
}
if (hyp_str) {
*hyp_str = kb->hyp_str;
}
return 0;
}
int
srch_FLAT_FWD_init(kb_t * kb, /**< The KB */
void *srch /**< The pointer to a search structure */
)
{
srch_FLAT_FWD_graph_t *fwg;
kbcore_t *kbc;
srch_t *s;
mdef_t *mdef;
dict_t *dict;
lm_t *lm;
kbc = kb->kbcore;
s = (srch_t *) srch;
mdef = kbcore_mdef(kbc);
dict = kbcore_dict(kbc);
lm = kbcore_lm(kbc);
fwg = ckd_calloc(1, sizeof(srch_FLAT_FWD_graph_t));
E_INFO("Initialization\n");
/** For convenience */
fwg->kbcore = s->kbc;
/* Allocate whmm structure */
fwg->hmmctx = hmm_context_init(mdef_n_emit_state(mdef),
kbcore_tmat(kbc)->tp, NULL,
mdef->sseq);
fwg->whmm = (whmm_t **) ckd_calloc(dict->n_word, sizeof(whmm_t *));
/* Data structures needed during word transition */
/* These five things need to be tied into the same structure. Such that when multiple LM they could be switched. */
fwg->rcscore = NULL;
fwg->rcscore = (int32 *) ckd_calloc(mdef->n_ciphone, sizeof(int32));
fwg->ug_backoff =
(backoff_t *) ckd_calloc(mdef->n_ciphone, sizeof(backoff_t));
fwg->filler_backoff =
(backoff_t *) ckd_calloc(mdef->n_ciphone, sizeof(backoff_t));
fwg->tg_trans_done = (uint8 *) ckd_calloc(dict->n_word, sizeof(uint8));
fwg->word_ugprob = init_word_ugprob(mdef, lm, dict);
/* Input candidate-word lattices information to restrict search; if any */
fwg->word_cand_dir = cmd_ln_str_r(kbcore_config(fwg->kbcore), "-inlatdir");
fwg->latfile_ext = cmd_ln_str_r(kbcore_config(fwg->kbcore), "-latext");
fwg->word_cand_win = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-inlatwin");
if (fwg->word_cand_win < 0) {
E_ERROR("Invalid -inlatwin argument: %d; set to 50\n",
fwg->word_cand_win);
fwg->word_cand_win = 50;
}
/* Allocate pointers to lists of word candidates in each frame */
if (fwg->word_cand_dir) {
fwg->word_cand =
(word_cand_t **) ckd_calloc(S3_MAX_FRAMES,
sizeof(word_cand_t *));
fwg->word_cand_cf =
(s3wid_t *) ckd_calloc(dict->n_word + 1, sizeof(s3wid_t));
}
/* Initializing debugging information such as trace_wid,
word_dump_sf, word_dump_ef, hmm_dump_sf and hmm_dump_ef */
fwg->fwdDBG = init_fwd_dbg(fwg);
fwg->ctr_mpx_whmm = pctr_new("mpx");
fwg->ctr_nonmpx_whmm = pctr_new("~mpx");
fwg->ctr_latentry = pctr_new("lat");
/** Initialize the context table */
fwg->ctxt = ctxt_table_init(kbcore_dict(kbc), kbcore_mdef(kbc));
/* Viterbi history structure */
fwg->lathist = latticehist_init(cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-bptblsize"),
S3_MAX_FRAMES + 1);
/* Glue the graph structure */
s->grh->graph_struct = fwg;
s->grh->graph_type = GRAPH_STRUCT_FLAT;
return SRCH_SUCCESS;
}
int
s3_decode_record_hyps(s3_decode_t * _decode, int _end_utt)
{
int32 i = 0;
glist_t hyp_list;
gnode_t *node;
srch_hyp_t *hyp;
char *hyp_strptr = 0;
char *hyp_str = 0;
srch_t *srch;
srch_hyp_t **hyp_segs = 0;
int hyp_seglen = 0;
int hyp_strlen = 0;
int finish_wid = 0;
kb_t *kb = 0;
dict_t *dict;
int rv;
if (_decode == NULL)
return S3_DECODE_ERROR_NULL_POINTER;
s3_decode_free_hyps(_decode);
kb = &_decode->kb;
dict = kbcore_dict(_decode->kbcore);
srch = (srch_t *) _decode->kb.srch;
hyp_list = srch_get_hyp(srch);
if (hyp_list == NULL) {
E_WARN("Failed to retrieve viterbi history.\n");
return S3_DECODE_ERROR_INTERNAL;
}
/** record the segment length and the overall string length */
finish_wid = dict_finishwid(dict);
for (node = hyp_list; node != NULL; node = gnode_next(node)) {
hyp = (srch_hyp_t *) gnode_ptr(node);
hyp_seglen++;
if (!dict_filler_word(dict, hyp->id) && hyp->id != finish_wid) {
hyp_strlen +=
strlen(dict_wordstr(dict, dict_basewid(dict, hyp->id))) +
1;
}
}
if (hyp_strlen == 0) {
hyp_strlen = 1;
}
/** allocate array to hold the segments and/or decoded string */
hyp_str = (char *) ckd_calloc(hyp_strlen, sizeof(char));
hyp_segs =
(srch_hyp_t **) ckd_calloc(hyp_seglen + 1, sizeof(srch_hyp_t *));
if (hyp_segs == NULL || hyp_str == NULL) {
E_WARN("Failed to allocate storage for hypothesis.\n");
rv = S3_DECODE_ERROR_OUT_OF_MEMORY;
goto s3_decode_record_hyps_cleanup;
}
/** iterate thru to fill in the array of segments and/or decoded string */
i = 0;
hyp_strptr = hyp_str;
for (node = hyp_list; node != NULL; node = gnode_next(node), i++) {
hyp = (srch_hyp_t *) gnode_ptr(node);
hyp_segs[i] = hyp;
hyp->word = dict_wordstr(dict, dict_basewid(dict, hyp->id));
if (!dict_filler_word(dict, hyp->id) && hyp->id != finish_wid) {
strcat(hyp_strptr,
dict_wordstr(dict, dict_basewid(dict, hyp->id)));
hyp_strptr += strlen(hyp_strptr);
*hyp_strptr = ' ';
hyp_strptr += 1;
}
}
glist_free(hyp_list);
hyp_str[hyp_strlen - 1] = '\0';
hyp_segs[hyp_seglen] = 0;
_decode->hyp_frame_num = _decode->num_frames_decoded;
_decode->hyp_segs = hyp_segs;
_decode->hyp_str = hyp_str;
return S3_DECODE_SUCCESS;
s3_decode_record_hyps_cleanup:
if (hyp_segs != NULL) {
ckd_free(hyp_segs);
}
if (hyp_str != NULL) {
ckd_free(hyp_str);
}
if (hyp_list != NULL) {
for (node = hyp_list; node != NULL; node = gnode_next(node)) {
if ((hyp = (srch_hyp_t *) gnode_ptr(node)) != NULL) {
ckd_free(hyp);
}
}
glist_free(hyp_list);
}
return rv;
}
void
gmm_compute(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
kb_t *kb;
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
mgau_model_t *mgau;
subvq_t *svq;
gs_t *gs;
int32 ptranskip;
int32 s, f, t;
int32 single_el_list[2];
stats_t cur_ci_st;
stats_t cur_cd_st;
stats_t cur_cd_Nbest_st;
stats_t *stptr;
char str[100];
int32 *idx;
int32 *cur_bstidx;
int32 *last_bstidx;
int32 *cur_scr;
int32 *last_scr;
int32 tmpint;
s3senid_t *cd2cisen;
int32 pheurtype;
E_INFO("Processing: %s\n", uttid);
kb = (kb_t *) data;
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
d2p = kbcore_dict2pid(kbcore);
mgau = kbcore_mgau(kbcore);
svq = kbcore_svq(kbcore);
gs = kbcore_gs(kbcore);
kb->uttid = uttid;
ptranskip = kb->beam->ptranskip;
pheurtype = kb->pl->pheurtype;
single_el_list[0] = -1;
single_el_list[1] = -1;
/* Read mfc file and build feature vectors for entire utterance */
kb->stat->nfr =
feat_s2mfc2feat(kbcore_fcb(kbcore), ur->uttfile,
cmd_ln_str("-cepdir"), ".mfc", sf, ef, kb->feat,
S3_MAX_FRAMES);
cd2cisen = mdef_cd2cisen(mdef);
/*This should be a procedure instead of just logic */
init_stat(&cur_cd_st, "Current CD Senone");
init_stat(&cur_ci_st, "Current CI Senone");
init_stat(&cur_cd_Nbest_st, "Current CD NBest Senone");
for (s = 0; s < mdef->n_ci_sen; s++) {
sprintf(str, "Cur Senone %d", s);
init_stat(&cur_sen_st[s], str);
}
for (t = 0; t < (int32) (mdef->n_sen - mdef->n_ci_sen) / NBEST_STEP;
t++) {
sprintf(str, " %d -Cur Best Senone", t * NBEST_STEP);
init_stat(&cur_sen_Nbest_st[t], str);
}
idx = ckd_calloc(mdef->n_sen - mdef->n_ci_sen, sizeof(int32));
/* Allocate temporary array for CurScr and Curbst indx and Lat index */
cur_bstidx = ckd_calloc(mdef->n_sen, sizeof(int32));
last_bstidx = ckd_calloc(mdef->n_sen, sizeof(int32));
cur_scr = ckd_calloc(mdef->n_sen, sizeof(int32));
last_scr = ckd_calloc(mdef->n_sen, sizeof(int32));
for (f = 0; f < kb->stat->nfr; f++) {
for (s = 0; s < mgau->n_mgau; s++) {
/*1, Compute the approximate scores with the last best index. */
if (mgau->mgau[s].bstidx != NO_BSTIDX) {
single_el_list[0] = mgau->mgau[s].bstidx;
last_bstidx[s] = mgau->mgau[s].bstidx;
last_scr[s] =
mgau_eval(mgau, s, single_el_list, kb->feat[f][0], f,
0);
}
else {
last_bstidx[s] = NO_BSTIDX;
}
/*2, Compute the exact scores and sort them and get the ranking. */
kb->ascr->senscr[s] =
mgau_eval(mgau, s, NULL, kb->feat[f][0], f, 1);
/*3, Compute the approximate scores with the current best index */
if (mgau->mgau[s].bstidx != NO_BSTIDX) {
single_el_list[0] = mgau->mgau[s].bstidx;
cur_bstidx[s] = mgau->mgau[s].bstidx;
cur_scr[s] =
mgau_eval(mgau, s, single_el_list, kb->feat[f][0], f,
0);
}
else {
cur_bstidx[s] = NO_BSTIDX;
}
/* Only test for CD senones, test for best index hit */
/*Update either CI senone and CD senone) */
if (!mdef_is_cisenone(mdef, s))
stptr = &cur_cd_st;
else
stptr = &cur_ci_st;
increment_stat(stptr,
abs(last_scr[s] - kb->ascr->senscr[s]),
abs(cur_scr[s] - kb->ascr->senscr[s]),
abs(kb->ascr->senscr[cd2cisen[s]] -
kb->ascr->senscr[s]),
(cur_bstidx[s] == last_bstidx[s]));
if (!mdef_is_cisenone(mdef, s)) {
stptr = &cur_sen_st[cd2cisen[s]];
increment_stat(stptr,
abs(last_scr[s] - kb->ascr->senscr[s]),
abs(cur_scr[s] - kb->ascr->senscr[s]),
abs(kb->ascr->senscr[cd2cisen[s]] -
kb->ascr->senscr[s]),
(cur_bstidx[s] == last_bstidx[s]));
stptr->total_senone += 1;
}
}
cur_cd_st.total_fr++;
cur_cd_st.total_senone += mdef->n_sen - mdef->n_ci_sen;
cur_ci_st.total_fr++;
cur_ci_st.total_senone += mdef->n_ci_sen;
for (s = 0; s < mdef->n_ci_sen; s++) {
cur_sen_st[s].total_fr++;
}
/*This is the part we need to do sorting */
/*1, sort the scores in the current frames */
/*E_INFO("At frame %d\n",f); */
/*Pointer trick at here. */
for (s = 0; s < mdef->n_sen - mdef->n_ci_sen; s++) {
idx[s] = s;
}
cd = &(kb->ascr->senscr[mdef->n_ci_sen]);
qsort(idx, mdef->n_sen - mdef->n_ci_sen, sizeof(int32),
intcmp_gmm_compute);
/*This loop is stupid and it is just a hack. */
for (s = 0; s < mdef->n_sen - mdef->n_ci_sen; s++) {
tmpint = idx[s] + mdef->n_ci_sen;
for (t = 0;
t <
(int32) ((float) (mdef->n_sen - mdef->n_ci_sen) /
(float) NBEST_STEP); t++) {
if (s < t * NBEST_STEP) {
increment_stat(&cur_sen_Nbest_st[t],
abs(last_scr[tmpint] -
kb->ascr->senscr[tmpint]),
abs(cur_scr[tmpint] -
kb->ascr->senscr[tmpint]),
abs(kb->ascr->senscr[cd2cisen[tmpint]] -
kb->ascr->senscr[tmpint]),
(cur_bstidx[tmpint] ==
last_bstidx[tmpint]));
cur_sen_Nbest_st[t].total_senone += 1;
}
}
}
for (t = 0;
t <
(int32) ((float) (mdef->n_sen - mdef->n_ci_sen) /
(float) NBEST_STEP); t++) {
cur_sen_Nbest_st[t].total_fr++;
}
}
print_stat(&cur_cd_st);
print_stat(&cur_ci_st);
print_stat(&cur_sen_Nbest_st[1]); /*Only show the first NBEST_STEP best */
add_stat(&cd_st, &cur_cd_st);
add_stat(&ci_st, &cur_ci_st);
for (s = 0; s < mdef->n_ci_sen; s++) {
add_stat(&sen_st[s], &cur_sen_st[s]);
}
for (s = 0; s < (int32) (mdef->n_sen - mdef->n_ci_sen) / NBEST_STEP;
s++) {
add_stat(&sen_Nbest_st[s], &cur_sen_Nbest_st[s]);
}
ckd_free(idx);
ckd_free(cur_bstidx);
ckd_free(last_bstidx);
ckd_free(cur_scr);
ckd_free(last_scr);
}
