int wr_tmat(const char *fn) { if (s3tmat_write(fn, otmat, n_tmat_o, n_state_pm) != S3_SUCCESS) return S3_ERROR; ckd_free_3d((void ***)otmat); ckd_free_3d((void ***)itmat); return S3_SUCCESS; }
int main(int argc, char *argv[]) { model_def_t *mdef; uint32 n_tmat; uint32 n_tied_state; uint32 n_state_pm; uint32 n_stream; uint32 n_density; float32 ***tmat; float32 **proto_tmat; float32 ***mixw; uint32 i, j, k; float32 mixw_ini; int retval = 0; parse_cmd_ln(argc, argv); printf("%s(%d): Reading model definition file %s\n", __FILE__, __LINE__, cmd_ln_str("-moddeffn")); if (model_def_read(&mdef, cmd_ln_str("-moddeffn")) != S3_SUCCESS) { return 1; } printf("%s(%d): %d models defined\n", __FILE__, __LINE__, mdef->n_defn); if (!cmd_ln_str("-tmatfn") && ! cmd_ln_str("-mixwfn")){ E_FATAL("Both -tmatfn and -mixwfn were not specified, forced exit\n"); } if (cmd_ln_str("-tmatfn")) { if (topo_read(&proto_tmat, &n_state_pm, cmd_ln_str("-topo")) != S3_SUCCESS) return 1; /* proto_tmat is normalized */ n_tmat = mdef->n_tied_tmat; tmat = (float32 ***)ckd_calloc_3d(n_tmat, n_state_pm-1, n_state_pm, sizeof(float32)); for (k = 0; k < n_tmat; k++) { for (i = 0; i < n_state_pm-1; i++) { for (j = 0; j < n_state_pm; j++) { /* perhaps this could be replaced with a block copy per tmat */ tmat[k][i][j] = proto_tmat[i][j]; } } } if (s3tmat_write(cmd_ln_str("-tmatfn"), tmat, n_tmat, n_state_pm) != S3_SUCCESS) { retval = 1; } ckd_free_3d((void ***)tmat); } else { E_INFO("No tmat file given; none generated\n"); } n_tied_state = mdef->n_tied_state; n_stream = cmd_ln_int32("-nstream"); n_density = cmd_ln_int32("-ndensity"); mixw = (float32 ***)ckd_calloc_3d(n_tied_state, n_stream, n_density, sizeof(float32)); /* weight each density uniformly */ mixw_ini = 1.0 / (float)n_density; for (i = 0; i < n_tied_state; i++) { for (j = 0; j < n_stream; j++) { for (k = 0; k < n_density; k++) { mixw[i][j][k] = mixw_ini; } } } if (cmd_ln_str("-mixwfn")) { if (s3mixw_write(cmd_ln_str("-mixwfn"), mixw, n_tied_state, n_stream, n_density) != S3_SUCCESS) { retval = 2; } } else { E_INFO("No mixw file given; none generated\n"); } ckd_free_3d((void ***)mixw); return retval; }
/********************************************************************* * * Function: * accum_dump * * Description: * This functions writes the reestimation numerators and * denominators to files. * * This routine may be called repeatedly until success to * try to cope with exceptional conditions like insufficient disk * space, etc. * * Function Inputs: * const char *out_dir - * model_inventory_t *inv - * int32 mixw_reest - * int32 tmat_reest - * int32 mean_reest - * int32 var_reest - * * Global Inputs: * None * * Return Values: * S3_SUCCESS - The values were written to files successfully. * S3_ERROR - The values were not completely written to files. * * Global Outputs: * None * * Errors: * *********************************************************************/ int32 accum_dump(const char *out_dir, model_inventory_t *inv, int32 mixw_reest, int32 tmat_reest, int32 mean_reest, int32 var_reest, int32 pass2var, int32 var_is_full, int ckpt) /* checkpoint dump flag */ { char fn[MAXPATHLEN+1]; gauden_t *g; /* run over the accumulators and report anything exceptional */ if (!ckpt) accum_stat(inv, mixw_reest); g = inv->gauden; mk_bkp(mixw_reest, tmat_reest, mean_reest, var_reest, out_dir); if (mixw_reest) { sprintf(fn, "%s/mixw_counts", out_dir); if (s3mixw_write(fn, inv->mixw_acc, inv->n_mixw, g->n_feat, g->n_density) != S3_SUCCESS) { revert_bkp(mixw_reest, tmat_reest, mean_reest, var_reest, out_dir); return S3_ERROR; } } else { if (!ckpt) E_INFO("Mixture weights not reestimated. " "No %s/mixw_counts produced.\n", out_dir); } if (tmat_reest) { sprintf(fn, "%s/tmat_counts", out_dir); if (s3tmat_write(fn, inv->tmat_acc, inv->n_tmat, inv->n_state_pm) != S3_SUCCESS) { revert_bkp(mixw_reest, tmat_reest, mean_reest, var_reest, out_dir); return S3_ERROR; } } else { if (!ckpt) E_INFO("Transition matrices not reestimated. " "No %s/tmat_counts produced.\n", out_dir); } if (mean_reest || var_reest) { int32 rv; sprintf(fn, "%s/gauden_counts", out_dir); if (var_is_full) rv = s3gaucnt_write_full(fn, (mean_reest ? g->macc : NULL), (var_reest ? g->fullvacc : NULL), pass2var, g->dnom, g->n_mgau, g->n_feat, g->n_density, g->veclen); else rv = s3gaucnt_write(fn, (mean_reest ? g->macc : NULL), (var_reest ? g->vacc : NULL), pass2var, g->dnom, g->n_mgau, g->n_feat, g->n_density, g->veclen); if (rv != S3_SUCCESS) { revert_bkp(mixw_reest, tmat_reest, mean_reest, var_reest, out_dir); return S3_ERROR; } } else { if (!ckpt) E_INFO("means and variances not reestimated. " "No %s/gauden_counts produced.\n", out_dir); } return commit(mixw_reest, tmat_reest, mean_reest, var_reest, ckpt, out_dir); }
static int normalize() { char file_name[MAXPATHLEN+1]; float32 ***mixw_acc = NULL; float32 ***in_mixw = NULL; float64 s; uint32 n_mixw; uint32 n_stream; uint32 n_mllr_class; uint32 n_density; float32 ***tmat_acc = NULL; uint32 n_tmat; uint32 n_state_pm; uint32 i, j, k; vector_t ***in_mean = NULL; vector_t ***wt_mean = NULL; vector_t ***in_var = NULL; vector_t ***wt_var = NULL; vector_t ****in_fullvar = NULL; vector_t ****wt_fullvar = NULL; int32 pass2var = FALSE; int32 var_is_full = FALSE; float32 ***dnom = NULL; uint32 n_mgau; uint32 n_gau_stream; uint32 n_gau_density; const uint32 *veclen = NULL; const char **accum_dir; const char *oaccum_dir; const char *in_mixw_fn; const char *out_mixw_fn; const char *out_tmat_fn; const char *in_mean_fn; const char *out_mean_fn; const char *in_var_fn; const char *out_var_fn; const char *out_dcount_fn; int err; uint32 mllr_mult; uint32 mllr_add; float32 *****regl = NULL; float32 ****regr = NULL; uint32 no_retries=0; accum_dir = cmd_ln_str_list("-accumdir"); oaccum_dir = cmd_ln_str("-oaccumdir"); out_mixw_fn = cmd_ln_str("-mixwfn"); out_tmat_fn = cmd_ln_str("-tmatfn"); out_mean_fn = cmd_ln_str("-meanfn"); out_var_fn = cmd_ln_str("-varfn"); in_mixw_fn = cmd_ln_str("-inmixwfn"); in_mean_fn = cmd_ln_str("-inmeanfn"); in_var_fn = cmd_ln_str("-invarfn"); out_dcount_fn = cmd_ln_str("-dcountfn"); var_is_full = cmd_ln_int32("-fullvar"); /* must be at least one accum dir */ assert(accum_dir[0] != NULL); if (out_mixw_fn == NULL) { E_INFO("No -mixwfn specified, will skip if any\n"); } if (out_tmat_fn == NULL) { E_INFO("No -tmatfn specified, will skip if any\n"); } if (out_mean_fn == NULL) { E_INFO("No -meanfn specified, will skip if any\n"); } if (out_var_fn == NULL) { E_INFO("No -varfn specified, will skip if any\n"); } if (in_mixw_fn != NULL) { E_INFO("Selecting unseen mixing weight parameters from %s\n", in_mixw_fn); } if (in_mean_fn != NULL) { E_INFO("Selecting unseen density mean parameters from %s\n", in_mean_fn); if (s3gau_read(in_mean_fn, &in_mean, &n_mgau, &n_gau_stream, &n_gau_density, &veclen) != S3_SUCCESS) { E_FATAL_SYSTEM("Couldn't read %s", in_mean_fn); } ckd_free((void *)veclen); veclen = NULL; } if (in_var_fn != NULL) { E_INFO("Selecting unseen density variance parameters from %s\n", in_var_fn); if (var_is_full) { if (s3gau_read_full(in_var_fn, &in_fullvar, &n_mgau, &n_gau_stream, &n_gau_density, &veclen) != S3_SUCCESS) { E_FATAL_SYSTEM("Couldn't read %s", in_var_fn); } } else { if (s3gau_read(in_var_fn, &in_var, &n_mgau, &n_gau_stream, &n_gau_density, &veclen) != S3_SUCCESS) { E_FATAL_SYSTEM("Couldn't read %s", in_var_fn); } } ckd_free((void *)veclen); veclen = NULL; } n_stream = 0; for (i = 0; accum_dir[i]; i++) { E_INFO("Reading and accumulating counts from %s\n", accum_dir[i]); if (out_mixw_fn) { rdacc_mixw(accum_dir[i], &mixw_acc, &n_mixw, &n_stream, &n_density); } if (out_tmat_fn) { rdacc_tmat(accum_dir[i], &tmat_acc, &n_tmat, &n_state_pm); } if (out_mean_fn || out_var_fn) { if (var_is_full) rdacc_den_full(accum_dir[i], &wt_mean, &wt_fullvar, &pass2var, &dnom, &n_mgau, &n_gau_stream, &n_gau_density, &veclen); else rdacc_den(accum_dir[i], &wt_mean, &wt_var, &pass2var, &dnom, &n_mgau, &n_gau_stream, &n_gau_density, &veclen); if (out_mixw_fn) { if (n_stream != n_gau_stream) { E_ERROR("mixw inconsistent w/ densities WRT # " "streams (%u != %u)\n", n_stream, n_gau_stream); } if (n_density != n_gau_density) { E_ERROR("mixw inconsistent w/ densities WRT # " "den/mix (%u != %u)\n", n_density, n_gau_density); } } else { n_stream = n_gau_stream; n_density = n_gau_density; } } } if (oaccum_dir && mixw_acc) { /* write the total mixing weight reest. accumulators */ err = 0; sprintf(file_name, "%s/mixw_counts", oaccum_dir); if (in_mixw_fn) { if (s3mixw_read(in_mixw_fn, &in_mixw, &i, &j, &k) != S3_SUCCESS) { E_FATAL_SYSTEM("Unable to read %s", in_mixw_fn); } if (i != n_mixw) { E_FATAL("# mixw in input mixw file != # mixw in output mixw file\n"); } if (j != n_stream) { E_FATAL("# stream in input mixw file != # stream in output mixw file\n"); } if (k != n_density) { E_FATAL("# density in input mixw file != # density in output mixw file\n"); } for (i = 0; i < n_mixw; i++) { for (j = 0; j < n_stream; j++) { for (k = 0, s = 0; k < n_density; k++) { s += mixw_acc[i][j][k]; } if ((s == 0) && in_mixw) { for (k = 0, s = 0; k < n_density; k++) { mixw_acc[i][j][k] = in_mixw[i][j][k]; } E_INFO("set mixw %u stream %u to input mixw value\n", i, j); } } } } do { /* Write out the accumulated reestimation sums */ if (s3mixw_write(file_name, mixw_acc, n_mixw, n_stream, n_density) != S3_SUCCESS) { if (err == 0) { E_ERROR("Unable to write %s; Retrying...\n", file_name); } ++err; sleep(3); no_retries++; if(no_retries>10){ E_FATAL("Failed to get the files after 10 retries(about 30 seconds).\n "); } } } while (err > 1); } if (pass2var) E_INFO("-2passvar yes\n"); if (oaccum_dir && (wt_mean || wt_var || wt_fullvar)) { /* write the total mixing Gau. den reest. accumulators */ err = 0; sprintf(file_name, "%s/gauden_counts", oaccum_dir); do { int32 rv; if (var_is_full) rv = s3gaucnt_write_full(file_name, wt_mean, wt_fullvar, pass2var, dnom, n_mgau, n_gau_stream, n_gau_density, veclen); else rv = s3gaucnt_write(file_name, wt_mean, wt_var, pass2var, dnom, n_mgau, n_gau_stream, n_gau_density, veclen); if (rv != S3_SUCCESS) { if (err == 0) { E_ERROR("Unable to write %s; Retrying...\n", file_name); } ++err; sleep(3); no_retries++; if(no_retries>10){ E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n "); } } } while (err > 1); } if (oaccum_dir && tmat_acc) { /* write the total transition matrix reest. accumulators */ err = 0; sprintf(file_name, "%s/tmat_counts", oaccum_dir); do { if (s3tmat_write(file_name, tmat_acc, n_tmat, n_state_pm) != S3_SUCCESS) { if (err == 0) { E_ERROR("Unable to write %s; Retrying...\n", file_name); } ++err; sleep(3); no_retries++; if(no_retries>10){ E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n "); } } } while (err > 1); } if (oaccum_dir && regr && regl) { /* write the total MLLR regression matrix accumulators */ err = 0; sprintf(file_name, "%s/regmat_counts", oaccum_dir); do { if (s3regmatcnt_write(file_name, regr, regl, n_mllr_class, n_stream, veclen, mllr_mult, mllr_add) != S3_SUCCESS) { if (err == 0) { E_ERROR("Unable to write %s; Retrying...\n", file_name); } ++err; sleep(3); no_retries++; if(no_retries>10){ E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n "); } } } while (err > 1); } if (wt_mean || wt_var || wt_fullvar) { if (out_mean_fn) { E_INFO("Normalizing mean for n_mgau= %u, n_stream= %u, n_density= %u\n", n_mgau, n_stream, n_density); gauden_norm_wt_mean(in_mean, wt_mean, dnom, n_mgau, n_stream, n_density, veclen); } else { if (wt_mean) { E_INFO("Ignoring means since -meanfn not specified\n"); } } if (out_var_fn) { if (var_is_full) { if (wt_fullvar) { E_INFO("Normalizing fullvar\n"); gauden_norm_wt_fullvar(in_fullvar, wt_fullvar, pass2var, dnom, wt_mean, /* wt_mean now just mean */ n_mgau, n_stream, n_density, veclen, cmd_ln_boolean("-tiedvar")); } } else { if (wt_var) { E_INFO("Normalizing var\n"); gauden_norm_wt_var(in_var, wt_var, pass2var, dnom, wt_mean, /* wt_mean now just mean */ n_mgau, n_stream, n_density, veclen, cmd_ln_boolean("-tiedvar")); } } } else { if (wt_var || wt_fullvar) { E_INFO("Ignoring variances since -varfn not specified\n"); } } } else { E_INFO("No means or variances to normalize\n"); } /* * Write the parameters to files */ if (out_mixw_fn) { if (mixw_acc) { if (s3mixw_write(out_mixw_fn, mixw_acc, n_mixw, n_stream, n_density) != S3_SUCCESS) { return S3_ERROR; } } else { E_WARN("NO mixing weight accumulators seen, but -mixwfn specified.\n"); } } else { if (mixw_acc) { E_INFO("Mixing weight accumulators seen, but -mixwfn NOT specified.\n"); } } if (out_tmat_fn) { if (tmat_acc) { if (s3tmat_write(out_tmat_fn, tmat_acc, n_tmat, n_state_pm) != S3_SUCCESS) { return S3_ERROR; } } else { E_WARN("NO transition matrix accumulators seen, but -tmatfn specified.\n"); } } else { if (tmat_acc) E_INFO("Transition matrix accumulators seen, but -tmatfn NOT specified\n"); } if (out_mean_fn) { if (wt_mean) { if (s3gau_write(out_mean_fn, (const vector_t ***)wt_mean, n_mgau, n_stream, n_density, veclen) != S3_SUCCESS) return S3_ERROR; if (out_dcount_fn) { if (s3gaudnom_write(out_dcount_fn, dnom, n_mgau, n_stream, n_density) != S3_SUCCESS) return S3_ERROR; } } else E_WARN("NO reestimated means seen, but -meanfn specified\n"); } else { if (wt_mean) { E_INFO("Reestimated means seen, but -meanfn NOT specified\n"); } } if (out_var_fn) { if (var_is_full) { if (wt_fullvar) { if (s3gau_write_full(out_var_fn, (const vector_t ****)wt_fullvar, n_mgau, n_stream, n_density, veclen) != S3_SUCCESS) return S3_ERROR; } else E_WARN("NO reestimated variances seen, but -varfn specified\n"); } else { if (wt_var) { if (s3gau_write(out_var_fn, (const vector_t ***)wt_var, n_mgau, n_stream, n_density, veclen) != S3_SUCCESS) return S3_ERROR; } else E_WARN("NO reestimated variances seen, but -varfn specified\n"); } } else { if (wt_var) { E_INFO("Reestimated variances seen, but -varfn NOT specified\n"); } } if (veclen) ckd_free((void *)veclen); return S3_SUCCESS; }
static int init_mixw() { model_def_t *src_mdef; float32 ***src_mixw; vector_t ***src_mean; vector_t ***src_var = NULL; vector_t ****src_fullvar = NULL; float32 ***src_tmat; model_def_t *dest_mdef; float32 ***dest_mixw; vector_t ***dest_mean; vector_t ***dest_var = NULL; vector_t ****dest_fullvar = NULL; float32 ***dest_tmat; uint32 n_mixw_src; uint32 n_mixw_dest; uint32 n_feat; uint32 tmp_n_feat; uint32 n_gau; uint32 tmp_n_gau; uint32 n_cb_src; uint32 n_cb_dest; uint32 n_state_pm; uint32 n_tmat_src; uint32 n_tmat_dest; uint32 *veclen; uint32 *tmp_veclen; uint32 m; uint32 dest_m; uint32 dest_m_base; uint32 src_m; acmod_id_t src_m_base; const char *dest_m_name; const char *dest_m_base_name; uint32 i; uint32 n_ts; uint32 n_cb; const char *ts2cbfn; E_INFO("Reading src %s\n", cmd_ln_str("-src_moddeffn")); /* read in the source model definition file */ if (model_def_read(&src_mdef, cmd_ln_str("-src_moddeffn")) != S3_SUCCESS) { return S3_ERROR; } ts2cbfn = cmd_ln_str("-src_ts2cbfn"); if (strcmp(SEMI_LABEL, ts2cbfn) == 0) { E_INFO("Generating semi-continous ts2cb mapping\n"); src_mdef->cb = semi_ts2cb(src_mdef->n_tied_state); n_ts = src_mdef->n_tied_state; n_cb = 1; } else if (strcmp(CONT_LABEL, ts2cbfn) == 0) { E_INFO("Generating continous ts2cb mapping\n"); src_mdef->cb = cont_ts2cb(src_mdef->n_tied_state); n_ts = src_mdef->n_tied_state; n_cb = src_mdef->n_tied_state; } else if (strcmp(PTM_LABEL, ts2cbfn) == 0) { E_INFO("Generating phonetically tied ts2cb mapping\n"); src_mdef->cb = ptm_ts2cb(src_mdef); n_ts = src_mdef->n_tied_state; n_cb = src_mdef->acmod_set->n_ci; } else { E_INFO("Reading src %s\n", cmd_ln_str("-src_ts2cbfn")); if (s3ts2cb_read(ts2cbfn, &src_mdef->cb, &n_ts, &n_cb) != S3_SUCCESS) { return S3_ERROR; } } E_INFO("Reading src %s\n", cmd_ln_str("-src_mixwfn")); /* read in the source mixing weight parameter file */ if (s3mixw_read(cmd_ln_str("-src_mixwfn"), &src_mixw, &n_mixw_src, &n_feat, &n_gau) != S3_SUCCESS) { return S3_ERROR; } E_INFO("Reading src %s\n", cmd_ln_str("-src_tmatfn")); if (s3tmat_read(cmd_ln_str("-src_tmatfn"), &src_tmat, &n_tmat_src, &n_state_pm) != S3_SUCCESS) { return S3_ERROR; } E_INFO("Reading src %s\n", cmd_ln_str("-src_meanfn")); if (s3gau_read(cmd_ln_str("-src_meanfn"), &src_mean, &n_cb_src, &tmp_n_feat, &tmp_n_gau, &veclen) != S3_SUCCESS) { return S3_ERROR; } if (tmp_n_feat != n_feat) { E_FATAL("src mean n_feat (== %u) != prior value (== %u)\n", tmp_n_feat, n_feat); } if (tmp_n_gau != n_gau) { E_FATAL("src mean n_gau (== %u) != prior value (== %u)\n", tmp_n_gau, n_gau); } if (n_cb_src != n_cb) { E_FATAL("src mean n_cb (== %u) is inconsistent with ts2cb mapping %u. Most probably phoneset has duplicated phones\n", n_cb_src, n_cb); } E_INFO("Reading src %s\n", cmd_ln_str("-src_varfn")); if (cmd_ln_int32("-fullvar")) { if (s3gau_read_full(cmd_ln_str("-src_varfn"), &src_fullvar, &n_cb_src, &tmp_n_feat, &tmp_n_gau, &tmp_veclen) != S3_SUCCESS) { return S3_ERROR; } } else { if (s3gau_read(cmd_ln_str("-src_varfn"), &src_var, &n_cb_src, &tmp_n_feat, &tmp_n_gau, &tmp_veclen) != S3_SUCCESS) { return S3_ERROR; } } if (tmp_n_feat != n_feat) { E_FATAL("src var n_feat (== %u) != prior value (== %u)\n", tmp_n_feat, n_feat); } if (tmp_n_gau != n_gau) { E_FATAL("src var n_gau (== %u) != prior value (== %u)\n", tmp_n_gau, n_gau); } if (n_cb_src != n_cb) { E_FATAL("src var n_cb (== %u) inconsistent w/ ts2cb mapping %u\n", n_cb_src, n_cb); } if (n_mixw_src < src_mdef->n_tied_state) { E_FATAL("Too few source mixing weights, %u, for the # of tied states, %u\n", n_mixw_src, src_mdef->n_tied_state); } for (i = 0; i < n_feat; i++) { if (veclen[i] != tmp_veclen[i]) { E_FATAL("src var veclen[%u] (== %u) != prior value (== %u)\n", i, tmp_veclen[i], veclen[i]); } } ckd_free(tmp_veclen); E_INFO("Reading dest %s\n", cmd_ln_str("-dest_moddeffn")); /* read in the destination model definition file */ if (model_def_read(&dest_mdef, cmd_ln_str("-dest_moddeffn")) < S3_SUCCESS) { return S3_ERROR; } ts2cbfn = cmd_ln_str("-dest_ts2cbfn"); if (strcmp(SEMI_LABEL, ts2cbfn) == 0) { E_INFO("Generating semi-continous ts2cb mapping\n"); dest_mdef->cb = semi_ts2cb(dest_mdef->n_tied_state); n_ts = dest_mdef->n_tied_state; n_cb = 1; } else if (strcmp(CONT_LABEL, ts2cbfn) == 0) { E_INFO("Generating continous ts2cb mapping\n"); dest_mdef->cb = cont_ts2cb(dest_mdef->n_tied_state); n_ts = dest_mdef->n_tied_state; n_cb = dest_mdef->n_tied_state; } else if (strcmp(PTM_LABEL, ts2cbfn) == 0) { E_INFO("Generating phonetically tied ts2cb mapping\n"); dest_mdef->cb = ptm_ts2cb(dest_mdef); n_ts = dest_mdef->n_tied_state; n_cb = dest_mdef->acmod_set->n_ci; } else { E_INFO("Reading dest %s\n", cmd_ln_str("-dest_ts2cbfn")); if (s3ts2cb_read(ts2cbfn, &dest_mdef->cb, &n_ts, &n_cb) != S3_SUCCESS) { return S3_ERROR; } } E_INFO("Calculating initial model parameters\n"); n_tmat_dest = dest_mdef->n_tied_tmat; tmat_dest_list = init_was_added(n_tmat_dest); E_INFO("Alloc %ux%ux%u dest tmat\n", n_tmat_dest, n_state_pm-1, n_state_pm); dest_tmat = (float32 ***)ckd_calloc_3d(n_tmat_dest, n_state_pm-1, n_state_pm, sizeof(float32)); n_mixw_dest = dest_mdef->n_tied_state; mixw_dest_list = init_was_added(n_mixw_dest); E_INFO("Alloc %ux%ux%u dest mixw\n", n_mixw_dest, n_feat, n_gau); dest_mixw = (float32 ***)ckd_calloc_3d(n_mixw_dest, n_feat, n_gau, sizeof(float32)); for (i = 0, n_cb_dest = 0; i < n_mixw_dest; i++) { if (dest_mdef->cb[i] > n_cb_dest) { n_cb_dest = dest_mdef->cb[i]; } } ++n_cb_dest; cb_dest_list = init_was_added(n_cb_dest); E_INFO("Alloc %ux%ux%u dest mean and var\n", n_cb_dest, n_feat, n_gau); dest_mean = gauden_alloc_param(n_cb_dest, n_feat, n_gau, veclen); if (src_var) dest_var = gauden_alloc_param(n_cb_dest, n_feat, n_gau, veclen); else if (src_fullvar) dest_fullvar = gauden_alloc_param_full(n_cb_dest, n_feat, n_gau, veclen); for (dest_m = 0; dest_m < dest_mdef->n_defn; dest_m++) { dest_m_name = acmod_set_id2name(dest_mdef->acmod_set, dest_m); src_m = acmod_set_name2id(src_mdef->acmod_set, dest_m_name); if (src_m == NO_ACMOD) { /* No corresponding phone model in the source set */ /* See if there is a source base phone corresponding to this destination model base phone */ dest_m_base = acmod_set_base_phone(dest_mdef->acmod_set, dest_m); dest_m_base_name = acmod_set_id2name(dest_mdef->acmod_set, dest_m_base); src_m_base = acmod_set_name2id(src_mdef->acmod_set, dest_m_base_name); if (src_m_base == NO_ACMOD) { /* No corresponding model or base model found. Use uniform distribution */ E_INFO("No source base phone %s found. Initializing %s using uniform distribution\n", dest_m_base_name, dest_m_name); if (src_tmat) { E_INFO("Uniform initialization of tmat not supported\n"); } init_uniform(dest_mixw, &dest_mdef->defn[dest_m], n_feat, n_gau); } else { /* No corresponding model, but a base model was found. Use base distribution. */ init_model(dest_mixw, dest_mean, dest_var, dest_fullvar, dest_tmat, &dest_mdef->defn[dest_m], dest_mdef->cb, dest_mdef->acmod_set, src_mixw, src_mean, src_var, src_fullvar, src_tmat, &src_mdef->defn[src_m_base], src_mdef->cb, src_mdef->acmod_set, n_feat, n_gau, n_state_pm, veclen); } } else { /* Found a corresponding model in the source set, so use source distributions to init the destination */ init_model(dest_mixw, dest_mean, dest_var, dest_fullvar, dest_tmat, &dest_mdef->defn[dest_m], dest_mdef->cb, dest_mdef->acmod_set, src_mixw, src_mean, src_var, src_fullvar, src_tmat, &src_mdef->defn[src_m], src_mdef->cb, src_mdef->acmod_set, n_feat, n_gau, n_state_pm, veclen); } } for (m = 0; m < n_mixw_dest; m++) { if (mixw_dest_list[m] == NULL) { E_WARN("Destination state %u has not been initialized!\n", m); } } for (m = 0; m < n_cb_dest; m++) { if (cb_dest_list[m] == NULL) { E_WARN("Destination cb %u has not been initialized!\n", m); } else if (cb_dest_list[m]->next != NULL) { E_WARN("dest cb %u has > 1 corresponding source cb\n", m); } } E_INFO("Writing dest %s\n", cmd_ln_str("-dest_tmatfn")); if (s3tmat_write(cmd_ln_str("-dest_tmatfn"), dest_tmat, n_tmat_dest, n_state_pm) != S3_SUCCESS) { return S3_ERROR; } E_INFO("Writing dest %s\n", cmd_ln_str("-dest_mixwfn")); if (s3mixw_write(cmd_ln_str("-dest_mixwfn"), dest_mixw, dest_mdef->n_tied_state, n_feat, n_gau) < S3_SUCCESS) { return S3_ERROR; } E_INFO("Writing dest %s\n", cmd_ln_str("-dest_meanfn")); if (s3gau_write(cmd_ln_str("-dest_meanfn"), (const vector_t ***)dest_mean, n_cb_dest, n_feat, n_gau, veclen) != S3_SUCCESS) { return S3_ERROR; } E_INFO("Writing dest %s\n", cmd_ln_str("-dest_varfn")); if (cmd_ln_int32("-fullvar")) { if (s3gau_write_full(cmd_ln_str("-dest_varfn"), (const vector_t ****)dest_fullvar, n_cb_dest, n_feat, n_gau, veclen) != S3_SUCCESS) { return S3_ERROR; } } else { if (s3gau_write(cmd_ln_str("-dest_varfn"), (const vector_t ***)dest_var, n_cb_dest, n_feat, n_gau, veclen) != S3_SUCCESS) { return S3_ERROR; } } ckd_free(veclen); return S3_SUCCESS; }