static void cmn_prior_shiftwin(cmn_t *cmn) { mfcc_t sf; int32 i; E_INFO("cmn_prior_update: from < "); for (i = 0; i < cmn->veclen; i++) E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i])); E_INFOCONT(">\n"); sf = FLOAT2MFCC(1.0) / cmn->nframe; for (i = 0; i < cmn->veclen; i++) cmn->cmn_mean[i] = cmn->sum[i] / cmn->nframe; /* sum[i] * sf */ /* Make the accumulation decay exponentially */ if (cmn->nframe >= CMN_WIN_HWM) { sf = CMN_WIN * sf; for (i = 0; i < cmn->veclen; i++) cmn->sum[i] = MFCCMUL(cmn->sum[i], sf); cmn->nframe = CMN_WIN; } E_INFO("cmn_prior_update: to < "); for (i = 0; i < cmn->veclen; i++) E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i])); E_INFOCONT(">\n"); }
void feat_report(feat_t * f) { int i; E_INFO_NOFN("Initialization of feat_t, report:\n"); E_INFO_NOFN("Feature type = %s\n", f->name); E_INFO_NOFN("Cepstral size = %d\n", f->cepsize); E_INFO_NOFN("Number of streams = %d\n", f->n_stream); for (i = 0; i < f->n_stream; i++) { E_INFO_NOFN("Vector size of stream[%d]: %d\n", i, f->stream_len[i]); } E_INFO_NOFN("Number of subvectors = %d\n", f->n_sv); for (i = 0; i < f->n_sv; i++) { int32 *sv; E_INFO_NOFN("Components of subvector[%d]:", i); for (sv = f->subvecs[i]; sv && *sv != -1; ++sv) E_INFOCONT(" %d", *sv); E_INFOCONT("\n"); } E_INFO_NOFN("Whether CMN is used = %d\n", f->cmn); E_INFO_NOFN("Whether AGC is used = %d\n", f->agc); E_INFO_NOFN("Whether variance is normalized = %d\n", f->varnorm); E_INFO_NOFN("\n"); }
static void usagemsg(char *pgm) { E_INFO("Usage: %s -jsgf <input.jsgf> -rule <rule name>\\\n", pgm); E_INFOCONT("\t[-fsm yes/no] [-compile yes/no]\n"); E_INFOCONT("\t-fsg <output.fsg>\n"); exit(0); }
static void fwd_timing_dump(srch_FLAT_FWD_graph_t * fwg) { E_INFO("[H %6.2fx ]", fwg->tm_hmmeval.t_cpu * 100.0 / fwg->n_frm); E_INFOCONT("[XH %6.2fx]", fwg->tm_hmmtrans.t_cpu * 100.0 / fwg->n_frm); E_INFOCONT("[XW %6.2fx]\n", fwg->tm_wdtrans.t_cpu * 100.0 / fwg->n_frm); E_INFOCONT("[mpx %d][~mpx %d]", fwg->ctr_mpx_whmm->count, fwg->ctr_nonmpx_whmm->count); }
static void usagemsg(char *pgm) { E_INFO("Usage: %s -i <input.lm> \\\n", pgm); E_INFOCONT("\t[-ifmt txt] [-ofmt dmp]\n"); E_INFOCONT("\t-o <output.lm.DMP>\n"); exit(0); }
void cmd_ln_appl_enter(int argc, char *argv[], const char *default_argfn, const arg_t * defn) { /* Look for default or specified arguments file */ const char *str; str = NULL; if ((argc == 2) && (strcmp(argv[1], "help") == 0)) { cmd_ln_print_help(stderr, defn); exit(1); } if ((argc == 2) && (argv[1][0] != '-')) str = argv[1]; else if (argc == 1) { FILE *fp; E_INFO("Looking for default argument file: %s\n", default_argfn); if ((fp = fopen(default_argfn, "r")) == NULL) { E_INFO("Can't find default argument file %s.\n", default_argfn); } else { str = default_argfn; } if (fp != NULL) fclose(fp); } if (str) { /* Build command line argument list from file */ E_INFO("Parsing command lines from file %s\n", str); if (cmd_ln_parse_file(defn, str, TRUE)) { E_INFOCONT("Usage:\n"); E_INFOCONT("\t%s argument-list, or\n", argv[0]); E_INFOCONT("\t%s [argument-file] (default file: . %s)\n\n", argv[0], default_argfn); cmd_ln_print_help(stderr, defn); exit(1); } } else { cmd_ln_parse(defn, argc, argv, TRUE); } }
int main(int argc, char *argv[]) { logmath_t *lmath; cmd_ln_t *config; acmod_t *acmod; ps_mgau_t *ps; ptm_mgau_t *s; int i, lastcb; lmath = logmath_init(1.0001, 0, 0); config = cmd_ln_init(NULL, ps_args(), TRUE, "-compallsen", "yes", "-input_endian", "little", NULL); cmd_ln_parse_file_r(config, ps_args(), MODELDIR "/en-us/en-us/feat.params", FALSE); cmd_ln_set_str_extra_r(config, "_mdef", MODELDIR "/en-us/en-us/mdef"); cmd_ln_set_str_extra_r(config, "_mean", MODELDIR "/en-us/en-us/means"); cmd_ln_set_str_extra_r(config, "_var", MODELDIR "/en-us/en-us/variances"); cmd_ln_set_str_extra_r(config, "_tmat", MODELDIR "/en-us/en-us/transition_matrices"); cmd_ln_set_str_extra_r(config, "_sendump", MODELDIR "/en-us/en-us/sendump"); cmd_ln_set_str_extra_r(config, "_mixw", NULL); cmd_ln_set_str_extra_r(config, "_lda", NULL); cmd_ln_set_str_extra_r(config, "_senmgau", NULL); err_set_debug_level(3); TEST_ASSERT(config); TEST_ASSERT((acmod = acmod_init(config, lmath, NULL, NULL))); TEST_ASSERT((ps = acmod->mgau)); TEST_EQUAL(0, strcmp(ps->vt->name, "ptm")); s = (ptm_mgau_t *)ps; E_DEBUG(2,("PTM model loaded: %d codebooks, %d senones, %d frames of history\n", s->g->n_mgau, s->n_sen, s->n_fast_hist)); E_DEBUG(2,("Senone to codebook mappings:\n")); lastcb = s->sen2cb[0]; E_DEBUG(2,("\t%d: 0", lastcb)); for (i = 0; i < s->n_sen; ++i) { if (s->sen2cb[i] != lastcb) { lastcb = s->sen2cb[i]; E_DEBUGCONT(2,("-%d\n", i-1)); E_DEBUGCONT(2,("\t%d: %d", lastcb, i)); } } E_INFOCONT("-%d\n", i-1); run_acmod_test(acmod); #if 0 /* Replace it with ms_mgau. */ ptm_mgau_free(ps); cmd_ln_set_str_r(config, "-mixw", MODELDIR "/en-us/en-us/mixture_weights"); TEST_ASSERT((acmod->mgau = ms_mgau_init(acmod, lmath, acmod->mdef))); run_acmod_test(acmod); cmd_ln_free_r(config); #endif return 0; }
void cmn_prior_set(cmn_t *cmn, mfcc_t const * vec) { int32 i; E_INFO("cmn_prior_set: from < "); for (i = 0; i < cmn->veclen; i++) E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i])); E_INFOCONT(">\n"); for (i = 0; i < cmn->veclen; i++) { cmn->cmn_mean[i] = vec[i]; cmn->sum[i] = vec[i] * CMN_WIN; } cmn->nframe = CMN_WIN; E_INFO("cmn_prior_set: to < "); for (i = 0; i < cmn->veclen; i++) E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i])); E_INFOCONT(">\n"); }
static uint32 setup_obs_multiclass(uint32 ts, uint32 strm, uint32 n_frame, const uint32 *veclen) { uint32 i, o, k; uint32 n_i_frame; vector_t **feat; uint32 d_ts; uint32 n_sv_frame; n_sv_frame = n_frame / stride; if ((l_ts == ts) && (l_strm == strm)) { E_INFO("No need to read data; using existing buffered data\n"); return n_sv_frame; } n_tot_frame += n_sv_frame; l_ts = ts; l_strm = strm; E_INFO("alloc'ing %uMb obs buf\n", n_sv_frame*veclen[strm]*sizeof(float32) / (1024 * 1024)); if (obuf) { ckd_free(obuf); obuf = NULL; } obuf = ckd_calloc(n_sv_frame * veclen[strm], sizeof(float32)); vlen = veclen[strm]; if (stride == 1) { E_INFO("Reading all frames\n"); } else { E_INFO("Reading 1 out of every %u frames from obs dmp file...\n", stride); } if (o2d) { E_INFO("o_ts == %u ->", ts); for (k = 0; k < n_o2d[ts]; k++) { E_INFOCONT(" %d", o2d[ts][k]); } E_INFOCONT("\n"); for (k = 0, o = 0; k < n_o2d[ts]; k++) { d_ts = o2d[ts][k]; for (i = 0; segdmp_next_feat(d_ts, &feat, &n_i_frame); i++) { assert(n_i_frame == 1); if ((i % stride) == 0) { memcpy(&obuf[o], (void *)&feat[0][strm][0], sizeof(float32) * vlen); o += vlen; } ckd_free((void *)&feat[0][0][0]); ckd_free_2d((void **)feat); } } } else { E_INFO("dmp mdef == output mdef\n"); for (i = 0, o = 0; segdmp_next_feat(ts, &feat, &n_i_frame); i++) { assert(n_i_frame == 1); if ((i % stride) == 0) { memcpy(&obuf[o], (void *)&feat[0][strm][0], sizeof(float32) * vlen); o += vlen; } ckd_free((void *)&feat[0][0][0]); ckd_free_2d((void **)feat); } } if ((o / vlen) != n_sv_frame) { E_WARN("Expected %u frames, but read %u\n", n_sv_frame, o / vlen); } E_INFO("done reading %u frames\n", n_sv_frame); return n_sv_frame; }
int main(int argc, char *argv[]) { lexicon_t *lex; model_def_t *omdef; model_def_t *dmdef; uint32 n_stream; const uint32 *veclen; uint32 ts_off; uint32 ts_cnt; FILE *fp; timing_t *all_timer= NULL; timing_t *km_timer= NULL; timing_t *var_timer= NULL; timing_t *em_timer= NULL; if (main_initialize(argc, argv, &lex, &omdef, &dmdef) != S3_SUCCESS) { return -1; } km_timer = timing_get("km"); var_timer = timing_get("var"); em_timer = timing_get("em"); all_timer = timing_get("all"); n_stream = feat_n_stream(); veclen = feat_vecsize(); if (strcmp((const char *)cmd_ln_access("-gthobj"), "state") == 0) { ts_off = *(uint32 *)cmd_ln_access("-tsoff"); if (cmd_ln_access("-tscnt") == NULL) { ts_cnt = omdef->n_tied_state - ts_off; } else { ts_cnt = *(uint32 *)cmd_ln_access("-tscnt"); } if (ts_off + ts_cnt > omdef->n_tied_state) { E_FATAL("Too many tied states specified\n"); } n_tot_frame = 0; if (all_timer) timing_reset(all_timer); if (km_timer) timing_reset(km_timer); if (var_timer) timing_reset(var_timer); if (em_timer) timing_reset(em_timer); if (all_timer) timing_start(all_timer); if (init_state((const char *)cmd_ln_access("-segdmpfn"), (const char *)cmd_ln_access("-segidxfn"), *(int32 *)cmd_ln_access("-ndensity"), n_stream, veclen, *(int32 *)cmd_ln_access("-reest"), (const char *)cmd_ln_access("-mixwfn"), (const char *)cmd_ln_access("-meanfn"), (const char *)cmd_ln_access("-varfn"), ts_off, ts_cnt, omdef->n_tied_state, (dmdef != NULL ? dmdef->n_tied_state : omdef->n_tied_state)) != S3_SUCCESS) { E_ERROR("Unable to train [%u %u]\n", ts_off, ts_off+ts_cnt-1); } if (all_timer) timing_stop(all_timer); if (n_tot_frame > 0) { E_INFO("TOTALS:"); if (km_timer) { E_INFOCONT(" km %4.3fx %4.3e", km_timer->t_cpu / (n_tot_frame * 0.01), (km_timer->t_cpu > 0 ? km_timer->t_elapsed / km_timer->t_cpu : 0.0)); } if (var_timer) { E_INFOCONT(" var %4.3fx %4.3e", var_timer->t_cpu / (n_tot_frame * 0.01), (var_timer->t_cpu > 0 ? var_timer->t_elapsed / var_timer->t_cpu : 0.0)); } if (em_timer) { E_INFOCONT(" em %4.3fx %4.3e", em_timer->t_cpu / (n_tot_frame * 0.01), (em_timer->t_cpu > 0 ? em_timer->t_elapsed / em_timer->t_cpu : 0.0)); } if (all_timer) { E_INFOCONT(" all %4.3fx %4.3e", all_timer->t_cpu / (n_tot_frame * 0.01), (all_timer->t_cpu > 0 ? all_timer->t_elapsed / all_timer->t_cpu : 0.0)); } E_INFOCONT("\n"); } if (cmd_ln_access("-tsrngfn") != NULL) { fp = fopen((const char *)cmd_ln_access("-tsrngfn"), "w"); if (fp == NULL) { E_FATAL_SYSTEM("Unable to open %s for reading", (const char *)cmd_ln_access("-tsrngfn")); } fprintf(fp, "%d %d\n", ts_off, ts_cnt); } else if (ts_cnt != omdef->n_tied_state) { E_WARN("Subset of tied states specified, but no -tsrngfn arg"); } } else if (strcmp((const char *)cmd_ln_access("-gthobj"), "single") == 0) { n_tot_frame = 0; if (all_timer) timing_reset(all_timer); if (km_timer) timing_reset(km_timer); if (var_timer) timing_reset(var_timer); if (em_timer) timing_reset(em_timer); if (all_timer) timing_start(all_timer); if (init_state((const char *)cmd_ln_access("-segdmpfn"), NULL, /* No index -> single class dump file */ *(int32 *)cmd_ln_access("-ndensity"), n_stream, veclen, *(int32 *)cmd_ln_access("-reest"), (const char *)cmd_ln_access("-mixwfn"), (const char *)cmd_ln_access("-meanfn"), (const char *)cmd_ln_access("-varfn"), 0, 1, 1, 1) != S3_SUCCESS) { E_ERROR("Unable to train\n"); } if (all_timer) timing_stop(all_timer); if (n_tot_frame > 0) { E_INFO("TOTALS:"); if (km_timer) { E_INFOCONT(" km %4.3fx %4.3e", km_timer->t_cpu / (n_tot_frame * 0.01), (km_timer->t_cpu > 0 ? km_timer->t_elapsed / km_timer->t_cpu : 0.0)); } if (var_timer) { E_INFOCONT(" var %4.3fx %4.3e", var_timer->t_cpu / (n_tot_frame * 0.01), (var_timer->t_cpu > 0 ? var_timer->t_elapsed / var_timer->t_cpu : 0.0)); } if (em_timer) { E_INFOCONT(" em %4.3fx %4.3e", em_timer->t_cpu / (n_tot_frame * 0.01), (em_timer->t_cpu > 0 ? em_timer->t_elapsed / em_timer->t_cpu : 0.0)); } if (all_timer) { E_INFOCONT(" all %4.3fx %4.3e", all_timer->t_cpu / (n_tot_frame * 0.01), (all_timer->t_cpu > 0 ? all_timer->t_elapsed / all_timer->t_cpu : 0.0)); } E_INFOCONT("\n"); } } return 0; }
cmd_ln_t * cmd_ln_parse_r(cmd_ln_t *inout_cmdln, const arg_t * defn, int32 argc, char *argv[], int strict) { int32 i, j, n, argstart; hash_table_t *defidx = NULL; cmd_ln_t *cmdln; /* Construct command-line object */ if (inout_cmdln == NULL) { cmdln = ckd_calloc(1, sizeof(*cmdln)); cmdln->refcount = 1; } else cmdln = inout_cmdln; /* Build a hash table for argument definitions */ defidx = hash_table_new(50, 0); if (defn) { for (n = 0; defn[n].name; n++) { void *v; v = hash_table_enter(defidx, defn[n].name, (void *)&defn[n]); if (strict && (v != &defn[n])) { E_ERROR("Duplicate argument name in definition: %s\n", defn[n].name); goto error; } } } else { /* No definitions. */ n = 0; } /* Allocate memory for argument values */ if (cmdln->ht == NULL) cmdln->ht = hash_table_new(n, 0 /* argument names are case-sensitive */ ); /* skip argv[0] if it doesn't start with dash */ argstart = 0; if (argc > 0 && argv[0][0] != '-') { argstart = 1; } /* Parse command line arguments (name-value pairs) */ for (j = argstart; j < argc; j += 2) { arg_t *argdef; cmd_ln_val_t *val; void *v; if (hash_table_lookup(defidx, argv[j], &v) < 0) { if (strict) { E_ERROR("Unknown argument name '%s'\n", argv[j]); goto error; } else if (defn == NULL) v = NULL; else continue; } argdef = v; /* Enter argument value */ if (j + 1 >= argc) { cmd_ln_print_help_r(cmdln, stderr, defn); E_ERROR("Argument value for '%s' missing\n", argv[j]); goto error; } if (argdef == NULL) val = cmd_ln_val_init(ARG_STRING, argv[j + 1]); else { if ((val = cmd_ln_val_init(argdef->type, argv[j + 1])) == NULL) { cmd_ln_print_help_r(cmdln, stderr, defn); E_ERROR("Bad argument value for %s: %s\n", argv[j], argv[j + 1]); goto error; } } #import "OpenEarsStaticAnalysisToggle.h" #ifdef STATICANALYZEDEPENDENCIES #define __clang_analyzer__ 1 #endif #if !defined(__clang_analyzer__) || defined(STATICANALYZEDEPENDENCIES) #undef __clang_analyzer__ if ((v = hash_table_enter(cmdln->ht, argv[j], (void *)val)) != (void *)val) { if (strict) { cmd_ln_val_free(val); E_ERROR("Duplicate argument name in arguments: %s\n", argdef->name); goto error; } else { v = hash_table_replace(cmdln->ht, argv[j], (void *)val); cmd_ln_val_free((cmd_ln_val_t *)v); } } } #endif /* Fill in default values, if any, for unspecified arguments */ for (i = 0; i < n; i++) { cmd_ln_val_t *val; void *v; if (hash_table_lookup(cmdln->ht, defn[i].name, &v) < 0) { if ((val = cmd_ln_val_init(defn[i].type, defn[i].deflt)) == NULL) { E_ERROR ("Bad default argument value for %s: %s\n", defn[i].name, defn[i].deflt); goto error; } hash_table_enter(cmdln->ht, defn[i].name, (void *)val); } } /* Check for required arguments; exit if any missing */ j = 0; for (i = 0; i < n; i++) { if (defn[i].type & ARG_REQUIRED) { void *v; if (hash_table_lookup(cmdln->ht, defn[i].name, &v) != 0) E_ERROR("Missing required argument %s\n", defn[i].name); } } if (j > 0) { cmd_ln_print_help_r(cmdln, stderr, defn); goto error; } if (strict && argc == 1) { E_ERROR("No arguments given, available options are:\n"); cmd_ln_print_help_r(cmdln, stderr, defn); if (defidx) hash_table_free(defidx); if (inout_cmdln == NULL) cmd_ln_free_r(cmdln); return NULL; } #ifndef _WIN32_WCE if(verbose_cmuclmtk == 1 || verbose_pocketsphinx == 1) { /* Set up logging. We need to do this earlier because we want to dump * the information to the configured log, not to the stderr. */ if (cmd_ln_exists_r(cmdln, "-logfn") && cmd_ln_str_r(cmdln, "-logfn")) err_set_logfile(cmd_ln_str_r(cmdln, "-logfn")); /* Echo command line */ E_INFO("Parsing command line:\n"); for (i = 0; i < argc; i++) { if (argv[i][0] == '-') E_INFOCONT("\\\n\t"); E_INFOCONT("%s ", argv[i]); } E_INFOCONT("\n\n"); fflush(stderr); /* Print configuration */ E_INFOCONT("Current configuration:\n"); arg_dump_r(cmdln, err_get_logfp(), defn, 0); } #endif hash_table_free(defidx); return cmdln; error: if (defidx) hash_table_free(defidx); if (inout_cmdln == NULL) cmd_ln_free_r(cmdln); E_ERROR("Failed to parse arguments list\n"); return NULL; }
int agg_phn_seg(lexicon_t *lex, acmod_set_t *acmod_set, feat_t *fcb, segdmp_type_t type) { uint16 *seg; vector_t *mfcc; vector_t **feat; int32 n_frame; uint32 tick_cnt; acmod_id_t *phone; uint32 *start; uint32 *len; uint32 n_phone; uint32 s; char *btw_mark; char *trans; char **word; uint32 n_word; int32 mfc_veclen = cmd_ln_int32("-ceplen"); uint32 n_stream; uint32 *veclen; tick_cnt = 0; n_stream = feat_dimension1(fcb); veclen = feat_stream_lengths(fcb); while (corpus_next_utt()) { if ((++tick_cnt % 500) == 0) { E_INFOCONT("[%u] ", tick_cnt); } if (corpus_get_sent(&trans) != S3_SUCCESS) { E_FATAL("Unable to read word transcript for %s\n", corpus_utt_brief_name()); } if (corpus_get_seg(&seg, &n_frame) != S3_SUCCESS) { E_FATAL("Unable to read Viterbi state segmentation for %s\n", corpus_utt_brief_name()); } n_word = str2words(trans, NULL, 0); word = ckd_calloc(n_word, sizeof(char*)); str2words(trans, word, n_word); phone = mk_phone_list(&btw_mark, &n_phone, word, n_word, lex); start = ckd_calloc(n_phone, sizeof(uint32)); len = ckd_calloc(n_phone, sizeof(uint32)); /* check to see whether the word transcript and dictionary entries agree with the state segmentation */ if (ck_seg(acmod_set, phone, n_phone, seg, n_frame, corpus_utt()) != S3_SUCCESS) { free(trans); /* alloc'ed using strdup, not ckd_*() */ free(seg); /* alloc'ed using malloc in areadshort(), not ckd_*() */ ckd_free(word); ckd_free(phone); E_ERROR("ck_seg failed"); continue; } if (cvt2triphone(acmod_set, phone, btw_mark, n_phone) != S3_SUCCESS) { free(trans); /* alloc'ed using strdup, not ckd_*() */ free(seg); /* alloc'ed using malloc in areadshort(), not ckd_*() */ ckd_free(word); ckd_free(phone); E_ERROR("cvt2triphone failed"); continue; } ckd_free(btw_mark); if (mk_seg(acmod_set, seg, n_frame, phone, start, len, n_phone) != S3_SUCCESS) { free(trans); free(seg); ckd_free(word); ckd_free(phone); E_ERROR("mk_seg failed"); continue; } if (corpus_provides_mfcc()) { if (corpus_get_generic_featurevec(&mfcc, &n_frame, mfc_veclen) < 0) { E_FATAL("Can't read input features from %s\n", corpus_utt()); } if (n_frame < 9) { E_WARN("utt %s too short\n", corpus_utt()); if (mfcc) { ckd_free(mfcc[0]); ckd_free(mfcc); mfcc = NULL; } continue; } feat = feat_array_alloc(fcb, n_frame + feat_window_size(fcb)); feat_s2mfc2feat_live(fcb, mfcc, &n_frame, TRUE, TRUE, feat); for (s = 0; s < n_phone; s++) { segdmp_add_feat(phone[s], &feat[start[s]], len[s]); } feat_array_free(feat); free(&mfcc[0][0]); ckd_free(mfcc); } else { E_FATAL("No data type specified\n"); } free(trans); /* alloc'ed using strdup, not ckd_*() */ free(seg); /* alloc'ed using malloc in areadshort(), not ckd_*() */ ckd_free(word); ckd_free(phone); ckd_free(start); ckd_free(len); } return 0; }
int main(int argc, char *argv[]) { lexicon_t *lex; model_def_t *omdef; model_def_t *dmdef; feat_t *feat; uint32 n_stream, blksize; uint32 *veclen; uint32 ts_off; uint32 ts_cnt; FILE *fp; if (main_initialize(argc, argv, &lex, &omdef, &dmdef, &feat) != S3_SUCCESS) { return -1; } n_stream = feat_dimension1(feat); veclen = feat_stream_lengths(feat); blksize = feat_dimension(feat); if (strcmp(cmd_ln_str("-gthobj"), "state") == 0) { ts_off = cmd_ln_int32("-tsoff"); if (cmd_ln_str("-tscnt") == NULL) { ts_cnt = omdef->n_tied_state - ts_off; } else { ts_cnt = cmd_ln_int32("-tscnt"); } if (ts_off + ts_cnt > omdef->n_tied_state) { E_FATAL("Too many tied states specified\n"); } n_tot_frame = 0; ptmr_reset(&all_timer); ptmr_reset(&km_timer); ptmr_reset(&var_timer); ptmr_reset(&em_timer); ptmr_start(&all_timer); if (init_state(cmd_ln_str("-segdmpfn"), cmd_ln_str("-segidxfn"), cmd_ln_int32("-ndensity"), n_stream, veclen, blksize, cmd_ln_int32("-reest"), cmd_ln_str("-mixwfn"), cmd_ln_str("-meanfn"), cmd_ln_str("-varfn"), ts_off, ts_cnt, omdef->n_tied_state, (dmdef != NULL ? dmdef->n_tied_state : omdef->n_tied_state)) != S3_SUCCESS) { E_ERROR("Unable to train [%u %u]\n", ts_off, ts_off+ts_cnt-1); } ptmr_stop(&all_timer); if (n_tot_frame > 0) { E_INFO("TOTALS:"); E_INFOCONT(" km %4.3fx %4.3e", km_timer.t_cpu / (n_tot_frame * 0.01), (km_timer.t_cpu > 0 ? km_timer.t_elapsed / km_timer.t_cpu : 0.0)); E_INFOCONT(" var %4.3fx %4.3e", var_timer.t_cpu / (n_tot_frame * 0.01), (var_timer.t_cpu > 0 ? var_timer.t_elapsed / var_timer.t_cpu : 0.0)); E_INFOCONT(" em %4.3fx %4.3e", em_timer.t_cpu / (n_tot_frame * 0.01), (em_timer.t_cpu > 0 ? em_timer.t_elapsed / em_timer.t_cpu : 0.0)); E_INFOCONT(" all %4.3fx %4.3e", all_timer.t_cpu / (n_tot_frame * 0.01), (all_timer.t_cpu > 0 ? all_timer.t_elapsed / all_timer.t_cpu : 0.0)); E_INFOCONT("\n"); } if (cmd_ln_str("-tsrngfn") != NULL) { fp = fopen(cmd_ln_str("-tsrngfn"), "w"); if (fp == NULL) { E_FATAL_SYSTEM("Unable to open %s for reading", cmd_ln_str("-tsrngfn")); } fprintf(fp, "%d %d\n", ts_off, ts_cnt); } else if (ts_cnt != omdef->n_tied_state) { E_WARN("Subset of tied states specified, but no -tsrngfn arg"); } } else if (strcmp(cmd_ln_str("-gthobj"), "single") == 0) { n_tot_frame = 0; ptmr_reset(&all_timer); ptmr_reset(&km_timer); ptmr_reset(&var_timer); ptmr_reset(&em_timer); ptmr_start(&all_timer); if (init_state(cmd_ln_str("-segdmpfn"), NULL, /* No index -> single class dump file */ cmd_ln_int32("-ndensity"), n_stream, veclen, blksize, cmd_ln_int32("-reest"), cmd_ln_str("-mixwfn"), cmd_ln_str("-meanfn"), cmd_ln_str("-varfn"), 0, 1, 1, 1) != S3_SUCCESS) { E_ERROR("Unable to train\n"); } ptmr_stop(&all_timer); if (n_tot_frame > 0) { E_INFO("TOTALS:"); E_INFOCONT(" km %4.3fx %4.3e", km_timer.t_cpu / (n_tot_frame * 0.01), (km_timer.t_cpu > 0 ? km_timer.t_elapsed / km_timer.t_cpu : 0.0)); E_INFOCONT(" var %4.3fx %4.3e", var_timer.t_cpu / (n_tot_frame * 0.01), (var_timer.t_cpu > 0 ? var_timer.t_elapsed / var_timer.t_cpu : 0.0)); E_INFOCONT(" em %4.3fx %4.3e", em_timer.t_cpu / (n_tot_frame * 0.01), (em_timer.t_cpu > 0 ? em_timer.t_elapsed / em_timer.t_cpu : 0.0)); E_INFOCONT(" all %4.3fx %4.3e", all_timer.t_cpu / (n_tot_frame * 0.01), (all_timer.t_cpu > 0 ? all_timer.t_elapsed / all_timer.t_cpu : 0.0)); E_INFOCONT("\n"); } } return 0; }
subvq_t * subvq_init(const char *file, float64 varfloor, int32 max_sv, mgau_model_t * g, cmd_ln_t *config, logmath_t * logmath) { FILE *fp; char line[16384]; int32 n_sv; /* #Subvectors in file, as opposed to that used */ int32 s, k, l, n, r, c; char *strp; subvq_t *vq; E_INFO("Loading Mixture Gaussian sub-VQ file '%s' (vq_eval: %d)\n", file, cmd_ln_int32_r(config, "-vqeval")); if ((fp = fopen(file, "r")) == NULL) { E_ERROR_SYSTEM("Failed to open subvq file"); return NULL; } vq = (subvq_t *) ckd_calloc(1, sizeof(subvq_t)); vq->VQ_EVAL = cmd_ln_int32_r(config, "-vqeval"); /*Arthur : It nows work for arbitrary size of sub-vector */ /* Read until "Sub-vectors" */ for (;;) { if (fgets(line, sizeof(line), fp) == NULL) E_FATAL("Failed to read VQParam header\n"); if (sscanf(line, "VQParam %d %d -> %d %d", &(vq->origsize.r), &(vq->origsize.c), &(vq->n_sv), &(vq->vqsize)) == 4) break; } if (g) { if ((g->n_mgau != vq->origsize.r) || (g->max_comp != vq->origsize.c)) E_FATAL ("Model size conflict: %d x %d (SubVQ) vs %d x %d (Original)\n", vq->origsize.r, vq->origsize.c, g->n_mgau, g->max_comp); } if (max_sv < 0) max_sv = vq->n_sv; if (max_sv < vq->n_sv) E_INFO("Using %d subvectors out of %d\n", max_sv, vq->n_sv); else if (max_sv > vq->n_sv) { E_WARN("#Subvectors specified(%d) > available(%d); using latter\n", max_sv, vq->n_sv); max_sv = vq->n_sv; } n_sv = vq->n_sv; vq->n_sv = max_sv; if (vq->n_sv < vq->VQ_EVAL) /* RAH, 5.9.01, sanity check to make sure VQ_EVAL isn't higher than the n_sv */ vq->VQ_EVAL = vq->n_sv; vq->featdim = (int32 **) ckd_calloc(vq->n_sv, sizeof(int32 *)); vq->gautbl = (vector_gautbl_t *) ckd_calloc(vq->n_sv, sizeof(vector_gautbl_t)); vq->map = (int32 ***) ckd_calloc_3d(vq->origsize.r, vq->origsize.c, vq->n_sv, sizeof(int32)); /* Read subvector sizes and feature dimension maps */ for (s = 0; s < n_sv; s++) { if ((fgets(line, sizeof(line), fp) == NULL) || (sscanf(line, "Subvector %d length %d%n", &k, &l, &n) != 2) || (k != s)) E_FATAL("Error reading length(subvector %d)\n", s); if (s < vq->n_sv) { vq->gautbl[s].veclen = l; vq->featdim[s] = (int32 *) ckd_calloc(vq->gautbl[s].veclen, sizeof(int32)); for (strp = line + n, c = 0; c < vq->gautbl[s].veclen; c++) { if (sscanf(strp, "%d%n", &(vq->featdim[s][c]), &n) != 1) E_FATAL("Error reading subvector(%d).featdim(%d)\n", s, c); strp += n; } vector_gautbl_alloc(&(vq->gautbl[s]), vq->vqsize, vq->gautbl[s].veclen, logmath); } } /* Echo info for sanity check */ E_INFO("Original #codebooks(states)/codewords: %d x %d\n", vq->origsize.r, vq->origsize.c); E_INFO("Subvectors: %d, VQsize: %d\n", vq->n_sv, vq->vqsize); for (s = 0; s < vq->n_sv; s++) { E_INFO("SV %d feature dims(%d): ", s, vq->gautbl[s].veclen); for (c = 0; c < vq->gautbl[s].veclen; c++) E_INFOCONT(" %2d", vq->featdim[s][c]); E_INFOCONT("\n"); } /* Read VQ codebooks and maps for each subvector */ for (s = 0; s < n_sv; s++) { E_INFO("Reading subvq %d%s\n", s, (s < vq->n_sv) ? "" : " (not used)"); E_INFO("Reading codebook\n"); if ((fgets(line, sizeof(line), fp) == NULL) || (sscanf(line, "Codebook %d", &k) != 1) || (k != s)) E_FATAL("Error reading codebook header\n", s); for (r = 0; r < vq->vqsize; r++) { if (fgets(line, sizeof(line), fp) == NULL) E_FATAL("Error reading row(%d)\n", r); if (s >= vq->n_sv) continue; for (strp = line, c = 0; c < vq->gautbl[s].veclen; c++) { if (sscanf(strp, "%f %f%n", &(vq->gautbl[s].mean[r][c]), &(vq->gautbl[s].var[r][c]), &k) != 2) E_FATAL("Error reading row(%d) col(%d)\n", r, c); strp += k; } } E_INFO("Reading map\n"); if ((fgets(line, sizeof(line), fp) == NULL) || (sscanf(line, "Map %d", &k) != 1) || (k != s)) E_FATAL("Error reading map header\n", s); for (r = 0; r < vq->origsize.r; r++) { if (fgets(line, sizeof(line), fp) == NULL) E_FATAL("Error reading row(%d)\n", r); if (s >= vq->n_sv) continue; for (strp = line, c = 0; c < vq->origsize.c; c++) { if (sscanf(strp, "%d%n", &(vq->map[r][c][s]), &k) != 1) E_FATAL("Error reading row(%d) col(%d)\n", r, c); strp += k; } } fflush(stdout); } if ((fscanf(fp, "%s", line) != 1) || (strcmp(line, "End") != 0)) E_FATAL("Error reading 'End' token\n"); fclose(fp); subvq_maha_precomp(vq, varfloor); subvq_map_compact(vq, g); subvq_map_linearize(vq); n = 0; for (s = 0; s < n_sv; s++) { if (vq->gautbl[s].veclen > n) n = vq->gautbl[s].veclen; } assert(n > 0); vq->subvec = (float32 *) ckd_calloc(n, sizeof(float32)); vq->vqdist = (int32 **) ckd_calloc_2d(vq->n_sv, vq->vqsize, sizeof(int32)); vq->gauscore = (int32 *) ckd_calloc(vq->origsize.c, sizeof(int32)); vq->mgau_sl = (int32 *) ckd_calloc(vq->origsize.c + 1, sizeof(int32)); return vq; }
void cmn(cmn_t *cmn, mfcc_t ** mfc, int32 varnorm, int32 n_frame) { mfcc_t *mfcp; mfcc_t t; int32 i, f; oe_assert(mfc != NULL); if (n_frame <= 0) return; /* If cmn->cmn_mean wasn't NULL, we need to zero the contents */ memset(cmn->cmn_mean, 0, cmn->veclen * sizeof(mfcc_t)); /* Find mean cep vector for this utterance */ for (f = 0; f < n_frame; f++) { mfcp = mfc[f]; for (i = 0; i < cmn->veclen; i++) { cmn->cmn_mean[i] += mfcp[i]; } } for (i = 0; i < cmn->veclen; i++) cmn->cmn_mean[i] /= n_frame; E_INFO("CMN: "); for (i = 0; i < cmn->veclen; i++) E_INFOCONT("%5.2f ", MFCC2FLOAT(cmn->cmn_mean[i])); E_INFOCONT("\n"); if (!varnorm) { /* Subtract mean from each cep vector */ for (f = 0; f < n_frame; f++) { mfcp = mfc[f]; for (i = 0; i < cmn->veclen; i++) mfcp[i] -= cmn->cmn_mean[i]; } } else { /* Scale cep vectors to have unit variance along each dimension, and subtract means */ /* If cmn->cmn_var wasn't NULL, we need to zero the contents */ memset(cmn->cmn_var, 0, cmn->veclen * sizeof(mfcc_t)); for (f = 0; f < n_frame; f++) { mfcp = mfc[f]; for (i = 0; i < cmn->veclen; i++) { t = mfcp[i] - cmn->cmn_mean[i]; cmn->cmn_var[i] += MFCCMUL(t, t); } } for (i = 0; i < cmn->veclen; i++) /* Inverse Std. Dev, RAH added type case from sqrt */ cmn->cmn_var[i] = FLOAT2MFCC(sqrt((float64)n_frame / MFCC2FLOAT(cmn->cmn_var[i]))); for (f = 0; f < n_frame; f++) { mfcp = mfc[f]; for (i = 0; i < cmn->veclen; i++) mfcp[i] = MFCCMUL((mfcp[i] - cmn->cmn_mean[i]), cmn->cmn_var[i]); } } }
int cnt_phn_seg(model_def_t *mdef, lexicon_t *lex, uint32 **out_n_seg, uint32 ***out_n_frame_per) { uint32 seq_no = 0; uint16 *seg; int32 n_frame; uint32 i, j; uint32 n_acmod; uint32 *phone; uint32 n_phone; uint32 *n_seg; uint32 **n_frame_per; uint32 *start; uint32 *len; seg_len_t *cur; seg_len_t *tmp; seg_len_t *phn_hd; seg_len_t *phn_tl; n_acmod = acmod_set_n_acmod(mdef->acmod_set); E_INFO("Counting # occ. for %u models\n", n_acmod); n_seg = ckd_calloc(n_acmod, sizeof(uint32)); hd = ckd_calloc(n_acmod, sizeof(seg_len_t *)); tl = ckd_calloc(n_acmod, sizeof(seg_len_t *)); for (seq_no = corpus_get_begin(); corpus_next_utt(); seq_no++) { if (!(seq_no % 250)) { E_INFOCONT(" cnt[%u]", seq_no); } corpus_get_seg(&seg, &n_frame); phone = get_next_phnseq(mdef, lex, &n_phone); ck_seg(mdef->acmod_set, phone, n_phone, seg, n_frame, corpus_utt()); start = ckd_calloc(n_phone, sizeof(uint32)); len = ckd_calloc(n_phone, sizeof(uint32)); mk_seg(mdef->acmod_set, seg, n_frame, phone, start, len, n_phone); ckd_free(start); ckd_free(seg); ckd_free(phone); for (i = 0; i < n_phone; i++) { /* insert the len for list phone[i] */ phn_hd = hd[phone[i]]; phn_tl = tl[phone[i]]; cur = (seg_len_t *)ckd_calloc(1, sizeof(seg_len_t)); cur->len = len[i]; if (phn_tl == NULL) { hd[phone[i]] = tl[phone[i]] = cur; } else { phn_tl->nxt = cur; tl[phone[i]] = cur; } } ckd_free(len); } n_frame_per = (uint32 **)ckd_calloc(n_acmod, sizeof(uint32 *)); for (i = 0; i < n_acmod; i++) { if (hd[i] == NULL) { n_seg[i] = 0; } else { for (cur = hd[i], j = 0; cur != NULL; j++, cur = cur->nxt); n_seg[i] = j; n_frame_per[i] = (uint32 *)ckd_calloc(n_seg[i], sizeof(uint32)); for (cur = hd[i], j = 0; cur != NULL; j++, cur = cur->nxt) n_frame_per[i][j] = cur->len; for (cur = hd[i]; cur != NULL; cur = tmp) { tmp = cur->nxt; ckd_free(cur); } E_INFO("phn= %s n_seg= %u\n", acmod_set_id2name(mdef->acmod_set, i), n_seg[i]); } } ckd_free(hd); ckd_free(tl); *out_n_seg = n_seg; *out_n_frame_per = n_frame_per; return S3_SUCCESS; }
s2_semi_mgau_t * s2_semi_mgau_init(cmd_ln_t *config, logmath_t *lmath, feat_t *fcb, mdef_t *mdef) { s2_semi_mgau_t *s; char const *sendump_path; float32 **fgau; int i; s = ckd_calloc(1, sizeof(*s)); s->config = config; s->lmath = logmath_retain(lmath); /* Log-add table. */ s->lmath_8b = logmath_init(logmath_get_base(lmath), SENSCR_SHIFT, TRUE); if (s->lmath_8b == NULL) { s2_semi_mgau_free(s); return NULL; } /* Ensure that it is only 8 bits wide so that fast_logmath_add() works. */ if (logmath_get_width(s->lmath_8b) != 1) { E_ERROR("Log base %f is too small to represent add table in 8 bits\n", logmath_get_base(s->lmath_8b)); s2_semi_mgau_free(s); return NULL; } /* Inherit stream dimensions from acmod, will be checked below. */ s->n_feat = feat_dimension1(fcb); s->veclen = ckd_calloc(s->n_feat, sizeof(int32)); for (i = 0; i < s->n_feat; ++i) s->veclen[i] = feat_dimension2(fcb, i); /* Read means and variances. */ if (s3_read_mgau(s, cmd_ln_str_r(s->config, "-mean"), &fgau) < 0) { s2_semi_mgau_free(s); return NULL; } s->means = (mfcc_t **)fgau; if (s3_read_mgau(s, cmd_ln_str_r(s->config, "-var"), &fgau) < 0) { s2_semi_mgau_free(s); return NULL; } s->vars = (mfcc_t **)fgau; /* Precompute (and fixed-point-ize) means, variances, and determinants. */ s->dets = (mfcc_t **)ckd_calloc_2d(s->n_feat, s->n_density, sizeof(**s->dets)); s3_precomp(s, s->lmath, cmd_ln_float32_r(s->config, "-varfloor")); /* Read mixture weights */ if ((sendump_path = cmd_ln_str_r(s->config, "-sendump"))) read_sendump(s, mdef, sendump_path); else read_mixw(s, cmd_ln_str_r(s->config, "-mixw"), cmd_ln_float32_r(s->config, "-mixwfloor")); s->ds_ratio = cmd_ln_int32_r(s->config, "-ds"); /* Determine top-N for each feature */ s->topn_beam = ckd_calloc(s->n_feat, sizeof(*s->topn_beam)); s->max_topn = cmd_ln_int32_r(s->config, "-topn"); split_topn(cmd_ln_str_r(s->config, "-topn_beam"), s->topn_beam, s->n_feat); E_INFO("Maximum top-N: %d ", s->max_topn); E_INFOCONT("Top-N beams:"); for (i = 0; i < s->n_feat; ++i) { E_INFOCONT(" %d", s->topn_beam[i]); } E_INFOCONT("\n"); /* Top-N scores from recent frames */ s->n_topn_hist = cmd_ln_int32_r(s->config, "-pl_window") + 2; s->topn_hist = (vqFeature_t ***) ckd_calloc_3d(s->n_topn_hist, s->n_feat, s->max_topn, sizeof(***s->topn_hist)); s->topn_hist_n = ckd_calloc_2d(s->n_topn_hist, s->n_feat, sizeof(**s->topn_hist_n)); for (i = 0; i < s->n_topn_hist; ++i) { int j; for (j = 0; j < s->n_feat; ++j) { int k; for (k = 0; k < s->max_topn; ++k) { s->topn_hist[i][j][k].score = WORST_DIST; s->topn_hist[i][j][k].codeword = k; } } } return s; }