int fsg_model_add_silence(fsg_model_t * fsg, char const *silword, int state, float32 silprob) { int32 logsilp; int n_trans, silwid, src; E_INFO("Adding silence transitions for %s to FSG\n", silword); silwid = fsg_model_word_add(fsg, silword); logsilp = (int32) (logmath_log(fsg->lmath, silprob) * fsg->lw); if (fsg->silwords == NULL) fsg->silwords = bitvec_alloc(fsg->n_word_alloc); bitvec_set(fsg->silwords, silwid); n_trans = 0; if (state == -1) { for (src = 0; src < fsg->n_state; src++) { fsg_model_trans_add(fsg, src, src, logsilp, silwid); ++n_trans; } } else { fsg_model_trans_add(fsg, state, state, logsilp, silwid); ++n_trans; } E_INFO("Added %d silence word transitions\n", n_trans); return n_trans; }
int fsg_model_add_alt(fsg_model_t * fsg, char const *baseword, char const *altword) { int i, basewid, altwid; int ntrans; /* FIXME: This will get slow, eventually... */ for (basewid = 0; basewid < fsg->n_word; ++basewid) if (0 == strcmp(fsg->vocab[basewid], baseword)) break; if (basewid == fsg->n_word) { E_ERROR("Base word %s not present in FSG vocabulary!\n", baseword); return -1; } altwid = fsg_model_word_add(fsg, altword); if (fsg->altwords == NULL) fsg->altwords = bitvec_alloc(fsg->n_word_alloc); bitvec_set(fsg->altwords, altwid); E_DEBUG(2,("Adding alternate word transitions (%s,%s) to FSG\n", baseword, altword)); /* Look for all transitions involving baseword and duplicate them. */ /* FIXME: This will also get slow, eventually... */ ntrans = 0; for (i = 0; i < fsg->n_state; ++i) { hash_iter_t *itor; if (fsg->trans[i].trans == NULL) continue; for (itor = hash_table_iter(fsg->trans[i].trans); itor; itor = hash_table_iter_next(itor)) { glist_t trans; gnode_t *gn; trans = hash_entry_val(itor->ent); for (gn = trans; gn; gn = gnode_next(gn)) { fsg_link_t *fl = gnode_ptr(gn); if (fl->wid == basewid) { fsg_link_t *link; /* Create transition object */ link = listelem_malloc(fsg->link_alloc); link->from_state = fl->from_state; link->to_state = fl->to_state; link->logs2prob = fl->logs2prob; /* FIXME!!!??? */ link->wid = altwid; trans = glist_add_ptr(trans, (void *) link); ++ntrans; } } hash_entry_val(itor->ent) = trans; } } E_DEBUG(2,("Added %d alternate word transitions\n", ntrans)); return ntrans; }
static fsg_model_t * jsgf_build_fsg_internal(jsgf_t * grammar, jsgf_rule_t * rule, logmath_t * lmath, float32 lw, int do_closure) { fsg_model_t *fsg; glist_t nulls; gnode_t *gn; int rule_entry, rule_exit; /* Clear previous links */ for (gn = grammar->links; gn; gn = gnode_next(gn)) { ckd_free(gnode_ptr(gn)); } glist_free(grammar->links); grammar->links = NULL; grammar->nstate = 0; /* Create the top-level entry state, and expand the top-level rule. */ rule_entry = grammar->nstate++; rule_exit = expand_rule(grammar, rule, rule_entry, NO_NODE); /* If no exit-state was created, create one. */ if (rule_exit == NO_NODE) { rule_exit = grammar->nstate++; jsgf_add_link(grammar, NULL, rule_entry, rule_exit); } fsg = fsg_model_init(rule->name, lmath, lw, grammar->nstate); fsg->start_state = rule_entry; fsg->final_state = rule_exit; grammar->links = glist_reverse(grammar->links); for (gn = grammar->links; gn; gn = gnode_next(gn)) { jsgf_link_t *link = gnode_ptr(gn); if (link->atom) { if (jsgf_atom_is_rule(link->atom)) { fsg_model_null_trans_add(fsg, link->from, link->to, logmath_log(lmath, link->atom->weight)); } else { int wid = fsg_model_word_add(fsg, link->atom->name); fsg_model_trans_add(fsg, link->from, link->to, logmath_log(lmath, link->atom->weight), wid); } } else { fsg_model_null_trans_add(fsg, link->from, link->to, 0); } } if (do_closure) { nulls = fsg_model_null_trans_closure(fsg, NULL); glist_free(nulls); } return fsg; }
static fsg_model_t * jsgf_build_fsg_internal(jsgf_t *grammar, jsgf_rule_t *rule, logmath_t *lmath, float32 lw, int do_closure) { fsg_model_t *fsg; glist_t nulls; gnode_t *gn; /* Clear previous links */ for (gn = grammar->links; gn; gn = gnode_next(gn)) { ckd_free(gnode_ptr(gn)); } glist_free(grammar->links); grammar->links = NULL; rule->entry = rule->exit = 0; grammar->nstate = 0; expand_rule(grammar, rule); fsg = fsg_model_init(rule->name, lmath, lw, grammar->nstate); fsg->start_state = rule->entry; fsg->final_state = rule->exit; grammar->links = glist_reverse(grammar->links); for (gn = grammar->links; gn; gn = gnode_next(gn)) { jsgf_link_t *link = gnode_ptr(gn); if (link->atom) { if (jsgf_atom_is_rule(link->atom)) { fsg_model_null_trans_add(fsg, link->from, link->to, logmath_log(lmath, link->atom->weight)); } else { int wid = fsg_model_word_add(fsg, link->atom->name); fsg_model_trans_add(fsg, link->from, link->to, logmath_log(lmath, link->atom->weight), wid); } } else { fsg_model_null_trans_add(fsg, link->from, link->to, 0); } } if (do_closure) { nulls = fsg_model_null_trans_closure(fsg, NULL); glist_free(nulls); } return fsg; }
fsg_model_t * gst_sphinx_construct_fsg (GstSphinxSink *sink, GSList *phrases) { fsg_model_t *fsg; GSList *l, *word_list; gchar **words; int n_states, n_transitions, i, j; n_states = 2; /* Final and initial state */ word_list = NULL; for (l = phrases; l; l = l->next) { words = g_strsplit (l->data, " ", 0); word_list = g_slist_append (word_list, words); n_states += g_strv_length (words); } n_transitions = n_states - 2; fsg = fsg_model_init ("desktop-control", ps_get_logmath (sink->decoder), 10.0, n_states); fsg->start_state = 0; fsg->final_state = n_states - 1; for (i = 0, l = word_list; l; l = l->next) { words = l->data; int wid, from_state, to_state, next; for (j = 0; words[j] != NULL; j++, i++) { wid = fsg_model_word_add(fsg, words[j]); from_state = (j == 0) ? 0 : i + 1; to_state = (words[j+1] == NULL) ? n_states - 1 : i + 2; fsg_model_trans_add (fsg, from_state, to_state, 0, wid); } } for (l = word_list; l; l = l->next) g_strfreev (l->data); g_slist_free (word_list); return fsg; }
ReturnType Recognizer::addGrammar(Integers& id, const Grammar& grammar) { if (decoder == NULL) return BAD_STATE; std::ostringstream grammar_name; grammar_name << grammar_index; grammar_names.push_back(grammar_name.str()); current_grammar = fsg_model_init(grammar_names.back().c_str(), logmath, 1.0, grammar.numStates); if (current_grammar == NULL) return RUNTIME_ERROR; current_grammar->start_state = grammar.start; current_grammar->final_state = grammar.end; for (int i=0;i<grammar.transitions.size();i++) { if (grammar.transitions.at(i).word.size() == 0) fsg_model_null_trans_add(current_grammar, grammar.transitions.at(i).from, grammar.transitions.at(i).to, grammar.transitions.at(i).logp); else fsg_model_trans_add(current_grammar, grammar.transitions.at(i).from, grammar.transitions.at(i).to, grammar.transitions.at(i).logp, fsg_model_word_add(current_grammar, grammar.transitions.at(i).word.c_str())); } fsg_model_add_silence(current_grammar, "<sil>", -1, 1.0); if(ps_set_fsg(decoder, grammar_names.back().c_str(), current_grammar)) { return RUNTIME_ERROR; } if (id.size() == 0) id.push_back(grammar_index); else id.at(0) = grammar_index; grammar_index++; // We switch to the newly added grammar right away if (ps_set_search(decoder, grammar_names.back().c_str())) { return RUNTIME_ERROR; } return SUCCESS; }