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;
}
