/*
* Load and cross-check all models (acoustic/lexical/linguistic).
*/
static void models_init ( void )
{
dict_t *dict;
/* HMM model definition */
mdef = mdef_init ((char *) cmd_ln_access("-mdeffn"));
/* Dictionary */
dict = dict_init ((char *) cmd_ln_access("-dictfn"),
(char *) cmd_ln_access("-fdictfn"));
/* HACK!! Make sure SILENCE_WORD, START_WORD and FINISH_WORD are in dictionary */
silwid = dict_wordid (SILENCE_WORD);
startwid = dict_wordid (START_WORD);
finishwid = dict_wordid (FINISH_WORD);
if (NOT_WID(silwid) || NOT_WID(startwid) || NOT_WID(finishwid)) {
E_FATAL("%s, %s, or %s missing from dictionary\n",
SILENCE_WORD, START_WORD, FINISH_WORD);
}
if ((dict->filler_start > dict->filler_end) || (! dict_filler_word (silwid)))
E_FATAL("%s must occur (only) in filler dictionary\n", SILENCE_WORD);
/* No check that alternative pronunciations for filler words are in filler range!! */
/* LM */
lm_read ((char *) cmd_ln_access("-lmfn"), "");
/* Filler penalties */
fillpen_init ((char *) cmd_ln_access("-fillpenfn"),
dict->filler_start, dict->filler_end);
}
static void
gst_pocketsphinx_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstPocketSphinx *sink = GST_POCKETSPHINX(object);
switch (prop_id) {
case PROP_HMM_DIR:
gst_pocketsphinx_set_string(sink, "-hmm", value);
break;
case PROP_LM_FILE:
/* FSG and LM are mutually exclusive. */
gst_pocketsphinx_set_string(sink, "-fsg", NULL);
gst_pocketsphinx_set_string(sink, "-lm", value);
/* Switch to this new LM if the decoder is active. */
if (sink->ad.initialized) {
lm_read(g_value_get_string(value),
g_value_get_string(value),
cmd_ln_float32("-lw"),
cmd_ln_float32("-uw"),
cmd_ln_float32("-wip"));
uttproc_set_lm(g_value_get_string(value));
}
break;
case PROP_DICT_FILE:
gst_pocketsphinx_set_string(sink, "-dict", value);
break;
case PROP_FSG_FILE:
/* FSG and LM are mutually exclusive */
gst_pocketsphinx_set_string(sink, "-lm", NULL);
gst_pocketsphinx_set_string(sink, "-fsg", value);
/* Switch to this new FSG if the decoder is active. */
if (sink->ad.initialized) {
char *fsgname;
fsgname = uttproc_load_fsgfile((char *)
g_value_get_string(value));
if (fsgname)
uttproc_set_fsg(fsgname);
}
break;
case PROP_S2_FSG:
{
s2_fsg_t *fsg = g_value_get_pointer(value);
uttproc_del_fsg(fsg->name);
uttproc_load_fsg(g_value_get_pointer(value),
cmd_ln_boolean("-fsgusealtpron"),
cmd_ln_boolean("-fsgusefiller"),
cmd_ln_float32("-silpen"),
cmd_ln_float32("-fillpen"),
cmd_ln_float32("-lw"));
uttproc_set_fsg(fsg->name);
break;
}
case PROP_FWDFLAT:
gst_pocketsphinx_set_boolean(sink, "-fwdflat", value);
break;
case PROP_BESTPATH:
gst_pocketsphinx_set_boolean(sink, "-bestpath", value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
return;
}
}
kbcore_t *kbcore_init (float64 logbase,
char *feattype,
char *cmn,
char *varnorm,
char *agc,
char *mdeffile,
char *dictfile,
char *fdictfile,
char *compsep,
char *lmfile,
char *fillpenfile,
float64 silprob,
float64 fillprob,
float64 langwt,
float64 inspen,
float64 uw,
char *meanfile,
char *varfile,
float64 varfloor,
char *mixwfile,
float64 mixwfloor,
char *subvqfile,
char *tmatfile,
float64 tmatfloor)
{
kbcore_t *kb;
E_INFO("Initializing core models:\n");
kb = (kbcore_t *) ckd_calloc (1, sizeof(kbcore_t));
kb->fcb = NULL;
kb->mdef = NULL;
kb->dict = NULL;
kb->dict2pid = NULL;
kb->lm = NULL;
kb->fillpen = NULL;
kb->dict2lmwid = NULL;
kb->mgau = NULL;
kb->svq = NULL;
kb->tmat = NULL;
logs3_init (logbase);
if (feattype) {
if ((kb->fcb = feat_init (feattype, cmn, varnorm, agc)) == NULL)
E_FATAL("feat_init(%s) failed\n", feattype);
if (feat_n_stream(kb->fcb) != 1)
E_FATAL("#Feature streams(%d) != 1\n", feat_n_stream(kb->fcb));
}
if (mdeffile) {
if ((kb->mdef = mdef_init (mdeffile)) == NULL)
E_FATAL("mdef_init(%s) failed\n", mdeffile);
}
if (dictfile) {
if (! compsep)
compsep = "";
else if ((compsep[0] != '\0') && (compsep[1] != '\0')) {
E_FATAL("Compound word separator(%s) must be empty or single character string\n",
compsep);
}
if ((kb->dict = dict_init (kb->mdef, dictfile, fdictfile, compsep[0])) == NULL)
E_FATAL("dict_init(%s,%s,%s) failed\n", dictfile,
fdictfile ? fdictfile : "", compsep);
}
if (lmfile) {
if ((kb->lm = lm_read (lmfile, langwt, inspen, uw)) == NULL)
E_FATAL("lm_read(%s, %e, %e, %e) failed\n", lmfile, langwt, inspen, uw);
}
if (fillpenfile || (lmfile && kb->dict)) {
if (! kb->dict) /* Sic */
E_FATAL("No dictionary for associating filler penalty file(%s)\n", fillpenfile);
if ((kb->fillpen = fillpen_init (kb->dict, fillpenfile, silprob, fillprob,
langwt, inspen)) == NULL)
E_FATAL("fillpen_init(%s) failed\n", fillpenfile);
}
if (meanfile) {
if ((! varfile) || (! mixwfile))
E_FATAL("Varfile or mixwfile not specified along with meanfile(%s)\n", meanfile);
kb->mgau = mgau_init (meanfile, varfile, varfloor, mixwfile, mixwfloor, TRUE);
if (kb->mgau == NULL)
E_FATAL("gauden_init(%s, %s, %e) failed\n", meanfile, varfile, varfloor);
if (subvqfile) {
if ((kb->svq = subvq_init (subvqfile, varfloor, -1, kb->mgau)) == NULL)
E_FATAL("subvq_init (%s, %e, -1) failed\n", subvqfile, varfloor);
}
}
if (tmatfile) {
if ((kb->tmat = tmat_init (tmatfile, tmatfloor)) == NULL)
E_FATAL("tmat_init (%s, %e) failed\n", tmatfile, tmatfloor);
}
if (kb->dict && kb->lm) { /* Initialize dict2lmwid */
if ((kb->dict2lmwid = wid_dict_lm_map (kb->dict, kb->lm)) == NULL)
E_FATAL("Dict/LM word-id mapping failed\n");
}
if (kb->mdef && kb->dict) { /* Initialize dict2pid */
kb->dict2pid = dict2pid_build (kb->mdef, kb->dict);
}
/* ***************** Verifications ***************** */
E_INFO("Verifying models consistency:\n");
if (kb->fcb && kb->mgau) {
/* Verify feature streams against gauden codebooks */
if (feat_stream_len(kb->fcb, 0) != mgau_veclen(kb->mgau))
E_FATAL("Feature streamlen(%d) != mgau streamlen(%d)\n",
feat_stream_len(kb->fcb, 0), mgau_veclen(kb->mgau));
}
if (kb->mdef && kb->mgau) {
/* Verify senone parameters against model definition parameters */
if (kb->mdef->n_sen != mgau_n_mgau(kb->mgau))
E_FATAL("Mdef #senones(%d) != mgau #senones(%d)\n",
kb->mdef->n_sen, mgau_n_mgau(kb->mgau));
}
if (kb->mdef && kb->tmat) {
/* Verify transition matrices parameters against model definition parameters */
if (kb->mdef->n_tmat != kb->tmat->n_tmat)
E_FATAL("Mdef #tmat(%d) != tmatfile(%d)\n", kb->mdef->n_tmat, kb->tmat->n_tmat);
if (kb->mdef->n_emit_state != kb->tmat->n_state)
E_FATAL("Mdef #states(%d) != tmat #states(%d)\n",
kb->mdef->n_emit_state, kb->tmat->n_state);
}
return kb;
}
void kb (int argc, char *argv[],
float ip, /* word insertion penalty */
float lw, /* langauge weight */
float pip) /* phone insertion penalty */
{
char *pname = argv[0];
char hmm_file_name[256];
int32 num_phones, num_ci_phones;
int32 i, use_darpa_lm;
/* FIXME: This is evil. But if we do it, let's prototype it
somewhere, OK? */
unlimit (); /* Remove memory size limits */
language_weight = lw;
insertion_penalty = ip;
phone_insertion_penalty = pip;
pconf (argc, argv, kb_param, 0, 0, 0);
if ((phone_file_name == 0) ||
(dict_file_name == 0))
pusage (pname, (Config_t *)kb_param);
log_info("%s(%d): Reading phone file [%s]\n",
__FILE__, __LINE__, phone_file_name);
if (phone_read (phone_file_name))
exit (-1);
if (useWDPhonesOnly)
phone_add_diphones();
num_ci_phones = phoneCiCount();
/* Read the distribution map file */
log_info("%s(%d): Reading map file [%s]\n", __FILE__, __LINE__, mapFileName);
read_map (mapFileName, TRUE /* useCiTrans compress */);
log_info("%s(%d): Reading dict file [%s]\n",
__FILE__, __LINE__, dict_file_name);
word_dict = dict_new ();
if (dict_read (word_dict, dict_file_name, phrase_dict_file_name,
noise_dict_file_name, !useWDPhonesOnly))
exit (-1);
use_darpa_lm = TRUE;
if (use_darpa_lm) {
lmSetStartSym (lm_start_sym);
lmSetEndSym (lm_end_sym);
/*
* Read control file describing multiple LMs, if specified.
* File format (optional stuff is indicated by enclosing in []):
*
* [{ LMClassFileName LMClassFilename ... }]
* TrigramLMFileName LMName [{ LMClassName LMClassName ... }]
* TrigramLMFileName LMName [{ LMClassName LMClassName ... }]
* ...
* (There should be whitespace around the { and } delimiters.)
*
* This is an extension of the older format that had only TrigramLMFilenName
* and LMName pairs. The new format allows a set of LMClass files to be read
* in and referred to by the trigram LMs. (Incidentally, if one wants to use
* LM classes in a trigram LM, one MUST use the -lmctlfn flag. It is not
* possible to read in a class-based trigram LM using the -lmfn flag.)
*
* No "comments" allowed in this file.
*/
if (lm_ctl_filename) {
FILE *ctlfp;
char lmfile[4096], lmname[4096], str[4096];
lmclass_set_t lmclass_set;
lmclass_t *lmclass, cl;
int32 n_lmclass, n_lmclass_used;
lmclass_set = lmclass_newset();
E_INFO("Reading LM control file '%s'\n", lm_ctl_filename);
ctlfp = CM_fopen (lm_ctl_filename, "r");
if (fscanf (ctlfp, "%s", str) == 1) {
if (strcmp (str, "{") == 0) {
/* Load LMclass files */
while ((fscanf (ctlfp, "%s", str) == 1) && (strcmp (str, "}") != 0))
lmclass_set = lmclass_loadfile (lmclass_set, str);
if (strcmp (str, "}") != 0)
E_FATAL("Unexpected EOF(%s)\n", lm_ctl_filename);
if (fscanf (ctlfp, "%s", str) != 1)
str[0] = '\0';
}
} else
str[0] = '\0';
/* Fill in dictionary word id information for each LMclass word */
for (cl = lmclass_firstclass(lmclass_set);
lmclass_isclass(cl);
cl = lmclass_nextclass(lmclass_set, cl)) {
kb_init_lmclass_dictwid (cl);
}
/* At this point if str[0] != '\0', we have an LM filename */
n_lmclass = lmclass_get_nclass(lmclass_set);
lmclass = (lmclass_t *) CM_calloc (n_lmclass, sizeof(lmclass_t));
/* Read in one LM at a time */
while (str[0] != '\0') {
strcpy (lmfile, str);
if (fscanf (ctlfp, "%s", lmname) != 1)
E_FATAL("LMname missing after LMFileName '%s'\n", lmfile);
n_lmclass_used = 0;
if (fscanf (ctlfp, "%s", str) == 1) {
if (strcmp (str, "{") == 0) {
/* LM uses classes; read their names */
while ((fscanf (ctlfp, "%s", str) == 1) &&
(strcmp (str, "}") != 0)) {
if (n_lmclass_used >= n_lmclass)
E_FATAL("Too many LM classes specified for '%s'\n",
lmfile);
lmclass[n_lmclass_used] = lmclass_get_lmclass (lmclass_set,
str);
if (! (lmclass_isclass(lmclass[n_lmclass_used])))
E_FATAL("LM class '%s' not found\n", str);
n_lmclass_used++;
}
if (strcmp (str, "}") != 0)
E_FATAL("Unexpected EOF(%s)\n", lm_ctl_filename);
if (fscanf (ctlfp, "%s", str) != 1)
str[0] = '\0';
}
} else
str[0] = '\0';
if (n_lmclass_used > 0)
lm_read_clm (lmfile, lmname,
language_weight, unigramWeight, insertion_penalty,
lmclass, n_lmclass_used);
else
lm_read (lmfile, lmname,
language_weight, unigramWeight, insertion_penalty);
}
fclose (ctlfp);
NoLangModel = FALSE;
}
/* Read "base" LM file, if specified */
if (lm_file_name) {
lmSetStartSym (lm_start_sym);
lmSetEndSym (lm_end_sym);
lm_read (lm_file_name, "", language_weight, unigramWeight, insertion_penalty);
/* Make initial OOV list known to this base LM */
lm_init_oov ();
NoLangModel = FALSE;
}
#ifdef USE_ILM
/* Init ILM module (non-std-Darpa LM, eg ug/bg cache LM) */
ilm_init ();
#endif
}
#if 0
/* Compute the phrase lm probabilities */
computePhraseLMProbs ();
#endif
num_phones = phone_count ();
numSmds = hmm_num_sseq();
smds = (SMD *) CM_calloc (numSmds, sizeof (SMD));
/*
* Read the hmm's into the SMD structures
*/
if (useBigHmmFiles) {
for (i = 0; i < num_ci_phones; i++) {
sprintf (hmm_file_name, "%s.%s", phone_from_id (i),
hmm_ext);
hmm_tied_read_big_bin (hmm_dir_list, hmm_file_name, smds,
transSmooth, NUMOFCODEENTRIES, TRUE,
transWeight);
}
} else {
for (i = 0; i < num_phones; i++) {
if ((!useCiTrans) || (phone_id_to_base_id(i) == i)) {
sprintf (hmm_file_name, "%s.%s", phone_from_id (i), hmm_ext);
hmm_tied_read_bin (hmm_dir_list, hmm_file_name,
&smds[hmm_pid2sid(i)], transSmooth,
NUMOFCODEENTRIES, TRUE, transWeight);
}
}
}
/*
* Use Ci transitions ?
*/
if (useCiTrans) {
for (i = 0; i < num_phones; i++) {
if (hmm_pid2sid(phone_id_to_base_id(i)) != hmm_pid2sid(i)) {
/*
* Just make a copy of the CI phone transitions
*/
memcpy (&smds[hmm_pid2sid(i)], &smds[hmm_pid2sid(phone_id_to_base_id(i))],
sizeof (SMD));
}
}
}
/*
* Read the distributions
*/
read_dists (hmm_dir, code1_ext, code2_ext, code3_ext, code4_ext,
NUMOFCODEENTRIES, hmm_smooth_min, useCiPhonesOnly);
if (Use8BitSenProb)
SCVQSetSenoneCompression (8);
/*
* Map the distributions to the correct locations
*/
remap (smds);
}
void kbAddGrammar(char const *fileName, char const *grammarName)
{
lmSetStartSym (lm_start_sym);
lmSetEndSym (lm_end_sym);
lm_read (fileName, grammarName, language_weight, unigramWeight, insertion_penalty);
}
int main(int argc, char *argv[])
{
char *lm_file;
char *args_file;
char *ngrams_file;
char *lmLoadTimer = "LM Load";
char *lmLookupTimer = "LM Lookup";
char *ngrams[MAX_NGRAMS];
float64 lw, wip, uw, logbase;
int i, n, score;
int32 *nwdptr;
int32 nwords[MAX_NGRAMS];
int scores[MAX_NGRAMS];
lm_t *lm;
s3lmwid_t wid[MAX_NGRAMS][MAX_WORDS_PER_NGRAM];
FILE* fp;
if (argc < 3) {
E_FATAL("USAGE: %s <lm_file> <args_file> <ngrams_file>\n", argv[0]);
}
args_file = argv[1];
lm_file = argv[2];
ngrams_file = argv[3];
parse_args_file(args_file);
lw = cmd_ln_float32("-lw");
wip = cmd_ln_float32("-wip");
uw = cmd_ln_float32("-uw");
logbase = cmd_ln_float32("-logbase");
logs3_init(logbase);
metricsStart(lmLoadTimer);
/* initialize the language model */
lm = lm_read(lm_file, lw, wip, uw);
metricsStop(lmLoadTimer);
if ((fp = fopen(ngrams_file, "r")) == NULL) {
E_FATAL("Unable to open N-gram file %s\n", ngrams_file);
}
while (has_more_utterances(fp)) {
/* read in all the N-grams */
n = read_ngrams(fp, ngrams, wid, nwords, MAX_NGRAMS, lm);
metricsStart(lmLookupTimer);
/* scores the N-grams */
for (i = 0; i < n; i++) {
scores[i] = score_ngram(wid[i], nwords[i], lm);
printf("%-10d %s\n", scores[i], ngrams[i]);
/*
printf("%-10d %s %d %d %d\n", scores[i], ngrams[i],
wid[i][0], wid[i][1], wid[i][2]);
*/
}
/* reset cache if <END_UTT> was reached */
if (n != MAX_NGRAMS) {
lm_cache_reset(lm);
}
metricsStop(lmLookupTimer);
}
printf("Bigram misses: %d \n", lm->n_bg_bo);
printf("Trigram misses: %d \n", lm->n_tg_bo);
fflush(stdout);
metricsPrint();
}
