int
s2_write_dhmm(float32 ***tmat,
float32 ***mixw,
model_def_t *mdef,
const char *dir)
{
acmod_set_t *acmod_set;
model_def_entry_t *defn;
uint32 b, n_state, i, j, err;
uint32 n_acmod;
float32 ***omixw = NULL;
err = 0;
acmod_set = mdef->acmod_set;
n_acmod = acmod_set_n_acmod(acmod_set);
for (i = 0; i < n_acmod; i++) {
defn = &mdef->defn[i];
b = (uint32)acmod_set_base_phone(acmod_set, (acmod_id_t)i);
if (omixw) ckd_free((void *)omixw);
n_state = defn->n_state;
omixw = (float32 ***)ckd_calloc(n_state, sizeof(float32 **));
for (j = 0; j < n_state-1; j++) {
omixw[j] = mixw[defn->state[j]];
}
if (put_dhmm(tmat[b],
omixw,
dir,
acmod_set_id2s2name(acmod_set, (acmod_id_t)i)) != S3_SUCCESS)
err = 1;
}
if (omixw) ckd_free((void *)omixw);
if (!err) {
return S3_SUCCESS;
}
else {
return S3_ERROR;
}
}
int32
model_def_write(model_def_t *mdef,
const char *fn)
{
FILE *fp;
uint32 n_ci;
uint32 n_acmod;
acmod_set_t *acmod_set;
const char **attrib;
acmod_id_t b;
acmod_id_t l;
acmod_id_t r;
word_posn_t wp;
uint32 p;
char *wp2c = WORD_POSN_CHAR_MAP;
uint32 i;
fp = fopen(fn, "w");
if (fp == NULL) {
E_ERROR_SYSTEM("Unable to open %s for writing", fn);
return S3_ERROR;
}
acmod_set = mdef->acmod_set;
fprintf(fp, "%s\n", MODEL_DEF_VERSION);
n_ci = acmod_set_n_ci(acmod_set);
fprintf(fp, "%u n_base\n", n_ci);
fprintf(fp, "%u n_tri\n", acmod_set_n_multi(acmod_set));
fprintf(fp, "%u n_state_map\n", mdef->n_total_state);
fprintf(fp, "%u n_tied_state\n", mdef->n_tied_state);
fprintf(fp, "%u n_tied_ci_state\n", mdef->n_tied_ci_state);
fprintf(fp, "%u n_tied_tmat\n", mdef->n_tied_tmat);
fprintf(fp, "#\n# Columns definitions\n");
fprintf(fp, "#%4s %3s %3s %1s %6s %4s %s\n",
"base", "lft", "rt", "p", "attrib", "tmat",
" ... state id's ...");
n_acmod = acmod_set_n_acmod(acmod_set);
for (p = 0; p < n_ci; p++) {
fprintf(fp, "%5s %3s %3s %1s",
acmod_set_id2name(acmod_set, p),
"-", "-", "-");
attrib = acmod_set_attrib(acmod_set, p);
if ((attrib == NULL) || (attrib[0] == NULL)) {
fprintf(fp, " %6s", "n/a");
}
else {
fprintf(fp, " %6s", attrib[0]);
for (i = 1; attrib[i]; i++) {
fprintf(fp, ",%s", attrib[i]);
}
}
fprintf(fp, " %4d", mdef->defn[p].tmat);
for (i = 0; i < mdef->defn[p].n_state; i++) {
if (mdef->defn[p].state[i] == NO_ID) {
fprintf(fp, " N");
}
else {
fprintf(fp, " %6u", mdef->defn[p].state[i]);
}
}
fprintf(fp, "\n");
}
for (; p < n_acmod; p++) {
acmod_set_id2tri(acmod_set,
&b, &l, &r, &wp,
p);
fprintf(fp, "%5s %3s %3s %c",
acmod_set_id2name(acmod_set, b),
acmod_set_id2name(acmod_set, l),
acmod_set_id2name(acmod_set, r),
wp2c[(uint32)wp]);
attrib = acmod_set_attrib(acmod_set, p);
if ((attrib == NULL) || (attrib[0] == NULL)) {
fprintf(fp, " %6s", "n/a");
}
else {
fprintf(fp, " %6s", attrib[0]);
for (i = 1; attrib[i]; i++) {
fprintf(fp, ",%s", attrib[i]);
}
}
fprintf(fp, " %4d", mdef->defn[p].tmat);
for (i = 0; i < mdef->defn[p].n_state; i++) {
if (mdef->defn[p].state[i] == NO_ID) {
fprintf(fp, " N");
}
else {
fprintf(fp, " %6u", mdef->defn[p].state[i]);
}
}
fprintf(fp, "\n");
}
fclose(fp);
return S3_SUCCESS;
}
int
main(int argc, char *argv[])
{
model_def_t *imdef;
model_def_t *omdef;
pset_t *pset;
uint32 n_pset;
dtree_t ***tree;
uint32 n_seno;
uint32 n_ci;
uint32 n_acmod;
uint32 p;
uint32 s;
model_def_entry_t *idefn, *odefn;
acmod_id_t b, l, r;
word_posn_t wp;
int allphones;
parse_cmd_ln(argc, argv);
if (init(&imdef, &pset, &n_pset, &tree, &n_seno) != S3_SUCCESS)
return 1;
omdef = (model_def_t *)ckd_calloc(1, sizeof(model_def_t));
omdef->acmod_set = imdef->acmod_set; /* same set of acoustic models */
omdef->n_total_state = imdef->n_total_state;
omdef->n_tied_ci_state = imdef->n_tied_ci_state;
omdef->n_tied_state = imdef->n_tied_ci_state + n_seno;
omdef->n_tied_tmat = imdef->n_tied_tmat;
omdef->defn = (model_def_entry_t *)ckd_calloc(imdef->n_defn,
sizeof(model_def_entry_t));
/*
* Define the context-independent models
*/
n_ci = acmod_set_n_ci(imdef->acmod_set);
for (p = 0; p < n_ci; p++) {
idefn = &imdef->defn[p];
odefn = &omdef->defn[p];
odefn->p = idefn->p;
odefn->tmat = idefn->tmat;
odefn->state = ckd_calloc(idefn->n_state, sizeof(uint32));
odefn->n_state = idefn->n_state;
for (s = 0; s < idefn->n_state; s++) {
if (idefn->state[s] == NO_ID)
odefn->state[s] = NO_ID;
else {
odefn->state[s] = idefn->state[s];
}
}
}
/*
* Define the rest of the models
*/
allphones = cmd_ln_int32("-allphones");
n_acmod = acmod_set_n_acmod(omdef->acmod_set);
for (; p < n_acmod; p++) {
b = acmod_set_base_phone(omdef->acmod_set, p);
assert(p != b);
idefn = &imdef->defn[p];
odefn = &omdef->defn[p];
odefn->p = idefn->p;
odefn->tmat = idefn->tmat;
odefn->state = ckd_calloc(idefn->n_state, sizeof(uint32));
odefn->n_state = idefn->n_state;
for (s = 0; s < idefn->n_state; s++) {
if (idefn->state[s] == NO_ID)
/* Non-emitting state */
odefn->state[s] = NO_ID;
else {
uint32 bb;
/* emitting state: find the tied state */
acmod_set_id2tri(omdef->acmod_set,
&b, &l, &r, &wp,
p);
#ifdef HORRIBLY_VERBOSE
fprintf(stderr, "%s %u ",
acmod_set_id2name(omdef->acmod_set, p), s);
#endif
bb = allphones ? 0 : b;
odefn->state[s] = tied_state(&tree[bb][s]->node[0],
b, l, r, wp,
pset);
#ifdef HORRIBLY_VERBOSE
fprintf(stderr, "\t-> %u\n", odefn->state[s]);
fprintf(stderr, "\n");
#endif
}
}
}
if (model_def_write(omdef, cmd_ln_str("-omoddeffn")) != S3_SUCCESS) {
return 1;
}
return 0;
}
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;
uint32 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)) {
fprintf(stderr, " cnt[%u]", seq_no);
fflush(stderr);
}
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;
}
