int
main(int argc, char *argv[])
{
uint32 *spd;
model_def_t *mdef;
const char *tying_type;
uint32 i;
uint32 n_cb=0;
parse_cmd_ln(argc, argv);
E_INFO("Reading model definition file %s\n", cmd_ln_str("-moddeffn"));
if (model_def_read(&mdef, cmd_ln_str("-moddeffn")) != S3_SUCCESS) {
exit(1);
}
E_INFO("%d tied states defined\n", mdef->n_tied_state);
tying_type = cmd_ln_str("-tyingtype");
E_INFO("Generating state parameter definitions for %s tying\n", tying_type);
spd = ckd_calloc(mdef->n_tied_state, sizeof(uint32));
if (strcmp(tying_type, "semi") == 0) {
n_cb = 1;
}
else if (strcmp(tying_type, "pd") == 0) {
E_INFO("Phone dependent codebooks not yet implemented\n");
exit(1);
}
else if (strcmp(tying_type, "cont") == 0) {
n_cb = mdef->n_tied_state;
for (i = 0; i < mdef->n_tied_state; i++)
spd[i] = i;
}
else {
E_FATAL("Unknown tying type %s given\n", tying_type);
}
E_INFO("Writing %s\n", cmd_ln_str("-ts2cbfn"));
if (s3ts2cb_write(cmd_ln_str("-ts2cbfn"),
spd,
mdef->n_tied_state,
n_cb) != S3_SUCCESS) {
E_FATAL_SYSTEM("Unable to write %s\n", cmd_ln_str("-ts2cbfn"));
}
return 0;
}
int
main_initialize(int argc,
char *argv[],
lexicon_t **out_lex,
model_def_t **out_omdef,
model_def_t **out_dmdef)
{
model_def_t *dmdef = NULL;
model_def_t *omdef = NULL;
lexicon_t *lex = NULL;
const char *fn;
uint32 n_ts;
uint32 n_cb;
const char *ts2cbfn;
parse_cmd_ln(argc, argv);
timing_bind_name("km", timing_new());
timing_bind_name("var", timing_new());
timing_bind_name("em", timing_new());
timing_bind_name("all", timing_new());
if (cmd_ln_access("-feat") != NULL) {
feat_set(cmd_ln_str("-feat"));
feat_set_in_veclen(cmd_ln_int32("-ceplen"));
feat_set_subvecs(cmd_ln_str("-svspec"));
}
else {
E_FATAL("You need to set a feature extraction config using -feat\n");
}
if (cmd_ln_access("-ldafn") != NULL) {
if (feat_read_lda(cmd_ln_access("-ldafn"), cmd_ln_int32("-ldadim"))) {
E_FATAL("Failed to read LDA matrix\n");
}
}
if (cmd_ln_access("-omoddeffn")) {
E_INFO("Reading output model definitions: %s\n", cmd_ln_access("-omoddeffn"));
/* Read in the model definitions. Defines the set of
CI phones and context dependent phones. Defines the
transition matrix tying and state level tying. */
if (model_def_read(&omdef,
cmd_ln_access("-omoddeffn")) != S3_SUCCESS) {
return S3_ERROR;
}
if (cmd_ln_access("-dmoddeffn")) {
E_INFO("Reading dump model definitions: %s\n", cmd_ln_access("-dmoddeffn"));
if (model_def_read(&dmdef,
cmd_ln_access("-dmoddeffn")) != S3_SUCCESS) {
return S3_ERROR;
}
setup_d2o_map(dmdef, omdef);
}
else {
E_INFO("Assuming dump and output model definitions are identical\n");
}
ts2cbfn = cmd_ln_access("-ts2cbfn");
if (ts2cbfn) {
if (strcmp(SEMI_LABEL, ts2cbfn) == 0) {
omdef->cb = semi_ts2cb(omdef->n_tied_state);
n_ts = omdef->n_tied_state;
n_cb = 1;
}
else if (strcmp(CONT_LABEL, ts2cbfn) == 0) {
omdef->cb = cont_ts2cb(omdef->n_tied_state);
n_ts = omdef->n_tied_state;
n_cb = omdef->n_tied_state;
}
else if (strcmp(PTM_LABEL, ts2cbfn) == 0) {
omdef->cb = ptm_ts2cb(omdef);
n_ts = omdef->n_tied_state;
n_cb = omdef->acmod_set->n_ci;
}
else if (s3ts2cb_read(cmd_ln_access("-ts2cbfn"),
&omdef->cb,
&n_ts,
&n_cb) != S3_SUCCESS) {
return S3_ERROR;
}
if (omdef->n_tied_state != n_ts) {
E_FATAL("Model definition file n_tied_state = %u, but %u mappings in ts2cb\n",
omdef->n_tied_state, n_ts);
}
}
}
else {
E_INFO("No mdef files. Assuming 1-class init\n");
}
*out_omdef = omdef;
*out_dmdef = dmdef;
fn = cmd_ln_access("-dictfn");
if (fn) {
E_INFO("Reading main lexicon: %s\n", fn);
lex = lexicon_read(NULL,
fn,
omdef->acmod_set);
if (lex == NULL)
return S3_ERROR;
}
fn = cmd_ln_access("-fdictfn");
if (fn) {
E_INFO("Reading filler lexicon: %s\n", fn);
(void)lexicon_read(lex,
fn,
omdef->acmod_set);
}
*out_lex = lex;
stride = *(int32 *)cmd_ln_access("-stride");
return S3_SUCCESS;
}
int
init(model_def_t **out_imdef,
pset_t **out_pset,
uint32 *out_n_pset,
dtree_t ****out_tree,
uint32 *out_n_seno)
{
model_def_t *imdef;
uint32 p, s;
uint32 n_ci, n_state;
char fn[MAXPATHLEN+1];
const char *a_fn;
FILE *fp;
dtree_t ***tree, *tr;
pset_t *pset;
uint32 n_pset;
uint32 n_seno;
const char *treedir;
uint32 ts_id;
int allphones;
a_fn = cmd_ln_str("-imoddeffn");
if (a_fn == NULL)
E_FATAL("Specify -imoddeffn\n");
if (model_def_read(&imdef, a_fn) != S3_SUCCESS) {
return S3_ERROR;
}
*out_imdef = imdef;
a_fn = cmd_ln_str("-psetfn");
E_INFO("Reading: %s\n", a_fn);
*out_pset = pset = read_pset_file(a_fn, imdef->acmod_set, &n_pset);
*out_n_pset = n_pset;
allphones = cmd_ln_int32("-allphones");
if (allphones)
n_ci = 1;
else
n_ci = acmod_set_n_ci(imdef->acmod_set);
treedir = cmd_ln_str("-treedir");
tree = (dtree_t ***)ckd_calloc(n_ci, sizeof(dtree_t **));
*out_tree = tree;
ts_id = imdef->n_tied_ci_state;
for (p = 0, n_seno = 0; p < n_ci; p++) {
if (allphones || !acmod_set_has_attrib(imdef->acmod_set, p, "filler")) {
const char *pname;
if (allphones) {
n_state = imdef->defn[acmod_set_n_ci(imdef->acmod_set)].n_state;
pname = "ALLPHONES";
}
else {
n_state = imdef->defn[p].n_state;
pname = acmod_set_id2name(imdef->acmod_set, p);
}
tree[p] = (dtree_t **)ckd_calloc(n_state, sizeof(dtree_t *));
for (s = 0; s < n_state-1; s++) {
E_INFO("%s-%u: offset %u\n",
pname, s, ts_id);
sprintf(fn, "%s/%s-%u.dtree",
treedir, pname, s);
fp = fopen(fn, "r");
if (fp == NULL) {
E_FATAL_SYSTEM("Unable to open %s for reading", fn);
}
tree[p][s] = tr = read_final_tree(fp, pset, n_pset);
label_leaves(&tr->node[0], &ts_id);
fclose(fp);
n_seno += cnt_leaf(&tr->node[0]);
}
}
}
assert(n_seno == (ts_id - imdef->n_tied_ci_state));
E_INFO("n_seno= %u\n", ts_id);
*out_n_seno = n_seno;
return S3_SUCCESS;
}
int
main_initialize(int argc,
char *argv[],
lexicon_t **out_lex,
model_def_t **out_omdef,
model_def_t **out_dmdef,
feat_t** out_feat)
{
model_def_t *dmdef = NULL;
model_def_t *omdef = NULL;
lexicon_t *lex = NULL;
feat_t *feat;
const char *fn;
uint32 n_ts;
uint32 n_cb;
const char *ts2cbfn;
parse_cmd_ln(argc, argv);
feat =
feat_init(cmd_ln_str("-feat"),
cmn_type_from_str(cmd_ln_str("-cmn")),
cmd_ln_boolean("-varnorm"),
agc_type_from_str(cmd_ln_str("-agc")),
1, cmd_ln_int32("-ceplen"));
if (cmd_ln_str("-lda")) {
E_INFO("Reading linear feature transformation from %s\n",
cmd_ln_str("-lda"));
if (feat_read_lda(feat,
cmd_ln_str("-lda"),
cmd_ln_int32("-ldadim")) < 0)
return -1;
}
if (cmd_ln_str("-svspec")) {
int32 **subvecs;
E_INFO("Using subvector specification %s\n",
cmd_ln_str("-svspec"));
if ((subvecs = parse_subvecs(cmd_ln_str("-svspec"))) == NULL)
return -1;
if ((feat_set_subvecs(feat, subvecs)) < 0)
return -1;
}
if (cmd_ln_exists("-agcthresh")
&& 0 != strcmp(cmd_ln_str("-agc"), "none")) {
agc_set_threshold(feat->agc_struct,
cmd_ln_float32("-agcthresh"));
}
if (feat->cmn_struct
&& cmd_ln_exists("-cmninit")) {
char *c, *cc, *vallist;
int32 nvals;
vallist = ckd_salloc(cmd_ln_str("-cmninit"));
c = vallist;
nvals = 0;
while (nvals < feat->cmn_struct->veclen
&& (cc = strchr(c, ',')) != NULL) {
*cc = '\0';
feat->cmn_struct->cmn_mean[nvals] = FLOAT2MFCC(atof(c));
c = cc + 1;
++nvals;
}
if (nvals < feat->cmn_struct->veclen && *c != '\0') {
feat->cmn_struct->cmn_mean[nvals] = FLOAT2MFCC(atof(c));
}
ckd_free(vallist);
}
*out_feat = feat;
if (cmd_ln_str("-omoddeffn")) {
E_INFO("Reading output model definitions: %s\n", cmd_ln_str("-omoddeffn"));
/* Read in the model definitions. Defines the set of
CI phones and context dependent phones. Defines the
transition matrix tying and state level tying. */
if (model_def_read(&omdef,
cmd_ln_str("-omoddeffn")) != S3_SUCCESS) {
return S3_ERROR;
}
if (cmd_ln_str("-dmoddeffn")) {
E_INFO("Reading dump model definitions: %s\n", cmd_ln_str("-dmoddeffn"));
if (model_def_read(&dmdef,
cmd_ln_str("-dmoddeffn")) != S3_SUCCESS) {
return S3_ERROR;
}
setup_d2o_map(dmdef, omdef);
}
else {
E_INFO("Assuming dump and output model definitions are identical\n");
}
ts2cbfn = cmd_ln_str("-ts2cbfn");
if (ts2cbfn) {
if (strcmp(SEMI_LABEL, ts2cbfn) == 0) {
omdef->cb = semi_ts2cb(omdef->n_tied_state);
n_ts = omdef->n_tied_state;
n_cb = 1;
}
else if (strcmp(CONT_LABEL, ts2cbfn) == 0) {
omdef->cb = cont_ts2cb(omdef->n_tied_state);
n_ts = omdef->n_tied_state;
n_cb = omdef->n_tied_state;
}
else if (strcmp(PTM_LABEL, ts2cbfn) == 0) {
omdef->cb = ptm_ts2cb(omdef);
n_ts = omdef->n_tied_state;
n_cb = omdef->acmod_set->n_ci;
}
else if (s3ts2cb_read(cmd_ln_str("-ts2cbfn"),
&omdef->cb,
&n_ts,
&n_cb) != S3_SUCCESS) {
return S3_ERROR;
}
if (omdef->n_tied_state != n_ts) {
E_FATAL("Model definition file n_tied_state = %u, but %u mappings in ts2cb\n",
omdef->n_tied_state, n_ts);
}
}
}
else {
E_INFO("No mdef files. Assuming 1-class init\n");
}
*out_omdef = omdef;
*out_dmdef = dmdef;
fn = cmd_ln_str("-dictfn");
if (fn) {
E_INFO("Reading main lexicon: %s\n", fn);
lex = lexicon_read(NULL,
fn,
omdef->acmod_set);
if (lex == NULL)
return S3_ERROR;
}
fn = cmd_ln_str("-fdictfn");
if (fn) {
E_INFO("Reading filler lexicon: %s\n", fn);
(void)lexicon_read(lex,
fn,
omdef->acmod_set);
}
*out_lex = lex;
stride = cmd_ln_int32("-stride");
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;
}
int
main(int argc, char *argv[])
{
model_def_t *mdef;
model_def_entry_t *defn;
uint32 n_defn;
uint32 *cluster_offset;
uint32 max_int;
uint32 *state_of;
uint32 max_state;
uint32 sstate;
int32 i;
uint32 j;
uint32 n_base_phone;
acmod_id_t base;
acmod_id_t p;
float32 ***out;
uint32 **smap;
char comment[4192];
time_t t;
parse_cmd_ln(argc, argv);
printf("%s(%d): Reading model definition file %s\n",
__FILE__, __LINE__, (const char *)cmd_ln_access("-moddeffn"));
if (model_def_read(&mdef, cmd_ln_access("-moddeffn")) != S3_SUCCESS) {
exit(1);
}
defn = mdef->defn;
n_defn = mdef->n_defn;
printf("%s(%d): %d models defined\n",
__FILE__, __LINE__, n_defn);
smap = ckd_calloc(n_defn, sizeof(uint32 *));
n_base_phone = acmod_set_n_ci(mdef->acmod_set);
cluster_offset = ckd_calloc(n_base_phone+1, sizeof(uint32));
max_int = 0;
--max_int; /* underflow offset values to max value */
for (i = 0; i < n_base_phone; i++) {
cluster_offset[i] = max_int;
}
for (i = 0, max_state = 0; i < n_defn; i++) {
for (j = 0; j < defn[i].n_state; j++) {
sstate = defn[i].state[j];
if ((sstate != TYING_NON_EMITTING) &&
(defn[i].state[j] > max_state)) max_state = defn[i].state[j];
}
}
/* record the total # of senones */
cluster_offset[n_base_phone] = max_state+1;
state_of = ckd_calloc(max_state+1, sizeof(uint32));
for (i = 0; i <= max_state; i++)
state_of[i] = NO_STATE;
for (i = 0; i < n_defn; i++) {
p = defn[i].p;
base = acmod_set_base_phone(mdef->acmod_set, defn[i].p);
smap[i] = defn[i].state;
for (j = 0; j < defn[i].n_state; j++) {
sstate = defn[i].state[j];
if (sstate != TYING_NON_EMITTING) {
if (state_of[sstate] == NO_STATE)
state_of[sstate] = j;
else if (state_of[sstate] != j) {
printf("%s %d appears as %d%s and %d%s model states\n",
acmod_set_id2name(mdef->acmod_set, acmod_set_base_phone(mdef->acmod_set, defn[i].p)),
sstate,
state_of[sstate],
ord_suff(state_of[sstate]),
j,
ord_suff(j));
}
if ((p != base) && (cluster_offset[base] > sstate)) {
cluster_offset[base] = sstate;
}
}
}
}
/* any untouched CLUSTER_OFFSET's implies a base phone
without any CD states. So offset is same as next
one */
for (i = (n_base_phone - 1); i >= 0 ; i--) {
if (cluster_offset[i] == max_int)
cluster_offset[i] = cluster_offset[i+1];
}
fflush(stdout);
for (i = 0; i < n_base_phone; i++) {
if (cluster_offset[i] != max_int) {
fprintf(stderr, "%s(%d): %s offset %d\n",
__FILE__, __LINE__,
acmod_set_id2name(mdef->acmod_set, i), cluster_offset[i]);
}
else {
fprintf(stderr, "%s(%d): %s <no CD states>\n",
__FILE__, __LINE__,
acmod_set_id2name(mdef->acmod_set, i));
}
}
fflush(stderr);
printf("%s(%d): Reading senone weights in %s with floor %e\n",
__FILE__, __LINE__, (const char *)cmd_ln_access("-hmmdir"),
*(float32 *)cmd_ln_access("-floor"));
out = s2_read_seno_3(mdef->acmod_set, cluster_offset,
cmd_ln_access("-hmmdir"),
(*(int32 *)cmd_ln_access("-ci2cd") ? NULL : smap),
*(float32 *)cmd_ln_access("-floor"),
state_of);
t = time(NULL);
sprintf(comment,
"Generated on %s\n\tmoddeffn: %s\n\tfloor: %e\n\thmmdir: %s\n\n\n\n\n\n\n\n\n",
ctime(&t),
(const char *)cmd_ln_access("-moddeffn"),
*(float32 *)cmd_ln_access("-floor"),
(const char *)cmd_ln_access("-hmmdir"));
fflush(stdout);
fprintf(stderr, "%s(%d): writing %s\n",
__FILE__, __LINE__,
(const char *)cmd_ln_access("-mixwfn"));
fflush(stderr);
if (s3mixw_write(cmd_ln_access("-mixwfn"),
out,
cluster_offset[n_base_phone], /* total # states */
S2_N_FEATURE,
S2_N_CODEWORD) != S3_SUCCESS) {
fflush(stdout);
fprintf(stderr, "%s(%d): couldn't write mixture weight file\n",
__FILE__, __LINE__);
perror(cmd_ln_access("-mixwfn"));
fflush(stderr);
}
ckd_free(state_of);
ckd_free(cluster_offset);
return 0;
}
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;
}
int main(int argc, char *argv[])
{
const char *out_mllr_fn;
const char **accum_dir;
const char *mean_fn;
const char *var_fn;
const char *cb2mllrfn;
const char *moddeffn;
uint32 cdonly;
uint32 mllr_mult; /* option 0 or 1 */
uint32 mllr_add; /* option 0 or 1 */
float32 varfloor;
vector_t ***mean = NULL; /* baseline mean */
vector_t ***wt_mean = NULL; /* read from bw accum */
float32 ***wt_dcount = NULL; /* read from bw accum */
vector_t ***wt_var = NULL; /* not used */
int32 pass2var; /* not used */
uint32 n_mgau;
uint32 n_stream;
uint32 n_density;
uint32 n_mllr_class;
uint32 n_mgau_rd;
uint32 n_stream_rd;
uint32 n_density_rd;
uint32 *veclen = NULL;
uint32 *veclen_rd = NULL;
float32 ****A = NULL; /* Output mllr: A */
float32 ***B = NULL; /* Output mllr: B */
int32 *cb2mllr = NULL;
/* int32 **mllr2cb = NULL;
int32 *n_mllr2cb = NULL;*/
model_def_t *mdef;
uint32 gau_begin;
uint32 i,s ;
if (initialize(argc, argv) != S3_SUCCESS) {
E_FATAL("errors initializing.\n");
}
out_mllr_fn = cmd_ln_str("-outmllrfn");
accum_dir = cmd_ln_str_list("-accumdir");
mean_fn = cmd_ln_str("-meanfn");
var_fn = cmd_ln_str("-varfn");
cb2mllrfn = cmd_ln_str("-cb2mllrfn");
cdonly = cmd_ln_int32("-cdonly");
moddeffn = cmd_ln_str("-moddeffn");
mllr_mult = cmd_ln_int32("-mllrmult");
mllr_add = cmd_ln_int32("-mllradd");
varfloor = cmd_ln_float32("-varfloor");
assert(accum_dir[0] != NULL); /* must be at least one accum dir */
if (! (out_mllr_fn && accum_dir && mean_fn)) {
E_FATAL("Some of options are missing.\n");
}
if (varfloor < 0.) {
E_FATAL("varfloor is negative (%e)\n",varfloor);
}
if (cb2mllrfn && strcmp(cb2mllrfn,"NO") == 0) {
cb2mllrfn = NULL;
}
if (moddeffn && strcmp(moddeffn,"NO") == 0) {
moddeffn = NULL;
}
/*--------------------------------------------------------------------*/
fprintf(stderr,"\n");
E_INFO("-- 1. Read input mean, (var) and accumulation.\n");
/*--------------------------------------------------------------------*/
/*-------------- Read baseline mean --------------*/
if (s3gau_read(mean_fn,
&mean,
&n_mgau,
&n_stream,
&n_density,
&veclen) != S3_SUCCESS) {
E_FATAL("Couldn't read %s", mean_fn);
}
/*-------- Read accum_dir (accumulation from bw) --------*/
for (i = 0; accum_dir[i]; i++) {
E_INFO("Reading and accumulating counts from %s\n", accum_dir[i]);
if (rdacc_den(accum_dir[i],
&wt_mean,
&wt_var,
&pass2var,
&wt_dcount,
&n_mgau_rd,
&n_stream_rd,
&n_density_rd,
&veclen_rd) != S3_SUCCESS) {
E_FATAL("Error in reading %s\n", accum_dir[i]);
}
}
if (n_mgau != n_mgau_rd) {
E_FATAL("n_mgau mismatch (%u : %u)\n",n_mgau,n_mgau_rd);
}
if (n_stream != n_stream_rd) {
E_FATAL("n_stream mismatch (%u : %u)\n",n_stream,n_stream_rd);
}
if (n_density != n_density_rd) {
E_FATAL("n_density mismatch (%u : %u)\n",n_density,n_density_rd);
}
for (s = 0; s < n_stream; s++) {
if (veclen[s] != veclen_rd[s]) {
E_FATAL("vector length of stream %u (== %u) "
"!= prior length (== %u)\n",
s, veclen_rd[s], veclen[s]);
}
}
ckd_free((void *)veclen_rd);
veclen_rd = NULL;
if (wt_var) { /* We don't use 'wt_var' in this program. */
gauden_free_param(wt_var);
wt_var = NULL;
}
/*--------------------------------------------------------------------*/
fprintf(stderr,"\n");
E_INFO("-- 2. Read cb2mllrfn\n");
/*--------------------------------------------------------------------*/
if (strcmp(cb2mllrfn, ".1cls.") == 0) {
n_mllr_class = 1;
cb2mllr = (int32 *) ckd_calloc(n_mgau, sizeof(int32));
}
else {
if (s3cb2mllr_read(cb2mllrfn,
&cb2mllr,
&n_mgau_rd,
&n_mllr_class) != S3_SUCCESS) {
E_FATAL("Unable to read %s\n",cb2mllrfn);
}
if (n_mgau_rd != n_mgau) {
E_FATAL("cb2mllr maps %u cb, but read %u cb from files\n",
n_mgau_rd, n_mgau);
}
}
E_INFO("n_mllr_class = %d\n", n_mllr_class);
gau_begin = 0;
if (cdonly) {
if (! moddeffn) {
E_FATAL("-moddeffn is not given.\n");
}
else if (model_def_read(&mdef, moddeffn) != S3_SUCCESS) {
E_FATAL("Can not read model definition file %s\n", moddeffn);
}
gau_begin = mdef->n_tied_ci_state;
for (i=0; i<gau_begin; i++) {
cb2mllr[i] = -1; /* skip CI senones */
}
E_INFO("Use CD senones only. (index >= %d)\n",mdef->n_tied_ci_state);
}
/*--------------------------------------------------------------------*/
fprintf(stderr,"\n");
E_INFO("-- 3. Calculate mllr matrices\n");
/*--------------------------------------------------------------------*/
mllr_mat(&A,
&B,
var_fn,
mean,
wt_mean,
wt_dcount,
gau_begin,
cb2mllr,
mllr_mult,
mllr_add,
varfloor,
n_mgau,
n_stream,
n_density,
n_mllr_class,
veclen);
/*--------------------------------------------------------------------*/
fprintf(stderr,"\n");
E_INFO("-- 4. Store mllr matrices (A,B) to %s\n", out_mllr_fn);
fflush(stderr);
/*--------------------------------------------------------------------*/
if(store_reg_mat(out_mllr_fn,
veclen,
n_mllr_class,
n_stream,
A,
B) != S3_SUCCESS) {
E_FATAL("Unable to write %s\n", out_mllr_fn);
}
ckd_free((void *)veclen);
free_mllr_A(A, n_mllr_class, n_stream);
free_mllr_B(B, n_mllr_class, n_stream);
return 0 ;
}
static int
initialize(int argc,
char *argv[])
{
const char *fdictfn;
const char *dictfn;
const char *ts2cbfn;
uint32 n_ts;
uint32 n_cb;
/* define, parse and (partially) validate the command line */
parse_cmd_ln(argc, argv);
feat =
feat_init(cmd_ln_str("-feat"),
cmn_type_from_str(cmd_ln_str("-cmn")),
cmd_ln_boolean("-varnorm"),
agc_type_from_str(cmd_ln_str("-agc")),
1, cmd_ln_int32("-ceplen"));
if (cmd_ln_str("-lda")) {
E_INFO("Reading linear feature transformation from %s\n",
cmd_ln_str("-lda"));
if (feat_read_lda(feat,
cmd_ln_str("-lda"),
cmd_ln_int32("-ldadim")) < 0)
return -1;
}
if (cmd_ln_str("-svspec")) {
int32 **subvecs;
E_INFO("Using subvector specification %s\n",
cmd_ln_str("-svspec"));
if ((subvecs = parse_subvecs(cmd_ln_str("-svspec"))) == NULL)
return -1;
if ((feat_set_subvecs(feat, subvecs)) < 0)
return -1;
}
if (cmd_ln_exists("-agcthresh")
&& 0 != strcmp(cmd_ln_str("-agc"), "none")) {
agc_set_threshold(feat->agc_struct,
cmd_ln_float32("-agcthresh"));
}
if (feat->cmn_struct
&& cmd_ln_exists("-cmninit")) {
char *c, *cc, *vallist;
int32 nvals;
vallist = ckd_salloc(cmd_ln_str("-cmninit"));
c = vallist;
nvals = 0;
while (nvals < feat->cmn_struct->veclen
&& (cc = strchr(c, ',')) != NULL) {
*cc = '\0';
feat->cmn_struct->cmn_mean[nvals] = FLOAT2MFCC(atof(c));
c = cc + 1;
++nvals;
}
if (nvals < feat->cmn_struct->veclen && *c != '\0') {
feat->cmn_struct->cmn_mean[nvals] = FLOAT2MFCC(atof(c));
}
ckd_free(vallist);
}
if (cmd_ln_str("-segdir"))
corpus_set_seg_dir(cmd_ln_str("-segdir"));
if (cmd_ln_str("-segext"))
corpus_set_seg_ext(cmd_ln_str("-segext"));
corpus_set_mfcc_dir(cmd_ln_str("-cepdir"));
corpus_set_mfcc_ext(cmd_ln_str("-cepext"));
if (cmd_ln_str("-lsnfn"))
corpus_set_lsn_filename(cmd_ln_str("-lsnfn"));
corpus_set_ctl_filename(cmd_ln_str("-ctlfn"));
if (cmd_ln_int32("-nskip") && cmd_ln_int32("-runlen")) {
corpus_set_interval(cmd_ln_int32("-nskip"),
cmd_ln_int32("-runlen"));
} else if (cmd_ln_int32("-part") && cmd_ln_int32("-npart")) {
corpus_set_partition(cmd_ln_int32("-part"),
cmd_ln_int32("-npart"));
}
if (corpus_init() != S3_SUCCESS) {
return S3_ERROR;
}
if (cmd_ln_str("-moddeffn")) {
E_INFO("Reading %s\n", cmd_ln_str("-moddeffn"));
/* Read in the model definitions. Defines the set of
CI phones and context dependent phones. Defines the
transition matrix tying and state level tying. */
if (model_def_read(&mdef,
cmd_ln_str("-moddeffn")) != S3_SUCCESS) {
return S3_ERROR;
}
ts2cbfn = cmd_ln_str("-ts2cbfn");
if (strcmp(SEMI_LABEL, ts2cbfn) == 0) {
mdef->cb = semi_ts2cb(mdef->n_tied_state);
n_ts = mdef->n_tied_state;
n_cb = 1;
}
else if (strcmp(CONT_LABEL, ts2cbfn) == 0) {
mdef->cb = cont_ts2cb(mdef->n_tied_state);
n_ts = mdef->n_tied_state;
n_cb = mdef->n_tied_state;
}
else if (strcmp(PTM_LABEL, ts2cbfn) == 0) {
mdef->cb = ptm_ts2cb(mdef);
n_ts = mdef->n_tied_state;
n_cb = mdef->acmod_set->n_ci;
}
else if (s3ts2cb_read(ts2cbfn,
&mdef->cb,
&n_ts,
&n_cb) != S3_SUCCESS) {
return S3_ERROR;
}
dictfn = cmd_ln_str("-dictfn");
if (dictfn == NULL) {
E_FATAL("You must specify a content dictionary using -dictfn\n");
}
E_INFO("Reading %s\n", dictfn);
lex = lexicon_read(NULL, /* no lexicon to start */
dictfn,
mdef->acmod_set);
if (lex == NULL)
return S3_ERROR;
fdictfn = cmd_ln_str("-fdictfn");
if (fdictfn) {
E_INFO("Reading %s\n", fdictfn);
(void)lexicon_read(lex, /* add filler words content lexicon */
fdictfn,
mdef->acmod_set);
}
}
return S3_SUCCESS;
}
static int
initialize(lexicon_t **out_lex,
model_def_t **out_mdef,
int argc,
char *argv[])
{
lexicon_t *lex = NULL;
model_def_t *mdef = NULL;
const char *fdictfn;
const char *dictfn;
const char *ts2cbfn;
uint32 n_ts;
uint32 n_cb;
/* define, parse and (partially) validate the command line */
parse_cmd_ln(argc, argv);
if (cmd_ln_access("-feat") != NULL) {
feat_set(cmd_ln_str("-feat"));
feat_set_in_veclen(cmd_ln_int32("-ceplen"));
feat_set_subvecs(cmd_ln_str("-svspec"));
}
else {
E_ERROR("Specify the feature extraction algorithm using -feat\n");
return S3_ERROR;
}
if (cmd_ln_access("-ldafn") != NULL) {
if (feat_read_lda(cmd_ln_access("-ldafn"), cmd_ln_int32("-ldadim"))) {
E_FATAL("Failed to read LDA matrix\n");
}
}
if (cmd_ln_access("-segdir"))
corpus_set_seg_dir(cmd_ln_access("-segdir"));
if (cmd_ln_access("-segext"))
corpus_set_seg_ext(cmd_ln_access("-segext"));
corpus_set_mfcc_dir(cmd_ln_access("-cepdir"));
corpus_set_mfcc_ext(cmd_ln_access("-cepext"));
if (cmd_ln_access("-lsnfn"))
corpus_set_lsn_filename(cmd_ln_access("-lsnfn"));
corpus_set_ctl_filename(cmd_ln_access("-ctlfn"));
if ( cmd_ln_access("-nskip") && cmd_ln_access("-runlen") ) {
corpus_set_interval(*(int32 *)cmd_ln_access("-nskip"),
*(int32 *)cmd_ln_access("-runlen"));
}
else if (cmd_ln_access("-part") && cmd_ln_access("-npart")) {
corpus_set_partition(*(uint32 *)cmd_ln_access("-part"),
*(uint32 *)cmd_ln_access("-npart"));
}
if (corpus_init() != S3_SUCCESS) {
return S3_ERROR;
}
if (cmd_ln_access("-moddeffn")) {
E_INFO("Reading %s\n", cmd_ln_access("-moddeffn"));
/* Read in the model definitions. Defines the set of
CI phones and context dependent phones. Defines the
transition matrix tying and state level tying. */
if (model_def_read(&mdef,
cmd_ln_access("-moddeffn")) != S3_SUCCESS) {
return S3_ERROR;
}
ts2cbfn = (const char *)cmd_ln_access("-ts2cbfn");
if (strcmp(SEMI_LABEL, ts2cbfn) == 0) {
mdef->cb = semi_ts2cb(mdef->n_tied_state);
n_ts = mdef->n_tied_state;
n_cb = 1;
}
else if (strcmp(CONT_LABEL, ts2cbfn) == 0) {
mdef->cb = cont_ts2cb(mdef->n_tied_state);
n_ts = mdef->n_tied_state;
n_cb = mdef->n_tied_state;
}
else if (strcmp(PTM_LABEL, ts2cbfn) == 0) {
mdef->cb = ptm_ts2cb(mdef);
n_ts = mdef->n_tied_state;
n_cb = mdef->acmod_set->n_ci;
}
else if (s3ts2cb_read(ts2cbfn,
&mdef->cb,
&n_ts,
&n_cb) != S3_SUCCESS) {
return S3_ERROR;
}
dictfn = cmd_ln_access("-dictfn");
if (dictfn == NULL) {
E_FATAL("You must specify a content dictionary using -dictfn\n");
}
E_INFO("Reading %s\n", dictfn);
lex = lexicon_read(NULL, /* no lexicon to start */
dictfn,
mdef->acmod_set);
if (lex == NULL)
return S3_ERROR;
fdictfn = cmd_ln_access("-fdictfn");
if (fdictfn) {
E_INFO("Reading %s\n", fdictfn);
(void)lexicon_read(lex, /* add filler words content lexicon */
fdictfn,
mdef->acmod_set);
}
}
*out_mdef = mdef;
*out_lex = lex;
return S3_SUCCESS;
}
