int
main(int argc, char *argv[])
{
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", defn);
unlimit();
config = cmd_ln_get();
logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1,
cmd_ln_int32_r(config, "-log3table"));
E_INFO("Value of base %f \n", cmd_ln_float32_r(config, "-logbase"));
models_init();
ptmr_init(&tm_utt);
if ((inmatchsegfp = fopen(cmd_ln_str_r(config, "-inhypseg"), "r")) == NULL)
E_ERROR("fopen(%s,r) failed\n", cmd_ln_str_r(config, "-inhypseg"));
if ((outconfmatchsegfp = fopen(cmd_ln_str_r(config, "-output"), "w")) == NULL)
E_ERROR("fopen(%s,w) failed\n", cmd_ln_str_r(config, "-output"));
if (cmd_ln_str_r(config, "-ctl")) {
ctl_process(cmd_ln_str_r(config, "-ctl"),
cmd_ln_str_r(config, "-ctl_lm"),
NULL,
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"), utt_confidence, NULL);
}
else {
E_FATAL("-ctl is not specified\n");
}
#if (! WIN32)
system("ps auxwww | grep s3dag");
#endif
fclose(outconfmatchsegfp);
fclose(inmatchsegfp);
models_free();
logmath_free(logmath);
cmd_ln_free_r(config);
return 0;
}
main (int32 argc, char *argv[])
{
tmat_t *t;
float64 flr;
if (argc < 3)
E_FATAL("Usage: %s tmat floor\n", argv[0]);
if (sscanf (argv[2], "%lf", &flr) != 1)
E_FATAL("Usage: %s tmat floor\n", argv[0]);
logs3_init ((float64) 1.0001);
t = tmat_init (argv[1], flr);
tmat_dump (t);
}
main (int32 argc, char *argv[])
{
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
if (argc != 4)
usage(argv[0]);
logs3_init (1.0003);
mdef = mdef_init (argv[1]);
dict = dict_init (mdef, argv[2], argv[3], 0);
d2p = dict2pid_build (mdef, dict);
dict2pid_dump (stdout, d2p, mdef, dict);
}
int
main(int32 argc, char *argv[])
{
/* kb_t kb;
ptmr_t tm; */
cmd_ln_appl_enter(argc, argv, "default.arg", defn);
config = cmd_ln_get();
logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1,
cmd_ln_int32_r(config, "-log3table"));
/* Read in input databases */
models_init();
ptmr_init(&tm_utt);
nbestdir = cmd_ln_str_r(config, "-nbestdir");
if (cmd_ln_str_r(config, "-ctl")) {
ctl_process(cmd_ln_str_r(config, "-ctl"),
cmd_ln_str_r(config, "-ctl_lm"),
NULL,
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"), utt_astar, NULL);
}
else {
E_FATAL("-ctl is not specified\n");
}
models_free();
logmath_free(logmath);
#if (! WIN32)
system("ps aguxwww | grep s3astar");
#endif
cmd_ln_free_r(config);
return 0;
}
main (int argc, char *argv[])
{
float64 base;
float64 p, q;
int32 logp, logq, logpq;
printf ("base: ");
scanf ("%lf", &base);
if (logs3_init (base) < 0)
exit (-1);
for (;;) {
printf ("p,q: ");
scanf ("%lf %lf", &p, &q);
logp = logs3 (p);
logq = logs3 (q);
logpq = logs3_add (logp, logq);
printf ("logB(p,q) = %d, %d\n", logp, logq);
printf ("logB(p+q) = %d, expected %d\n", logpq, logs3 (p+q));
}
}
/* RAH, April 26th, 2001, opened file tmat_test.out and added tmat_free(t) call, there are no memory leaks here */
main (int32 argc, char *argv[])
{
tmat_t *t;
float64 flr;
FILE *fp;
if (argc < 3)
E_FATAL("Usage: %s tmat floor\n", argv[0]);
if (sscanf (argv[2], "%lf", &flr) != 1)
E_FATAL("Usage: %s tmat floor\n", argv[0]);
fp = fopen ("tmat_test.out","wt");
if (! fp) {
fprintf (stderr,"Unable to topen tmat_test.out for writing\n");
exit (-1);
}
logs3_init ((float64) 1.0001);
t = tmat_init (argv[1], flr);
tmat_dump (t,fp);
tmat_free (t);
}
int32
main(int32 argc, char *argv[])
{
FILE *fpout;
mgau_model_t *mgau;
int32 **subvec;
int32 max_datarows, datarows, datacols, svqrows, svqcols;
float32 **data, **vqmean;
int32 *datamap, *vqmap;
float64 sqerr;
int32 stdev;
int32 i, j, v, m, c;
cmd_ln_t *config;
logmath_t *logmath;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", arg);
unlimit();
config = cmd_ln_get();
logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1, cmd_ln_int32_r(config, "-log3table")); /*Report Progress, use log table */
/* Load means/vars but DO NOT precompute variance inverses or determinants */
mgau = mgau_init(cmd_ln_str_r(config, "-mean"),
cmd_ln_str_r(config, "-var"), 0.0 /* no varfloor */ ,
cmd_ln_str_r(config, "-mixw"), cmd_ln_float32_r(config, "-mixwfloor"), FALSE, /* No precomputation */
".cont.", MIX_INT_FLOAT_COMP, logmath);
/* Parse subvector spec argument; subvec is null terminated; subvec[x] is -1 terminated */
subvec = parse_subvecs(cmd_ln_str_r(config, "-svspec"));
if (cmd_ln_str_r(config, "-subvq")) {
if ((fpout = fopen(cmd_ln_str_r(config, "-subvq"), "w")) == NULL) {
E_ERROR_SYSTEM("Failed to open output file '%s'", fpout);
return 1;
}
}
else
fpout = stdout;
/* Echo command line to output file */
for (i = 0; i < argc - 1; i++)
fprintf(fpout, "# %s \\\n", argv[i]);
fprintf(fpout, "# %s\n#\n", argv[argc - 1]);
/* Print input and output configurations to output file */
for (v = 0; subvec[v]; v++); /* No. of subvectors */
svqrows = cmd_ln_int32_r(config, "-svqrows");
fprintf(fpout, "VQParam %d %d -> %d %d\n",
mgau_n_mgau(mgau), mgau_max_comp(mgau), v, svqrows);
for (v = 0; subvec[v]; v++) {
for (i = 0; subvec[v][i] >= 0; i++);
fprintf(fpout, "Subvector %d length %d ", v, i);
for (i = 0; subvec[v][i] >= 0; i++)
fprintf(fpout, " %2d", subvec[v][i]);
fprintf(fpout, "\n");
}
fflush(fpout);
/*
* datamap[] for identifying non-0 input vectors that take part in the clustering process:
* datamap[m*max_mean + c] = row index of data[][] containing the copy.
* vqmap[] for mapping vq input data to vq output.
*/
max_datarows = mgau_n_mgau(mgau) * mgau_max_comp(mgau);
datamap = (int32 *) ckd_calloc(max_datarows, sizeof(int32));
vqmap = (int32 *) ckd_calloc(max_datarows, sizeof(int32));
stdev = cmd_ln_int32_r(config, "-stdev");
/* Copy and cluster each subvector */
for (v = 0; subvec[v]; v++) {
E_INFO("Clustering subvector %d\n", v);
for (datacols = 0; subvec[v][datacols] >= 0; datacols++); /* Input subvec length */
svqcols = datacols * 2; /* subvec length after concatenating mean + var */
/* Allocate input/output data areas */
data =
(float32 **) ckd_calloc_2d(max_datarows, svqcols,
sizeof(float32));
vqmean =
(float32 **) ckd_calloc_2d(svqrows, svqcols, sizeof(float32));
/* Make a copy of the subvectors from the input data, and initialize maps */
for (i = 0; i < max_datarows; i++)
datamap[i] = -1;
datarows = 0;
for (m = 0; m < mgau_n_mgau(mgau); m++) { /* For each mixture m */
for (c = 0; c < mgau_n_comp(mgau, m); c++) { /* For each component c in m */
if (vector_is_zero
(mgau_var(mgau, m, c), mgau_veclen(mgau))) {
E_INFO("Skipping mgau %d comp %d\n", m, c);
continue;
}
for (i = 0; i < datacols; i++) { /* Copy specified dimensions, mean+var */
data[datarows][i * 2] =
mgau->mgau[m].mean[c][subvec[v][i]];
data[datarows][i * 2 + 1] =
(!stdev) ? mgau->mgau[m].
var[c][subvec[v][i]] : sqrt(mgau->mgau[m].
var[c][subvec[v][i]]);
}
datamap[m * mgau_max_comp(mgau) + c] = datarows++;
}
}
E_INFO("Sanity check: input data[0]:\n");
vector_print(stderr, data[0], svqcols);
for (i = 0; i < max_datarows; i++)
vqmap[i] = -1;
#if 0
{
int32 **in;
printf("Input data: %d x %d\n", datarows, svqcols);
in = (int32 **) data;
for (i = 0; i < datarows; i++) {
printf("%8d:", i);
for (j = 0; j < svqcols; j++)
printf(" %08x", in[i][j]);
printf("\n");
}
for (i = 0; i < datarows; i++) {
printf("%15d:", i);
for (j = 0; j < svqcols; j++)
printf(" %15.7e", data[i][j]);
printf("\n");
}
fflush(stdout);
}
#endif
/* VQ the subvector copy built above */
sqerr = vector_vqgen(data, datarows, svqcols, svqrows,
cmd_ln_float64_r(config, "-eps"), cmd_ln_int32_r(config, "-iter"),
vqmean, vqmap, cmd_ln_int32_r(config, "-seed"));
/* Output VQ */
fprintf(fpout, "Codebook %d Sqerr %e\n", v, sqerr);
for (i = 0; i < svqrows; i++) {
if (stdev) {
/* Convert clustered stdev back to var */
for (j = 1; j < svqcols; j += 2)
vqmean[i][j] *= vqmean[i][j];
}
vector_print(fpout, vqmean[i], svqcols);
}
fprintf(fpout, "Map %d\n", v);
for (i = 0; i < max_datarows; i += mgau_max_comp(mgau)) {
for (j = 0; j < mgau_max_comp(mgau); j++) {
if (datamap[i + j] < 0)
fprintf(fpout, " -1");
else
fprintf(fpout, " %d", vqmap[datamap[i + j]]);
}
fprintf(fpout, "\n");
}
fflush(fpout);
/* Cleanup */
ckd_free_2d((void **) data);
ckd_free_2d((void **) vqmean);
}
subvecs_free(subvec);
ckd_free(datamap);
ckd_free(vqmap);
mgau_free(mgau);
fprintf(fpout, "End\n");
fclose(fpout);
logmath_free(logmath);
cmd_ln_free_r(config);
exit(0);
}
main (int32 argc, char *argv[])
{
char *str;
#if 0
ckd_debug(100000);
#endif
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
/* Digest command line argument definitions */
cmd_ln_define (defn);
if ((argc == 2) && (strcmp (argv[1], "help") == 0)) {
cmd_ln_print_definitions();
exit(1);
}
/* Look for default or specified arguments file */
str = NULL;
if ((argc == 2) && (argv[1][0] != '-'))
str = argv[1];
else if (argc == 1) {
str = "s3align.arg";
E_INFO("Looking for default argument file: %s\n", str);
}
if (str) {
/* Build command line argument list from file */
if ((argc = load_argfile (str, argv[0], &argv)) < 0) {
fprintf (stderr, "Usage:\n");
fprintf (stderr, "\t%s argument-list, or\n", argv[0]);
fprintf (stderr, "\t%s [argument-file] (default file: s3align.arg)\n\n",
argv[0]);
cmd_ln_print_definitions();
exit(1);
}
}
cmdline_parse (argc, argv);
if ((cmd_ln_access("-mdeffn") == NULL) ||
(cmd_ln_access("-meanfn") == NULL) ||
(cmd_ln_access("-varfn") == NULL) ||
(cmd_ln_access("-mixwfn") == NULL) ||
(cmd_ln_access("-tmatfn") == NULL) ||
(cmd_ln_access("-dictfn") == NULL))
E_FATAL("Missing -mdeffn, -meanfn, -varfn, -mixwfn, -tmatfn, or -dictfn argument\n");
if ((cmd_ln_access("-ctlfn") == NULL) || (cmd_ln_access("-insentfn") == NULL))
E_FATAL("Missing -ctlfn or -insentfn argument\n");
if ((cmd_ln_access ("-s2stsegdir") == NULL) &&
(cmd_ln_access ("-stsegdir") == NULL) &&
(cmd_ln_access ("-phsegdir") == NULL) &&
(cmd_ln_access ("-wdsegdir") == NULL) &&
(cmd_ln_access ("-outsentfn") == NULL))
E_FATAL("Missing output file/directory argument(s)\n");
tm_utt = timing_new ();
/*
* Initialize log(S3-base). All scores (probs...) computed in log domain to avoid
* underflow. At the same time, log base = 1.0001 (1+epsilon) to allow log values
* to be maintained in int32 variables without significant loss of precision.
*/
if (cmd_ln_access("-logbase") == NULL)
logs3_init (1.0001);
else {
float32 logbase;
logbase = *((float32 *) cmd_ln_access("-logbase"));
if (logbase <= 1.0)
E_FATAL("Illegal log-base: %e; must be > 1.0\n", logbase);
if (logbase > 1.1)
E_WARN("Logbase %e perhaps too large??\n", logbase);
logs3_init ((float64) logbase);
}
/* Initialize feature stream type */
feat_init ((char *) cmd_ln_access ("-feat"));
/* BHIKSHA: PASS CEPSIZE TO FEAT_CEPSIZE, 6 Jan 98 */
cepsize = *((int32 *) cmd_ln_access("-ceplen"));
cepsize = feat_cepsize (cepsize);
/* END CHANGES BY BHIKSHA */
/* Read in input databases */
models_init ();
senscale = (int32 *) ckd_calloc (S3_MAX_FRAMES, sizeof(int32));
tmr_utt = cyctimer_new ("U");
tmr_gauden = cyctimer_new ("G");
tmr_senone = cyctimer_new ("S");
tmr_align = cyctimer_new ("A");
/* Initialize align module */
align_init ();
printf ("\n");
tot_nfr = 0;
process_ctlfile ();
if (tot_nfr > 0) {
printf ("\n");
printf("TOTAL FRAMES: %8d\n", tot_nfr);
printf("TOTAL CPU TIME: %11.2f sec, %7.2f xRT\n",
tm_utt->t_tot_cpu, tm_utt->t_tot_cpu/(tot_nfr*0.01));
printf("TOTAL ELAPSED TIME: %11.2f sec, %7.2f xRT\n",
tm_utt->t_tot_elapsed, tm_utt->t_tot_elapsed/(tot_nfr*0.01));
}
#if (! WIN32)
system ("ps aguxwww | grep s3align");
#endif
/* Hack!! To avoid hanging problem under Linux */
if (logfp) {
fclose (logfp);
*stdout = orig_stdout;
*stderr = orig_stderr;
}
exit(0);
}
main (int32 argc, char *argv[])
{
char *str;
#if 0
ckd_debug(100000);
#endif
/* Digest command line argument definitions */
cmd_ln_define (defn);
if ((argc == 2) && (strcmp (argv[1], "help") == 0)) {
cmd_ln_print_definitions();
exit(1);
}
/* Look for default or specified arguments file */
str = NULL;
if ((argc == 2) && (argv[1][0] != '-'))
str = argv[1];
else if (argc == 1) {
str = "s3decode.arg";
E_INFO("Looking for default argument file: %s\n", str);
}
if (str) {
/* Build command line argument list from file */
if ((argc = load_argfile (str, argv[0], &argv)) < 0) {
fprintf (stderr, "Usage:\n");
fprintf (stderr, "\t%s argument-list, or\n", argv[0]);
fprintf (stderr, "\t%s [argument-file] (default file: s3decode.arg)\n\n",
argv[0]);
cmd_ln_print_definitions();
exit(1);
}
}
cmdline_parse (argc, argv);
/* Remove memory allocation restrictions */
unlimit ();
#if (! WIN32)
{
char buf[1024];
gethostname (buf, 1024);
buf[1023] = '\0';
E_INFO ("Executing on: %s\n", buf);
}
#endif
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
if ((cmd_ln_access("-mdeffn") == NULL) ||
(cmd_ln_access("-dictfn") == NULL) ||
(cmd_ln_access("-lmfn") == NULL))
E_FATAL("Missing -mdeffn, -dictfn, or -lmfn argument\n");
/*
* Initialize log(S3-base). All scores (probs...) computed in log domain to avoid
* underflow. At the same time, log base = 1.0001 (1+epsilon) to allow log values
* to be maintained in int32 variables without significant loss of precision.
*/
if (cmd_ln_access("-logbase") == NULL)
logs3_init (1.0001);
else {
float32 logbase;
logbase = *((float32 *) cmd_ln_access("-logbase"));
if (logbase <= 1.0)
E_FATAL("Illegal log-base: %e; must be > 1.0\n", logbase);
if (logbase > 1.1)
E_WARN("Logbase %e perhaps too large??\n", logbase);
logs3_init ((float64) logbase);
}
/* Read in input databases */
models_init ();
/* Allocate timing object */
tm_utt = timing_new ();
tot_nfr = 0;
/* Initialize forward Viterbi search module */
dag_init ();
printf ("\n");
process_ctlfile ();
printf ("\n");
printf("TOTAL FRAMES: %8d\n", tot_nfr);
if (tot_nfr > 0) {
printf("TOTAL CPU TIME: %11.2f sec, %7.2f xRT\n",
tm_utt->t_tot_cpu, tm_utt->t_tot_cpu/(tot_nfr*0.01));
printf("TOTAL ELAPSED TIME: %11.2f sec, %7.2f xRT\n",
tm_utt->t_tot_elapsed, tm_utt->t_tot_elapsed/(tot_nfr*0.01));
}
fflush (stdout);
#if (! WIN32)
system ("ps auxwww | grep s3dag");
#endif
/* Hack!! To avoid hanging problem under Linux */
if (logfp) {
fclose (logfp);
*stdout = orig_stdout;
*stderr = orig_stderr;
}
exit(0);
}
static void
models_init(cmd_ln_t *config)
{
int32 cisencnt;
kbc = New_kbcore(config);
kbc->logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1,
cmd_ln_int32_r(config, "-log3table"));
/* Initialize feaure stream type */
kbc->fcb = feat_init(cmd_ln_str_r(config, "-feat"),
cmn_type_from_str(cmd_ln_str_r(config, "-cmn")),
cmd_ln_boolean_r(config, "-varnorm"),
agc_type_from_str(cmd_ln_str_r(config, "-agc")), 1,
cmd_ln_int32_r(config, "-ceplen"));
s3_am_init(kbc);
/* Initialize the front end if -adcin is specified */
if (cmd_ln_exists_r(config, "-adcin") && cmd_ln_boolean_r(config, "-adcin")) {
if ((fe = fe_init_auto_r(config)) == NULL) {
E_FATAL("fe_init_auto_r() failed\n");
}
}
assert(kbc);
assert(kbc->mdef);
assert(kbc->tmat);
/* Dictionary */
dict = dict_init(kbc->mdef, cmd_ln_str_r(config, "-dict"),
cmd_ln_str_r(config, "-fdict"),
cmd_ln_int32_r(config, "-lts_mismatch"),
cmd_ln_boolean_r(config, "-mdef_fillers"),
/* Never do mdef filler phones. */
FALSE,
TRUE);
for (cisencnt = 0; cisencnt == kbc->mdef->cd2cisen[cisencnt];
cisencnt++);
ascr = ascr_init(kbc->mdef->n_sen, 0, /* No composite senone */
mdef_n_sseq(kbc->mdef), 0, /* No composite senone sequence */
1, /* Phoneme lookahead window =1. Not enabled phoneme lookahead at this moment */
cisencnt);
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"),
kbc->mdef->n_ci_sen,
kbc->logmath);
adapt_am = adapt_am_init();
}
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;
}
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();
}
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;
int32 nwords[MAX_NGRAMS];
int scores[MAX_NGRAMS];
lm_t *lm;
s3lmwid32_t *wid[MAX_NGRAMS];
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, 1, 1); /*Report progress and use log table */
metricsStart(lmLoadTimer);
/* initialize the language model */
/* HACK! This doesn't work for class-based LM */
lm = lm_read_advance(lm_file, "default", lw, wip, uw, 0, NULL, 1);
metricsStop(lmLoadTimer);
/* read in all the N-grams */
n = read_ngrams(ngrams_file, 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);
}
metricsStop(lmLookupTimer);
for (i = 0; i < n; i++) {
printf("%-10d %s\n", scores[i], ngrams[i]);
}
printf("Bigram misses: %d \n", lm->n_bg_bo);
printf("Trigram misses: %d \n", lm->n_tg_bo);
fflush(stdout);
metricsPrint();
return 0;
}
