int
main(int argc, char *argv[])
{
bitvec_t *bv;
int i, j;
clock_t c;
TEST_ASSERT(bv = bitvec_alloc(199));
bitvec_set(bv,198);
bitvec_set(bv,0);
bitvec_set(bv,42);
bitvec_set(bv,43);
bitvec_set(bv,44);
TEST_ASSERT(bitvec_is_set(bv,198));
TEST_ASSERT(bitvec_is_set(bv,0));
TEST_ASSERT(bitvec_is_set(bv,42));
TEST_ASSERT(bitvec_is_set(bv,43));
TEST_ASSERT(bitvec_is_set(bv,44));
TEST_EQUAL(5, bitvec_count_set(bv, 199));
bitvec_clear(bv, 43);
TEST_EQUAL(0, bitvec_is_set(bv,43));
c = clock();
for (j = 0; j < 1000000; ++j)
bitvec_count_set(bv, 199);
c = clock() - c;
printf("1000000 * 199 bitvec_count_set in %.2f sec\n",
(double)c / CLOCKS_PER_SEC);
bitvec_free(bv);
bv = bitvec_alloc(1314);
c = clock();
for (j = 0; j < 50000; ++j)
for (i = 0; i < 1314; ++i)
bitvec_set(bv, i);
c = clock() - c;
printf("50000 * 1314 bitvec_set in %.2f sec\n",
(double)c / CLOCKS_PER_SEC);
bitvec_free(bv);
/* Test realloc */
bv = bitvec_alloc(13);
for (i = 1; i < 13; i+=2)
bitvec_set(bv, i);
printf("Bits set %d\n", bitvec_count_set(bv, 13));
TEST_EQUAL(6, bitvec_count_set(bv, 13));
bv = bitvec_realloc(bv, 13, 2000);
for (i = 0; i < 2000; i++) {
/* printf("%d %d\n", i, bitvec_is_set(bv, i) != 0); */
}
printf("Bits set after realloc %d\n", bitvec_count_set(bv, 2000));
TEST_EQUAL(6, bitvec_count_set(bv, 2000));
bitvec_free(bv);
return 0;
}
int
fsg_model_add_alt(fsg_model_t * fsg, char const *baseword,
char const *altword)
{
int i, basewid, altwid;
int ntrans;
/* FIXME: This will get slow, eventually... */
for (basewid = 0; basewid < fsg->n_word; ++basewid)
if (0 == strcmp(fsg->vocab[basewid], baseword))
break;
if (basewid == fsg->n_word) {
E_ERROR("Base word %s not present in FSG vocabulary!\n", baseword);
return -1;
}
altwid = fsg_model_word_add(fsg, altword);
if (fsg->altwords == NULL)
fsg->altwords = bitvec_alloc(fsg->n_word_alloc);
bitvec_set(fsg->altwords, altwid);
E_DEBUG(2,("Adding alternate word transitions (%s,%s) to FSG\n",
baseword, altword));
/* Look for all transitions involving baseword and duplicate them. */
/* FIXME: This will also get slow, eventually... */
ntrans = 0;
for (i = 0; i < fsg->n_state; ++i) {
hash_iter_t *itor;
if (fsg->trans[i].trans == NULL)
continue;
for (itor = hash_table_iter(fsg->trans[i].trans); itor;
itor = hash_table_iter_next(itor)) {
glist_t trans;
gnode_t *gn;
trans = hash_entry_val(itor->ent);
for (gn = trans; gn; gn = gnode_next(gn)) {
fsg_link_t *fl = gnode_ptr(gn);
if (fl->wid == basewid) {
fsg_link_t *link;
/* Create transition object */
link = listelem_malloc(fsg->link_alloc);
link->from_state = fl->from_state;
link->to_state = fl->to_state;
link->logs2prob = fl->logs2prob; /* FIXME!!!??? */
link->wid = altwid;
trans =
glist_add_ptr(trans, (void *) link);
++ntrans;
}
}
hash_entry_val(itor->ent) = trans;
}
}
E_DEBUG(2,("Added %d alternate word transitions\n", ntrans));
return ntrans;
}
int
fsg_model_add_silence(fsg_model_t * fsg, char const *silword,
int state, float32 silprob)
{
int32 logsilp;
int n_trans, silwid, src;
E_INFO("Adding silence transitions for %s to FSG\n", silword);
silwid = fsg_model_word_add(fsg, silword);
logsilp = (int32) (logmath_log(fsg->lmath, silprob) * fsg->lw);
if (fsg->silwords == NULL)
fsg->silwords = bitvec_alloc(fsg->n_word_alloc);
bitvec_set(fsg->silwords, silwid);
n_trans = 0;
if (state == -1) {
for (src = 0; src < fsg->n_state; src++) {
fsg_model_trans_add(fsg, src, src, logsilp, silwid);
++n_trans;
}
}
else {
fsg_model_trans_add(fsg, state, state, logsilp, silwid);
++n_trans;
}
E_INFO("Added %d silence word transitions\n", n_trans);
return n_trans;
}
acmod_t *
acmod_init(cmd_ln_t *config, logmath_t *lmath, featbuf_t *fb)
{
acmod_t *acmod;
acmod = ckd_calloc(1, sizeof(*acmod));
acmod->refcount = 1;
acmod->config = cmd_ln_retain(config);
acmod->lmath = logmath_retain(lmath);
acmod->fb = featbuf_retain(fb);
acmod->fcb = featbuf_get_fcb(acmod->fb);
/* Load acoustic model parameters. */
if (acmod_init_am(acmod) < 0)
goto error_out;
/* Senone computation stuff. */
acmod->senone_scores = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_scores));
acmod->senone_active_vec = bitvec_alloc(bin_mdef_n_sen(acmod->mdef));
acmod->senone_active = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_active));
acmod->log_zero = logmath_get_zero(acmod->lmath);
acmod->compallsen = cmd_ln_boolean_r(config, "-compallsen");
acmod->feat_buf = feat_array_alloc(acmod->fcb, 1);
return acmod;
error_out:
acmod_free(acmod);
return NULL;
}
acmod_t *
acmod_copy(acmod_t *other)
{
acmod_t *acmod;
acmod = ckd_calloc(1, sizeof(*acmod));
acmod->refcount = 1;
acmod->config = cmd_ln_retain(other->config);
acmod->lmath = logmath_retain(other->lmath);
acmod->mdef = bin_mdef_retain(other->mdef);
acmod->tmat = tmat_retain(other->tmat);
acmod->mgau = ps_mgau_copy(other->mgau);
acmod->fb = featbuf_retain(other->fb);
acmod->fcb = other->fcb; /* Implicitly retained with fb, I think */
/* Senone computation stuff. */
acmod->senone_scores = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_scores));
acmod->senone_active_vec = bitvec_alloc(bin_mdef_n_sen(acmod->mdef));
acmod->senone_active = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_active));
acmod->log_zero = logmath_get_zero(acmod->lmath);
acmod->compallsen = cmd_ln_boolean_r(acmod->config, "-compallsen");
acmod->feat_buf = feat_array_alloc(acmod->fcb, 1);
return acmod;
}
int
ngram_fwdflat_reinit(ngram_search_t *ngs)
{
/* Reallocate things that depend on the number of words. */
int n_words;
ckd_free(ngs->fwdflat_wordlist);
ckd_free(ngs->expand_word_list);
bitvec_free(ngs->expand_word_flag);
n_words = ps_search_n_words(ngs);
ngs->fwdflat_wordlist = ckd_calloc(n_words + 1, sizeof(*ngs->fwdflat_wordlist));
ngs->expand_word_flag = bitvec_alloc(n_words);
ngs->expand_word_list = ckd_calloc(n_words + 1, sizeof(*ngs->expand_word_list));
/* No tree-search; take care of the expansion list and single phone words. */
if (!ngs->fwdtree) {
/* Free single-phone words. */
ngram_fwdflat_free_1ph(ngs);
/* Reallocate word_chan. */
ckd_free(ngs->word_chan);
ngs->word_chan = ckd_calloc(dict_size(ps_search_dict(ngs)),
sizeof(*ngs->word_chan));
/* Rebuild full expansion list from LM words. */
ngram_fwdflat_expand_all(ngs);
/* Allocate single phone words. */
ngram_fwdflat_allocate_1ph(ngs);
}
/* Otherwise there is nothing to do since the wordlist is
* generated anew every utterance. */
return 0;
}
int main(int argc, char **argv) {
bitvec_t *b = NULL;
assert(!bitvec_alloc(&b, 1));
bitvec_set(b, 0);
assert(b->storage[0] == 0x1);
return 0;
}
int gprs_rlcmac_paging_request(uint8_t *ptmsi, uint16_t ptmsi_len,
const char *imsi)
{
LOGP(DRLCMAC, LOGL_NOTICE, "TX: [PCU -> BTS] Paging Request (CCCH)\n");
bitvec *paging_request = bitvec_alloc(23);
bitvec_unhex(paging_request, "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b");
int plen = Encoding::write_paging_request(paging_request, ptmsi, ptmsi_len);
pcu_l1if_tx_pch(paging_request, plen, (char *)imsi);
bitvec_free(paging_request);
return 0;
}
static void parse_xmaxc_frame(uint8_t *frame, uint64_t xmaxc_res[4])
{
unsigned int field_index, len;
struct bitvec *frame_bitvec = bitvec_alloc(GSM_FR_BYTES, NULL);
OSMO_ASSERT(frame_bitvec);
len = bitvec_unpack(frame_bitvec, frame);
OSMO_ASSERT(len == GSM_FR_BYTES);
field_index = GSM610_RTP_XMAXC00;
xmaxc_res[0] = bitvec_read_field(frame_bitvec, &field_index, GSM610_XMAXC_LEN);
field_index = GSM610_RTP_XMAXC10;
xmaxc_res[1] = bitvec_read_field(frame_bitvec, &field_index, GSM610_XMAXC_LEN);
field_index = GSM610_RTP_XMAXC20;
xmaxc_res[2] = bitvec_read_field(frame_bitvec, &field_index, GSM610_XMAXC_LEN);
field_index = GSM610_RTP_XMAXC30;
xmaxc_res[3] = bitvec_read_field(frame_bitvec, &field_index, GSM610_XMAXC_LEN);
bitvec_free(frame_bitvec);
}
void
ngram_fwdflat_init(ngram_search_t *ngs)
{
int n_words;
n_words = ps_search_n_words(ngs);
ngs->fwdflat_wordlist = ckd_calloc(n_words + 1, sizeof(*ngs->fwdflat_wordlist));
ngs->expand_word_flag = bitvec_alloc(n_words);
ngs->expand_word_list = ckd_calloc(n_words + 1, sizeof(*ngs->expand_word_list));
ngs->frm_wordlist = ckd_calloc(ngs->n_frame_alloc, sizeof(*ngs->frm_wordlist));
ngs->min_ef_width = cmd_ln_int32_r(ps_search_config(ngs), "-fwdflatefwid");
ngs->max_sf_win = cmd_ln_int32_r(ps_search_config(ngs), "-fwdflatsfwin");
E_INFO("fwdflat: min_ef_width = %d, max_sf_win = %d\n",
ngs->min_ef_width, ngs->max_sf_win);
/* No tree-search; pre-build the expansion list, including all LM words. */
if (!ngs->fwdtree) {
/* Build full expansion list from LM words. */
ngram_fwdflat_expand_all(ngs);
/* Allocate single phone words. */
ngram_fwdflat_allocate_1ph(ngs);
}
}
subvq_t *subvq_init (char *file)
{
FILE *fp;
char line[16384];
int32 n_sv;
int32 s, k, n, r, c;
char *strp;
subvq_t *vq;
E_INFO("Loading Mixture Gaussian sub-VQ file '%s'\n", file);
vq = (subvq_t *) ckd_calloc (1, sizeof(subvq_t));
fp = myfopen(file, "r");
/* 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;
}
n_sv = vq->n_sv;
vq->svsize = (int32 *) ckd_calloc (n_sv, sizeof(int32));
vq->featdim = (int32 **) ckd_calloc (n_sv, sizeof(int32 *));
vq->mean = (float32 ***) ckd_calloc (n_sv, sizeof(float32 **));
vq->var = (float32 ***) ckd_calloc (n_sv, sizeof(float32 **));
vq->map = (int32 ***) ckd_calloc_3d (vq->origsize.r, vq->origsize.c, n_sv, sizeof(int32));
vq->cb_invalid = bitvec_alloc (vq->origsize.r);
/* 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, &(vq->svsize[s]), &n) != 2) ||
(k != s))
E_FATAL("Error reading length(subvector %d)\n", s);
vq->mean[s] = (float32 **) ckd_calloc_2d (vq->vqsize, vq->svsize[s], sizeof(float32));
vq->var[s] = (float32 **) ckd_calloc_2d (vq->vqsize, vq->svsize[s], sizeof(float32));
vq->featdim[s] = (int32 *) ckd_calloc (vq->svsize[s], sizeof(int32));
for (strp = line+n, c = 0; c < vq->svsize[s]; 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;
}
}
/* 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 < n_sv; s++) {
E_INFO("Feature dims(%d): ", s);
for (c = 0; c < vq->svsize[s]; c++)
printf (" %2d", vq->featdim[s][c]);
printf (" (%d)\n", vq->svsize[s]);
}
/* Read VQ codebooks and maps for each subvector */
for (s = 0; s < n_sv; s++) {
E_INFO("Reading subvq %d\n", s);
E_INFO("Reading codebook\n");
if ((fgets (line, sizeof(line), fp) == NULL) ||
(sscanf (line, "Codebook %d", &k) != 1) || (k != s))
E_FATAL("Error reading 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);
for (strp = line, c = 0; c < vq->svsize[s]; c++) {
if (sscanf (strp, "%f %f%n", &(vq->mean[s][r][c]), &(vq->var[s][r][c]), &k) != 2)
E_FATAL("Error reading row(%d) col(%d)\n", r, c);
strp += k;
}
}
#if 0
E_INFO("Sanity check: mean[0,%d]:\n", vq->vqsize-1);
vector_print (stdout, vq->mean[s][0], vq->svsize[s]);
vector_print (stdout, vq->mean[s][vq->vqsize-1], vq->svsize[s]);
E_INFO("Sanity check: var[0,%d]:\n", vq->vqsize-1);
vector_print (stdout, vq->var[s][0], vq->svsize[s]);
vector_print (stdout, vq->var[s][vq->vqsize-1], vq->svsize[s]);
#endif
E_INFO("Reading map\n");
if ((fgets (line, sizeof(line), fp) == NULL) ||
(sscanf (line, "Map %d", &k) != 1) || (k != s))
E_FATAL("Error reading 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);
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;
}
}
#if 0
E_INFO("Sanity check: map[0][0]:\n");
for (c = 0; c < vq->origsize.c; c++)
printf (" %d", vq->map[0][c][s]);
printf ("\n");
#endif
fflush (stdout);
}
if ((fscanf (fp, "%s", line) != 1) || (strcmp (line, "End") != 0))
E_FATAL("Error reading 'End' token\n");
fclose (fp);
subvq_ivar_idet_precompute (vq, 0.0001 /* varfloor */);
#if 0
E_INFO("Sanity check: var[*,0]:\n");
for (s = 0; s < n_sv; s++)
vector_print (stdout, vq->var[s][0], vq->svsize[s]);
#endif
/* Replace invalid entries in map with duplicate of a valid entry, if possible */
for (r = 0; r < vq->origsize.r; r++) {
k = -1;
for (c = 0; c < vq->origsize.c; c++) {
if (vq->map[r][c][0] < 0) {
/* All ought to be < 0 */
for (s = 1; s < vq->n_sv; s++) {
if (vq->map[r][c][s] >= 0)
E_FATAL("Partially undefined map[%d][%d]\n", r, c);
}
} else {
/* All ought to be >= 0 */
for (s = 1; s < vq->n_sv; s++) {
if (vq->map[r][c][s] < 0)
E_FATAL("Partially undefined map[%d][%d]\n", r, c);
}
k = c; /* A valid codeword found; remember it */
}
}
if (k >= 0) {
/* Copy k into invalid rows */
for (c = 0; c < vq->origsize.c; c++) {
if (vq->map[r][c][0] < 0) {
for (s = 0; s < vq->n_sv; s++)
vq->map[r][c][s] = vq->map[r][k][s];
}
}
bitvec_clear (vq->cb_invalid, r);
} else
bitvec_set (vq->cb_invalid, r);
}
return vq;
}
int
gs_display(char *file, gs_t * gs)
{
int32 i;
int32 code_id;
int32 m_id, s_id, c_id;
float32 tmp;
bitvec_t *bv;
E_INFO("Reading gaussian selector map: %s\n", file);
gs = (gs_t *) ckd_calloc(1, sizeof(gs_t));
if ((gs->fp = fopen(file, "rb")) == NULL)
E_FATAL("fopen(%s,rb) failed\n", file);
gs->n_mgau = gs_fread_int32(gs);
E_INFO("The number of mixtures of gaussian: %d\n", gs->n_mgau);
gs->n_feat = gs_fread_int32(gs);
E_INFO("The number of features stream: %d\n", gs->n_feat);
gs->n_density = gs_fread_int32(gs);
E_INFO("The number of density: %d\n", gs->n_density);
gs->n_code = gs_fread_int32(gs);
E_INFO("The number of code word: %d\n", gs->n_code);
gs->n_featlen = gs_fread_int32(gs);
E_INFO("The feature length: %d\n", gs->n_featlen);
gs->n_mbyte = bitvec_size(gs->n_density) * sizeof(bitvec_t);
E_INFO("The number of byte to read: %d\n", gs->n_mbyte);
/* allocate the bit vector here */
bv = bitvec_alloc(gs->n_density);
/* for(i=0;i<gs->n_code;i++) */
for (code_id = 0; code_id < gs->n_code; code_id++) {
printf("Code idx: %d\n", code_id);
for (c_id = 0; c_id < gs->n_featlen; c_id++) {
tmp = gs_fread_float32(gs);
printf("%f ", tmp);
}
printf("\n");
for (m_id = 0; m_id < gs->n_mgau; m_id++) {
for (s_id = 0; s_id < gs->n_feat; s_id++) {
/*The writer currently doesn't support the byte order */
gs_fread_bitvec_t(bv, gs);
printf("%d %d ", m_id, s_id);
for (i = 0; i < gs->n_density; i++) {
if (bitvec_is_set(bv, i)) {
printf("%d ", i);
}
}
printf("\n");
}
}
}
printf("\n");
/* bitvec_free(bv); */
/* destroy the bit vector here */
gs_free(gs);
return 1;
}
gs_t *
gs_read(const char *file, logmath_t *logmath)
{
int32 code_id;
int32 m_id, s_id, c_id;
bitvec_t *bv;
gs_t *gs;
E_INFO("Reading gaussian selector map: %s\n", file);
gs = (gs_t *) ckd_calloc(1, sizeof(gs_t));
if (gs == NULL)
E_FATAL("Cannot allocate gs\n");
if ((gs->fp = fopen(file, "rb")) == NULL)
E_FATAL("gs_read(%s,rb) failed\n", file);
gs->logmath = logmath;
gs->n_mgau = gs_fread_int32(gs);
E_INFO("The number of mixtures of gaussian: %d\n", gs->n_mgau);
gs->n_feat = gs_fread_int32(gs);
E_INFO("The number of features stream: %d\n", gs->n_feat);
gs->n_density = gs_fread_int32(gs);
E_INFO("The number of density: %d\n", gs->n_density);
gs->n_code = gs_fread_int32(gs);
E_INFO("The number of code word: %d\n", gs->n_code);
gs->n_featlen = gs_fread_int32(gs);
E_INFO("The feature length: %d\n", gs->n_featlen);
gs->n_mbyte = bitvec_size(gs->n_density) * sizeof(bitvec_t);
E_INFO("The number of byte to read: %d\n", gs->n_mbyte);
/* allocate the bit vector here */
bv = bitvec_alloc(gs->n_density);
/* allocate memory for the data structure */
/* n_code * n_featlen */
gs->codeword =
(float32 **) ckd_calloc_2d(gs->n_code, gs->n_featlen,
sizeof(float32));
/* n_mgau * n_feat * n_code */
/*Hack ! assume feature stream to be only 1 */
gs->codemap =
(uint32 ***) ckd_calloc_3d(gs->n_mgau, gs->n_feat, gs->n_code,
sizeof(uint32));
gs->mgau_sl = (int32 *) ckd_calloc(gs->n_density + 1, sizeof(int32));
for (code_id = 0; code_id < gs->n_code; code_id++) {
for (c_id = 0; c_id < gs->n_featlen; c_id++) {
gs->codeword[code_id][c_id] = gs_fread_float32(gs);
}
for (m_id = 0; m_id < gs->n_mgau; m_id++) {
for (s_id = 0; s_id < gs->n_feat; s_id++) {
/*The writer currently doesn't support the byte order */
gs_fread_bitvec_t(bv, gs);
gs->codemap[m_id][s_id][code_id] = *bv;
}
}
}
return gs;
}
float64 vector_vqgen (float32 **data, int32 rows, int32 cols, int32 vqrows,
float64 epsilon, int32 maxiter,
float32 **mean, int32 *map)
{
int32 i, j, r, it;
static uint32 seed = 1;
float64 sqerr, prev_sqerr=0, t;
bitvec_t sel;
int32 *count;
float32 *gmean;
ptmr_t tm;
assert ((rows >= vqrows) && (maxiter >= 0) && (epsilon > 0.0));
sel = bitvec_alloc (rows);
ptmr_init (&tm);
ptmr_start (&tm);
/* Pick a random initial set of centroids */
#ifndef WIN32 /* RAH */
srandom (seed);
seed ^= random();
#else /* RAH */
srand ((unsigned) time(NULL)); /* RAH */
#endif
for (i = 0; i < vqrows; i++) {
/* Find r = a random, previously unselected row from the input */
#ifndef WIN32 /* RAH */
r = (random() & (int32)0x7fffffff) % rows;
#else /* RAH */
r = (rand() & (int32)0x7fffffff) % rows; /* RAH */
#endif /* RAH */
while (bitvec_is_set (sel, r)) { /* BUG: possible infinite loop!! */
if (++r >= rows)
r = 0;
}
bitvec_set (sel, r);
memcpy ((void *)(mean[i]), (void *)(data[r]), cols * sizeof(float32));
/* BUG: What if two randomly selected rows are identical in content?? */
}
bitvec_free (sel);
count = (int32 *) ckd_calloc (vqrows, sizeof(int32));
/* In k-means, unmapped means in any iteration are a problem. Replace them with gmean */
gmean = (float32 *) ckd_calloc (cols, sizeof(float32));
vector_mean (gmean, mean, vqrows, cols);
for (it = 0;; it++) { /* Iterations of k-means algorithm */
/* Find the current data->mean mappings (labels) */
sqerr = 0.0;
for (i = 0; i < rows; i++) {
map[i] = vector_vqlabel (data[i], mean, vqrows, cols, &t);
sqerr += t;
}
ptmr_stop(&tm);
if (it == 0)
E_INFO("Iter %4d: %.1fs CPU; sqerr= %e\n", it, tm.t_cpu, sqerr);
else
E_INFO("Iter %4d: %.1fs CPU; sqerr= %e; delta= %e\n",
it, tm.t_cpu, sqerr, (prev_sqerr-sqerr)/prev_sqerr);
/* Check if exit condition satisfied */
if ((sqerr == 0.0) || (it >= maxiter-1) ||
((it > 0) && ( ((prev_sqerr - sqerr) / prev_sqerr) < epsilon )) )
break;
prev_sqerr = sqerr;
ptmr_start(&tm);
/* Update (reestimate) means */
for (i = 0; i < vqrows; i++) {
for (j = 0; j < cols; j++)
mean[i][j] = 0.0;
count[i] = 0;
}
for (i = 0; i < rows; i++) {
vector_accum (mean[map[i]], data[i], cols);
count[map[i]]++;
}
for (i = 0; i < vqrows; i++) {
if (count[i] > 1) {
t = 1.0 / (float64)(count[i]);
for (j = 0; j < cols; j++)
/* mean[i][j] *= t; */ /* RAH, compiler was complaining about this, */
mean[i][j] = (float32) ((float64) mean[i][j] * (float64) t); /* */
} else if (count[i] == 0) {
E_ERROR("Iter %d: mean[%d] unmapped\n", it, i);
memcpy (mean[i], gmean, cols * sizeof(float32));
}
}
}
ckd_free (count);
ckd_free (gmean);
return sqerr;
}
/*ARCHAN, to allow backward compatibility -lm, -lmctlfn coexists. This makes the current implmentation more complicated than necessary. */
void kb_init (kb_t *kb)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
lm_t *lm;
lmset_t *lmset;
s3cipid_t sil, ci;
s3wid_t w;
int32 i, n, n_lc;
wordprob_t *wp;
s3cipid_t *lc;
bitvec_t lc_active;
char *str;
int32 cisencnt;
int32 j;
/* Initialize the kb structure to zero, just in case */
memset(kb, 0, sizeof(*kb));
kb->kbcore = NULL;
kb->kbcore = kbcore_init (cmd_ln_float32 ("-logbase"),
cmd_ln_str("-feat"),
cmd_ln_str("-cmn"),
cmd_ln_str("-varnorm"),
cmd_ln_str("-agc"),
cmd_ln_str("-mdef"),
cmd_ln_str("-dict"),
cmd_ln_str("-fdict"),
"", /* Hack!! Hardwired constant
for -compsep argument */
cmd_ln_str("-lm"),
cmd_ln_str("-lmctlfn"),
cmd_ln_str("-lmdumpdir"),
cmd_ln_str("-fillpen"),
cmd_ln_str("-senmgau"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_float32("-uw"),
cmd_ln_str("-mean"),
cmd_ln_str("-var"),
cmd_ln_float32("-varfloor"),
cmd_ln_str("-mixw"),
cmd_ln_float32("-mixwfloor"),
cmd_ln_str("-subvq"),
cmd_ln_str("-gs"),
cmd_ln_str("-tmat"),
cmd_ln_float32("-tmatfloor"));
if(kb->kbcore==NULL){
E_FATAL("Initialization of kb failed\n");
}
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
lm = kbcore_lm(kbcore);
lmset=kbcore_lmset(kbcore);
d2p = kbcore_dict2pid(kbcore);
if (NOT_S3WID(dict_startwid(dict)) || NOT_S3WID(dict_finishwid(dict)))
E_FATAL("%s or %s not in dictionary\n", S3_START_WORD, S3_FINISH_WORD);
if(lmset){
for(i=0;i<kbcore_nlm(kbcore);i++){
if (NOT_S3LMWID(lm_startwid(lmset[i].lm)) || NOT_S3LMWID(lm_finishwid(lmset[i].lm)))
E_FATAL("%s or %s not in LM %s\n", S3_START_WORD, S3_FINISH_WORD,lmset[i].name);
}
}else if(lm){
if (NOT_S3LMWID(lm_startwid(lm)) || NOT_S3LMWID(lm_finishwid(lm)))
E_FATAL("%s or %s not in LM\n", S3_START_WORD, S3_FINISH_WORD);
}
/* Check that HMM topology restrictions are not violated */
if (tmat_chk_1skip (kbcore->tmat) < 0)
E_FATAL("Tmat contains arcs skipping more than 1 state\n");
/*
* Unlink <s> and </s> between dictionary and LM, to prevent their
* recognition. They are merely dummy words (anchors) at the beginning
* and end of each utterance.
*/
if(lmset){
for(i=0;i<kbcore_nlm(kbcore);i++){
lm_lmwid2dictwid(lmset[i].lm, lm_startwid(lmset[i].lm)) = BAD_S3WID;
lm_lmwid2dictwid(lmset[i].lm, lm_finishwid(lmset[i].lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
lmset[i].lm->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
lmset[i].lm->dict2lmwid[w] = BAD_S3LMWID;
}
}else if(lm){ /* No LM is set at this point*/
lm_lmwid2dictwid(lm, lm_startwid(lm)) = BAD_S3WID;
lm_lmwid2dictwid(lm, lm_finishwid(lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
}
sil = mdef_silphone (kbcore_mdef (kbcore));
if (NOT_S3CIPID(sil))
E_FATAL("Silence phone '%s' not in mdef\n", S3_SILENCE_CIPHONE);
kb->sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->rec_sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->ssid_active = (int32 *) ckd_calloc (mdef_n_sseq(mdef), sizeof(int32));
kb->comssid_active = (int32 *) ckd_calloc (dict2pid_n_comsseq(d2p), sizeof(int32));
/* Build set of all possible left contexts */
lc = (s3cipid_t *) ckd_calloc (mdef_n_ciphone(mdef) + 1, sizeof(s3cipid_t));
lc_active = bitvec_alloc (mdef_n_ciphone (mdef));
for (w = 0; w < dict_size (dict); w++) {
ci = dict_pron (dict, w, dict_pronlen(dict, w) - 1);
if (! mdef_is_fillerphone (mdef, (int)ci))
bitvec_set (lc_active, ci);
}
ci = mdef_silphone(mdef);
bitvec_set (lc_active, ci);
for (ci = 0, n_lc = 0; ci < mdef_n_ciphone(mdef); ci++) {
if (bitvec_is_set (lc_active, ci))
lc[n_lc++] = ci;
}
lc[n_lc] = BAD_S3CIPID;
E_INFO("Building lextrees\n");
/* Get the number of lexical tree*/
kb->n_lextree = cmd_ln_int32 ("-Nlextree");
if (kb->n_lextree < 1) {
E_ERROR("No. of ugtrees specified: %d; will instantiate 1 ugtree\n",
kb->n_lextree);
kb->n_lextree = 1;
}
/* ARCHAN: This code was rearranged in s3.4 implementation of dynamic LM */
/* Build active word list */
wp = (wordprob_t *) ckd_calloc (dict_size(dict), sizeof(wordprob_t));
if(lmset){
kb->ugtreeMulti = (lextree_t **) ckd_calloc (kbcore_nlm(kbcore)*kb->n_lextree, sizeof(lextree_t *));
/* Just allocate pointers*/
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for(i=0;i<kbcore_nlm(kbcore);i++){
E_INFO("Creating Unigram Table for lm %d name %s\n",i,lmset[i].name);
n=0;
for(j=0;j<dict_size(dict);j++){ /*try to be very careful again */
wp[j].wid=-1;
wp[j].prob=-1;
}
n = lm_ug_wordprob (lmset[i].lm, dict,MAX_NEG_INT32, wp);
E_INFO("Size of word table after unigram + words in class: %d.\n",n);
if (n < 1)
E_FATAL("%d active words in %s\n", n,lmset[i].name);
n = wid_wordprob2alt(dict,wp,n);
E_INFO("Size of word table after adding alternative prons: %d.\n",n);
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
for (j = 0; j < kb->n_lextree; j++) {
kb->ugtreeMulti[i*kb->n_lextree+j] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtreeMulti[i*kb->n_lextree+j]) = 0;
E_INFO("Lextrees (%d) for lm %d name %s, %d nodes(ug)\n",
kb->n_lextree, i, lmset[i].name,lextree_n_node(kb->ugtreeMulti[i*kb->n_lextree+j]));
}
}
}else if (lm){
E_INFO("Creating Unigram Table\n");
n=0;
n = lm_ug_wordprob (lm, dict,MAX_NEG_INT32, wp);
E_INFO("Size of word table after unigram + words in class: %d\n",n);
if (n < 1)
E_FATAL("%d active words\n", n);
n = wid_wordprob2alt (dict, wp, n); /* Add alternative pronunciations */
/* Retain or remove unigram probs from lextree, depending on option */
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
/* Create the desired no. of unigram lextrees */
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for (i = 0; i < kb->n_lextree; i++) {
kb->ugtree[i] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtree[i]) = 0;
}
E_INFO("Lextrees(%d), %d nodes(ug)\n",
kb->n_lextree, lextree_n_node(kb->ugtree[0]));
}
/* Create filler lextrees */
/* ARCHAN : only one filler tree is supposed to be build even for dynamic LMs */
n = 0;
for (i = dict_filler_start(dict); i <= dict_filler_end(dict); i++) {
if (dict_filler_word(dict, i)) {
wp[n].wid = i;
wp[n].prob = fillpen (kbcore->fillpen, i);
n++;
}
}
kb->fillertree = (lextree_t **)ckd_calloc(kb->n_lextree,sizeof(lextree_t*));
for (i = 0; i < kb->n_lextree; i++) {
kb->fillertree[i] = lextree_build (kbcore, wp, n, NULL);
lextree_type (kb->fillertree[i]) = -1;
}
ckd_free ((void *) wp);
ckd_free ((void *) lc);
bitvec_free (lc_active);
E_INFO("Lextrees(%d), %d nodes(filler)\n",
kb->n_lextree,
lextree_n_node(kb->fillertree[0]));
if (cmd_ln_int32("-lextreedump")) {
if(lmset){
E_FATAL("Currently, doesn't support -lextreedump for multiple-LMs\n");
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "UGTREE %d\n", i);
lextree_dump (kb->ugtree[i], dict, stderr);
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "FILLERTREE %d\n", i);
lextree_dump (kb->fillertree[i], dict, stderr);
}
fflush (stderr);
}
kb->ascr = ascr_init (mgau_n_mgau(kbcore_mgau(kbcore)),
kbcore->dict2pid->n_comstate);
kb->beam = beam_init (cmd_ln_float64("-subvqbeam"),
cmd_ln_float64("-beam"),
cmd_ln_float64("-pbeam"),
cmd_ln_float64("-wbeam"));
E_INFO("Beam= %d, PBeam= %d, WBeam= %d, SVQBeam= %d\n",
kb->beam->hmm, kb->beam->ptrans, kb->beam->word, kb->beam->subvq);
/*Sections of optimization related parameters*/
kb->ds_ratio=cmd_ln_int32("-ds");
E_INFO("Down Sampling Ratio = %d\n",kb->ds_ratio);
kb->rec_bstcid=-1;
kb->skip_count=0;
kb->cond_ds=cmd_ln_int32("-cond_ds");
E_INFO("Conditional Down Sampling Parameter = %d\n",kb->cond_ds);
if(kb->cond_ds>0&&kb->kbcore->gs==NULL) E_FATAL("Conditional Down Sampling require the use of Gaussian Selection map\n");
kb->gs4gs=cmd_ln_int32("-gs4gs");
E_INFO("GS map would be used for Gaussian Selection? = %d\n",kb->gs4gs);
kb->svq4svq=cmd_ln_int32("-svq4svq");
E_INFO("SVQ would be used as Gaussian Score ?= %d\n",kb->svq4svq);
kb->ci_pbeam=-1*logs3(cmd_ln_float32("-ci_pbeam"));
E_INFO("CI phone beam to prune the number of parent CI phones in CI-base GMM Selection = %d\n",kb->ci_pbeam);
if(kb->ci_pbeam>10000000){
E_INFO("Virtually no CI phone beam is applied now. (ci_pbeam>1000000)\n");
}
kb->wend_beam=-1*logs3(cmd_ln_float32("-wend_beam"));
E_INFO("Word-end pruning beam: %d\n",kb->wend_beam);
kb->pl_window=cmd_ln_int32("-pl_window");
E_INFO("Phoneme look-ahead window size = %d\n",kb->pl_window);
kb->pl_window_start=0;
kb->pl_beam=logs3(cmd_ln_float32("-pl_beam"));
E_INFO("Phoneme look-ahead beam = %d\n",kb->pl_beam);
for(cisencnt=0;cisencnt==mdef->cd2cisen[cisencnt];cisencnt++)
;
kb->cache_ci_senscr=(int32**)ckd_calloc_2d(kb->pl_window,cisencnt,sizeof(int32));
kb->cache_best_list=(int32*)ckd_calloc(kb->pl_window,sizeof(int32));
kb->phn_heur_list=(int32*)ckd_calloc(mdef_n_ciphone (mdef),sizeof(int32));
if ((kb->feat = feat_array_alloc(kbcore_fcb(kbcore),S3_MAX_FRAMES)) == NULL)
E_FATAL("feat_array_alloc() failed\n");
kb->vithist = vithist_init(kbcore, kb->beam->word, cmd_ln_int32("-bghist"));
ptmr_init (&(kb->tm_sen));
ptmr_init (&(kb->tm_srch));
ptmr_init (&(kb->tm_ovrhd));
kb->tot_fr = 0;
kb->tot_sen_eval = 0.0;
kb->tot_gau_eval = 0.0;
kb->tot_hmm_eval = 0.0;
kb->tot_wd_exit = 0.0;
kb->hmm_hist_binsize = cmd_ln_int32("-hmmhistbinsize");
if(lmset)
n = ((kb->ugtreeMulti[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
else
n = ((kb->ugtree[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
n /= kb->hmm_hist_binsize;
kb->hmm_hist_bins = n+1;
kb->hmm_hist = (int32 *) ckd_calloc (n+1, sizeof(int32)); /* Really no need for +1 */
/* Open hypseg file if specified */
str = cmd_ln_str("-hypseg");
kb->matchsegfp = NULL;
if (str) {
#ifdef SPEC_CPU_WINDOWS
if ((kb->matchsegfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchsegfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
str = cmd_ln_str("-hyp");
kb->matchfp = NULL;
if (str) {
#ifdef SPEC_CPU_WINDOWS
if ((kb->matchfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
}
void kb_init (kb_t *kb)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
lm_t *lm;
s3cipid_t sil, ci;
s3wid_t w;
int32 i, n, n_lc;
wordprob_t *wp;
s3cipid_t *lc;
bitvec_t lc_active;
char *str;
/* Initialize the kb structure to zero, just in case */
memset(kb, 0, sizeof(*kb));
kb->kbcore = kbcore_init (cmd_ln_float32 ("-logbase"),
"1s_c_d_dd", /* Hack!! Hardwired constant
for -feat argument */
cmd_ln_str("-cmn"),
cmd_ln_str("-varnorm"),
cmd_ln_str("-agc"),
cmd_ln_str("-mdef"),
cmd_ln_str("-dict"),
cmd_ln_str("-fdict"),
"", /* Hack!! Hardwired constant
for -compsep argument */
cmd_ln_str("-lm"),
cmd_ln_str("-fillpen"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_float32("-uw"),
cmd_ln_str("-mean"),
cmd_ln_str("-var"),
cmd_ln_float32("-varfloor"),
cmd_ln_str("-mixw"),
cmd_ln_float32("-mixwfloor"),
cmd_ln_str("-subvq"),
cmd_ln_str("-tmat"),
cmd_ln_float32("-tmatfloor"));
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
lm = kbcore_lm(kbcore);
d2p = kbcore_dict2pid(kbcore);
if (NOT_S3WID(dict_startwid(dict)) || NOT_S3WID(dict_finishwid(dict)))
E_FATAL("%s or %s not in dictionary\n", S3_START_WORD, S3_FINISH_WORD);
if (NOT_S3LMWID(lm_startwid(lm)) || NOT_S3LMWID(lm_finishwid(lm)))
E_FATAL("%s or %s not in LM\n", S3_START_WORD, S3_FINISH_WORD);
/* Check that HMM topology restrictions are not violated */
if (tmat_chk_1skip (kbcore->tmat) < 0)
E_FATAL("Tmat contains arcs skipping more than 1 state\n");
/*
* Unlink <s> and </s> between dictionary and LM, to prevent their
* recognition. They are merely dummy words (anchors) at the beginning
* and end of each utterance.
*/
lm_lmwid2dictwid(lm, lm_startwid(lm)) = BAD_S3WID;
lm_lmwid2dictwid(lm, lm_finishwid(lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
sil = mdef_silphone (kbcore_mdef (kbcore));
if (NOT_S3CIPID(sil))
E_FATAL("Silence phone '%s' not in mdef\n", S3_SILENCE_CIPHONE);
E_INFO("Building lextrees\n");
kb->sen_active = (int32 *) ckd_calloc (mdef_n_sen(mdef), sizeof(int32));
kb->ssid_active = (int32 *) ckd_calloc (mdef_n_sseq(mdef), sizeof(int32));
kb->comssid_active = (int32 *) ckd_calloc (dict2pid_n_comsseq(d2p),
sizeof(int32));
/* Build active word list */
wp = (wordprob_t *) ckd_calloc (dict_size(dict), sizeof(wordprob_t));
n = lm_ug_wordprob (lm, MAX_NEG_INT32, wp);
if (n < 1)
E_FATAL("%d active words\n", n);
n = wid_wordprob2alt (dict, wp, n); /* Add alternative pronunciations */
/* Retain or remove unigram probs from lextree, depending on option */
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
/* Build set of all possible left contexts */
lc = (s3cipid_t *) ckd_calloc (mdef_n_ciphone(mdef) + 1, sizeof(s3cipid_t));
lc_active = bitvec_alloc (mdef_n_ciphone (mdef));
for (w = 0; w < dict_size (dict); w++) {
ci = dict_pron (dict, w, dict_pronlen(dict, w) - 1);
if (! mdef_is_fillerphone (mdef, (int)ci))
bitvec_set (lc_active, ci);
}
ci = mdef_silphone(mdef);
bitvec_set (lc_active, ci);
for (ci = 0, n_lc = 0; ci < mdef_n_ciphone(mdef); ci++) {
if (bitvec_is_set (lc_active, ci))
lc[n_lc++] = ci;
}
lc[n_lc] = BAD_S3CIPID;
/* Create the desired no. of unigram lextrees */
kb->n_lextree = cmd_ln_int32 ("-Nlextree");
if (kb->n_lextree < 1) {
E_ERROR("No. of ugtrees specified: %d; will instantiate 1 ugtree\n",
kb->n_lextree);
kb->n_lextree = 1;
}
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for (i = 0; i < kb->n_lextree; i++) {
kb->ugtree[i] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtree[i]) = 0;
}
bitvec_free (lc_active);
ckd_free ((void *) lc);
/* Create filler lextrees */
n = 0;
for (i = dict_filler_start(dict); i <= dict_filler_end(dict); i++) {
if (dict_filler_word(dict, i)) {
wp[n].wid = i;
wp[n].prob = fillpen (kbcore->fillpen, i);
n++;
}
}
kb->fillertree = (lextree_t **)ckd_calloc(kb->n_lextree,sizeof(lextree_t*));
for (i = 0; i < kb->n_lextree; i++) {
kb->fillertree[i] = lextree_build (kbcore, wp, n, NULL);
lextree_type (kb->fillertree[i]) = -1;
}
ckd_free ((void *) wp);
E_INFO("Lextrees(%d), %d nodes(ug), %d nodes(filler)\n",
kb->n_lextree, lextree_n_node(kb->ugtree[0]),
lextree_n_node(kb->fillertree[0]));
if (cmd_ln_int32("-lextreedump")) {
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "UGTREE %d\n", i);
lextree_dump (kb->ugtree[i], dict, stderr);
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "FILLERTREE %d\n", i);
lextree_dump (kb->fillertree[i], dict, stderr);
}
fflush (stderr);
}
kb->ascr = ascr_init (mgau_n_mgau(kbcore_mgau(kbcore)),
kbcore->dict2pid->n_comstate);
kb->beam = beam_init (cmd_ln_float64("-subvqbeam"),
cmd_ln_float64("-beam"),
cmd_ln_float64("-pbeam"),
cmd_ln_float64("-wbeam"));
E_INFO("Beam= %d, PBeam= %d, WBeam= %d, SVQBeam= %d\n",
kb->beam->hmm, kb->beam->ptrans, kb->beam->word, kb->beam->subvq);
if ((kb->feat = feat_array_alloc(kbcore_fcb(kbcore),S3_MAX_FRAMES)) == NULL)
E_FATAL("feat_array_alloc() failed\n");
kb->vithist = vithist_init(kbcore, kb->beam->word, cmd_ln_int32("-bghist"));
ptmr_init (&(kb->tm_sen));
ptmr_init (&(kb->tm_srch));
kb->tot_fr = 0;
kb->tot_sen_eval = 0.0;
kb->tot_gau_eval = 0.0;
kb->tot_hmm_eval = 0.0;
kb->tot_wd_exit = 0.0;
kb->hmm_hist_binsize = cmd_ln_int32("-hmmhistbinsize");
n = ((kb->ugtree[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
n /= kb->hmm_hist_binsize;
kb->hmm_hist_bins = n+1;
kb->hmm_hist = (int32 *) ckd_calloc (n+1, sizeof(int32)); /* Really no need for +1 */
/* Open hypseg file if specified */
str = cmd_ln_str("-hypseg");
kb->matchsegfp = NULL;
if (str) {
#ifdef WIN32
if ((kb->matchsegfp = fopen(str, "wt")) == NULL)
#else
if ((kb->matchsegfp = fopen(str, "w")) == NULL)
#endif
E_ERROR("fopen(%s,w) failed; use FWDXCT: from std logfile\n", str);
}
}
/* Update kb w/ new dictionary and new LM.
* assumes: single-LM kbcore (before & after)
* requires: updating kbcore
* Lucian Galescu, 08/11/2005
*/
void kb_update_lm(kb_t *kb, char *dictfile, char *lmfile)
{
kbcore_t *kbcore;
mdef_t *mdef;
dict_t *dict;
dict2pid_t *d2p;
lm_t *lm;
s3cipid_t ci;
s3wid_t w;
int32 i, n, n_lc;
wordprob_t *wp;
s3cipid_t *lc;
bitvec_t lc_active;
/*** clean up ***/
vithist_t *vithist = kb->vithist;
if (kb->fillertree)
ckd_free ((void *)kb->fillertree);
if (kb->hmm_hist)
ckd_free ((void *)kb->hmm_hist);
/* vithist */
if (vithist) {
ckd_free ((void *) vithist->entry);
ckd_free ((void *) vithist->frame_start);
ckd_free ((void *) vithist->bestscore);
ckd_free ((void *) vithist->bestvh);
ckd_free ((void *) vithist->lms2vh_root);
ckd_free ((void *) kb->vithist);
}
/*** re-initialize ***/
kb->kbcore = kbcore_update_lm(kb->kbcore,
dictfile,
cmd_ln_str("-fdict"),
"", /* Hack!! Hardwired constant for -compsep argument */
lmfile,
cmd_ln_str("-fillpen"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_float32("-uw"));
if(kb->kbcore==NULL){
E_FATAL("Updating kbcore failed\n");
}
kbcore = kb->kbcore;
mdef = kbcore_mdef(kbcore);
dict = kbcore_dict(kbcore);
lm = kbcore_lm(kbcore);
d2p = kbcore_dict2pid(kbcore);
if (NOT_S3WID(dict_startwid(dict)) || NOT_S3WID(dict_finishwid(dict)))
E_FATAL("%s or %s not in dictionary\n", S3_START_WORD, S3_FINISH_WORD);
if(lm){
if (NOT_S3LMWID(lm_startwid(lm)) || NOT_S3LMWID(lm_finishwid(lm)))
E_FATAL("%s or %s not in LM\n", S3_START_WORD, S3_FINISH_WORD);
}
/*
* Unlink <s> and </s> between dictionary and LM, to prevent their
* recognition. They are merely dummy words (anchors) at the beginning
* and end of each utterance.
*/
if(lm){
lm_lmwid2dictwid(lm, lm_startwid(lm)) = BAD_S3WID;
lm_lmwid2dictwid(lm, lm_finishwid(lm)) = BAD_S3WID;
for (w = dict_startwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
for (w = dict_finishwid(dict); IS_S3WID(w); w = dict_nextalt(dict, w))
kbcore->dict2lmwid[w] = BAD_S3LMWID;
}
/* Build set of all possible left contexts */
lc = (s3cipid_t *) ckd_calloc (mdef_n_ciphone(mdef) + 1, sizeof(s3cipid_t));
lc_active = bitvec_alloc (mdef_n_ciphone (mdef));
for (w = 0; w < dict_size (dict); w++) {
ci = dict_pron (dict, w, dict_pronlen(dict, w) - 1);
if (! mdef_is_fillerphone (mdef, (int)ci))
bitvec_set (lc_active, ci);
}
ci = mdef_silphone(mdef);
bitvec_set (lc_active, ci);
for (ci = 0, n_lc = 0; ci < mdef_n_ciphone(mdef); ci++) {
if (bitvec_is_set (lc_active, ci))
lc[n_lc++] = ci;
}
lc[n_lc] = BAD_S3CIPID;
E_INFO("Building lextrees\n");
/* Get the number of lexical tree*/
kb->n_lextree = cmd_ln_int32 ("-Nlextree");
if (kb->n_lextree < 1) {
E_ERROR("No. of ugtrees specified: %d; will instantiate 1 ugtree\n",
kb->n_lextree);
kb->n_lextree = 1;
}
/* ARCHAN: This code was rearranged in s3.4 implementation of dynamic LM */
/* Build active word list */
wp = (wordprob_t *) ckd_calloc (dict_size(dict), sizeof(wordprob_t));
if (lm) {
E_INFO("Creating Unigram Table\n");
n=0;
n = lm_ug_wordprob (lm, dict, MAX_NEG_INT32, wp);
E_INFO("Size of word table after unigram + words in class: %d\n",n);
if (n < 1)
E_FATAL("%d active words\n", n);
n = wid_wordprob2alt (dict, wp, n); /* Add alternative pronunciations */
/* Retain or remove unigram probs from lextree, depending on option */
if (cmd_ln_int32("-treeugprob") == 0) {
for (i = 0; i < n; i++)
wp[i].prob = -1; /* Flatten all initial probabilities */
}
/* Create the desired no. of unigram lextrees */
kb->ugtree = (lextree_t **) ckd_calloc (kb->n_lextree, sizeof(lextree_t *));
for (i = 0; i < kb->n_lextree; i++) {
kb->ugtree[i] = lextree_build (kbcore, wp, n, lc);
lextree_type (kb->ugtree[i]) = 0;
}
E_INFO("Lextrees(%d), %d nodes(ug)\n",
kb->n_lextree, lextree_n_node(kb->ugtree[0]));
}
/* Create filler lextrees */
/* ARCHAN : only one filler tree is supposed to be build even for dynamic LMs */
n = 0;
for (i = dict_filler_start(dict); i <= dict_filler_end(dict); i++) {
if (dict_filler_word(dict, i)) {
wp[n].wid = i;
wp[n].prob = fillpen (kbcore->fillpen, i);
n++;
}
}
kb->fillertree = (lextree_t **)ckd_calloc(kb->n_lextree,sizeof(lextree_t*));
for (i = 0; i < kb->n_lextree; i++) {
kb->fillertree[i] = lextree_build (kbcore, wp, n, NULL);
lextree_type (kb->fillertree[i]) = -1;
}
ckd_free ((void *) wp);
ckd_free ((void *) lc);
bitvec_free (lc_active);
E_INFO("Lextrees(%d), %d nodes(filler)\n",
kb->n_lextree,
lextree_n_node(kb->fillertree[0]));
if (cmd_ln_int32("-lextreedump")) {
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "UGTREE %d\n", i);
lextree_dump (kb->ugtree[i], dict, stderr);
}
for (i = 0; i < kb->n_lextree; i++) {
fprintf (stderr, "FILLERTREE %d\n", i);
lextree_dump (kb->fillertree[i], dict, stderr);
}
fflush (stderr);
}
kb->ascr = ascr_init (mgau_n_mgau(kbcore_mgau(kbcore)),
kbcore->dict2pid->n_comstate);
kb->vithist = vithist_init(kbcore, kb->beam->word, cmd_ln_int32("-bghist"));
kb->hmm_hist_binsize = cmd_ln_int32("-hmmhistbinsize");
n = ((kb->ugtree[0]->n_node) + (kb->fillertree[0]->n_node)) * kb->n_lextree;
n /= kb->hmm_hist_binsize;
kb->hmm_hist_bins = n+1;
kb->hmm_hist = (int32 *) ckd_calloc (n+1, sizeof(int32)); /* Really no need for +1 */
}
acoustic_t *acoustic_init (feat_t *f, gauden_t *g, senone_t *s,
float64 beam,
int32 maxfr)
{
acoustic_t *am;
int32 i;
if (senone_n_mgau(s) != gauden_n_mgau(g)) {
E_ERROR("#Parent mixture Gaussians mismatch: senone(%d), gauden(%d)\n",
senone_n_mgau(s), gauden_n_mgau(g));
}
if (feat_n_stream(f) != senone_n_stream(s)) {
E_ERROR("#Feature-streams mismatch: feat(%d), senone(%d)\n",
feat_n_stream(f), senone_n_stream(s));
}
if (feat_n_stream(f) != gauden_n_stream(g)) {
E_ERROR("#Feature-streams mismatch: feat(%d), gauden(%d)\n",
feat_n_stream(f), gauden_n_stream(g));
return NULL;
}
for (i = 0; i < feat_n_stream(f); i++) {
if (feat_stream_len(f, i) != gauden_stream_len(g, i)) {
E_ERROR("Feature stream(%d) length mismatch: feat(%d), gauden(%d)\n",
feat_stream_len(f, i), gauden_stream_len(g, i));
return NULL;
}
}
if (beam > 1.0) {
E_ERROR("mgaubeam > 1.0 (%e)\n", beam);
return NULL;
}
am = (acoustic_t *) ckd_calloc (1, sizeof(acoustic_t));
am->fcb = f;
am->gau = g;
am->sen = s;
am->mgaubeam = (beam == 0.0) ? LOGPROB_ZERO : logs3(beam);
if (am->mgaubeam > 0)
am->mgaubeam = 0;
am->tot_mgau_eval = 0;
am->tot_dist_valid = 0.0;
am->dist_valid = (am->mgaubeam <= LOGPROB_ZERO) ? NULL :
(int32 *) ckd_calloc (g->max_n_mean, sizeof(int32));
if (f->compute_feat) {
/* Input is MFC cepstra; feature vectors computed from that */
am->mfc = (float32 **) ckd_calloc_2d (maxfr, feat_cepsize(am->fcb),
sizeof(float32));
am->feat = feat_array_alloc (f, 1);
} else {
/* Input is directly feature vectors */
am->mfc = NULL;
am->feat = feat_array_alloc (f, maxfr);
}
am->dist = (int32 *) ckd_calloc (g->max_n_mean, sizeof(int32));
am->gauden_active = bitvec_alloc (g->n_mgau);
am->senscr = (int32 *) ckd_calloc (s->n_sen, sizeof(int32));
am->senscale = (int32 *) ckd_calloc (maxfr, sizeof(int32));
am->sen_active = bitvec_alloc (s->n_sen);
return am;
}
acmod_t *
acmod_init(cmd_ln_t *config, logmath_t *lmath, fe_t *fe, feat_t *fcb)
{
acmod_t *acmod;
char const *featparams;
acmod = ckd_calloc(1, sizeof(*acmod));
acmod->config = cmd_ln_retain(config);
acmod->lmath = lmath;
acmod->state = ACMOD_IDLE;
/* Look for feat.params in acoustic model dir. */
if ((featparams = cmd_ln_str_r(acmod->config, "-featparams"))) {
if (NULL !=
cmd_ln_parse_file_r(acmod->config, feat_defn, featparams, FALSE))
E_INFO("Parsed model-specific feature parameters from %s\n",
featparams);
}
/* Initialize feature computation. */
if (fe) {
if (acmod_fe_mismatch(acmod, fe))
goto error_out;
fe_retain(fe);
acmod->fe = fe;
}
else {
/* Initialize a new front end. */
acmod->fe = fe_init_auto_r(config);
if (acmod->fe == NULL)
goto error_out;
if (acmod_fe_mismatch(acmod, acmod->fe))
goto error_out;
}
if (fcb) {
if (acmod_feat_mismatch(acmod, fcb))
goto error_out;
feat_retain(fcb);
acmod->fcb = fcb;
}
else {
/* Initialize a new fcb. */
if (acmod_init_feat(acmod) < 0)
goto error_out;
}
/* Load acoustic model parameters. */
if (acmod_init_am(acmod) < 0)
goto error_out;
/* The MFCC buffer needs to be at least as large as the dynamic
* feature window. */
acmod->n_mfc_alloc = acmod->fcb->window_size * 2 + 1;
acmod->mfc_buf = (mfcc_t **)
ckd_calloc_2d(acmod->n_mfc_alloc, acmod->fcb->cepsize,
sizeof(**acmod->mfc_buf));
/* Feature buffer has to be at least as large as MFCC buffer. */
acmod->n_feat_alloc = acmod->n_mfc_alloc + cmd_ln_int32_r(config, "-pl_window");
acmod->feat_buf = feat_array_alloc(acmod->fcb, acmod->n_feat_alloc);
acmod->framepos = ckd_calloc(acmod->n_feat_alloc, sizeof(*acmod->framepos));
acmod->utt_start_frame = 0;
/* Senone computation stuff. */
acmod->senone_scores = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_scores));
acmod->senone_active_vec = bitvec_alloc(bin_mdef_n_sen(acmod->mdef));
acmod->senone_active = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_active));
acmod->log_zero = logmath_get_zero(acmod->lmath);
acmod->compallsen = cmd_ln_boolean_r(config, "-compallsen");
return acmod;
error_out:
acmod_free(acmod);
return NULL;
}
int DBSCAN(void *data, unsigned int *d, unsigned int dlen,
float eps, unsigned int minpoints,
unsigned int (*neighbours_search)(bitvec_t *out,
void *, unsigned int, float, unsigned int *)
) {
unsigned int cluster = 1;
unsigned int count, i, j, k;
bitvec_t *visited, *clustered, *neighbours, *neighbours2;
bitvec_alloc(&visited, dlen);
bitvec_alloc(&clustered, dlen);
bitvec_alloc(&neighbours, dlen);
bitvec_alloc(&neighbours2, dlen);
// d is a list of identifiers
for (i = 0; i < dlen; i++) {
count = 0;
// Already visited this point
if (bitvec_check(visited, i)) continue;
fprintf(stderr, "Cluster: %.2f\n", 100.0*i/dlen);
// Mark this point as visited
bitvec_set(visited, i);
bitvec_clear_all(neighbours);
// Get the first set of neighbours
if(neighbours_search(neighbours, data, i, eps, &count)) {
return 1;
}
if (count < minpoints) {
*(d + i) = 0; // Noise
continue;
}
*(d + i) = cluster;
bitvec_set(clustered, i);
// Expand the cluster
for (j = 0; j < dlen; j++) {
if(!bitvec_check(neighbours, j)) continue;
if(!bitvec_check(visited, j)) {
bitvec_set(visited, j);
count = 0;
bitvec_clear_all(neighbours2);
if (neighbours_search(neighbours2, data, j, eps, &count)) {
return 1;
}
if (count >= minpoints) {
// Merge two bitarrays
bitvec_union(neighbours, neighbours2);
j = 0;
}
}
if (!bitvec_check(clustered, j)) {
*(d + j) = cluster;
bitvec_set(clustered, j);
}
}
cluster++;
}
bitvec_free(visited);
bitvec_free(clustered);
bitvec_free(neighbours);
bitvec_free(neighbours2);
return 0;
}
dict2pid_t *
dict2pid_build(bin_mdef_t * mdef, dict_t * dict)
{
dict2pid_t *dict2pid;
s3ssid_t ***rdiph_rc;
bitvec_t *ldiph, *rdiph, *single;
int32 pronlen;
int32 b, l, r, w, p;
E_INFO("Building PID tables for dictionary\n");
assert(mdef);
assert(dict);
dict2pid = (dict2pid_t *) ckd_calloc(1, sizeof(dict2pid_t));
dict2pid->refcount = 1;
dict2pid->mdef = bin_mdef_retain(mdef);
dict2pid->dict = dict_retain(dict);
E_INFO("Allocating %d^3 * %d bytes (%d KiB) for word-initial triphones\n",
mdef->n_ciphone, sizeof(s3ssid_t),
mdef->n_ciphone * mdef->n_ciphone * mdef->n_ciphone * sizeof(s3ssid_t) / 1024);
dict2pid->ldiph_lc =
(s3ssid_t ***) ckd_calloc_3d(mdef->n_ciphone, mdef->n_ciphone,
mdef->n_ciphone, sizeof(s3ssid_t));
/* Only used internally to generate rssid */
rdiph_rc =
(s3ssid_t ***) ckd_calloc_3d(mdef->n_ciphone, mdef->n_ciphone,
mdef->n_ciphone, sizeof(s3ssid_t));
dict2pid->lrdiph_rc = (s3ssid_t ***) ckd_calloc_3d(mdef->n_ciphone,
mdef->n_ciphone,
mdef->n_ciphone,
sizeof
(s3ssid_t));
/* Actually could use memset for this, if BAD_S3SSID is guaranteed
* to be 65535... */
for (b = 0; b < mdef->n_ciphone; ++b) {
for (r = 0; r < mdef->n_ciphone; ++r) {
for (l = 0; l < mdef->n_ciphone; ++l) {
dict2pid->ldiph_lc[b][r][l] = BAD_S3SSID;
dict2pid->lrdiph_rc[b][l][r] = BAD_S3SSID;
rdiph_rc[b][l][r] = BAD_S3SSID;
}
}
}
/* Track which diphones / ciphones have been seen. */
ldiph = bitvec_alloc(mdef->n_ciphone * mdef->n_ciphone);
rdiph = bitvec_alloc(mdef->n_ciphone * mdef->n_ciphone);
single = bitvec_alloc(mdef->n_ciphone);
for (w = 0; w < dict_size(dict2pid->dict); w++) {
pronlen = dict_pronlen(dict, w);
if (pronlen >= 2) {
b = dict_first_phone(dict, w);
r = dict_second_phone(dict, w);
/* Populate ldiph_lc */
if (bitvec_is_clear(ldiph, b * mdef->n_ciphone + r)) {
/* Mark this diphone as done */
bitvec_set(ldiph, b * mdef->n_ciphone + r);
/* Record all possible ssids for b(?,r) */
for (l = 0; l < bin_mdef_n_ciphone(mdef); l++) {
p = bin_mdef_phone_id_nearest(mdef, (s3cipid_t) b,
(s3cipid_t) l, (s3cipid_t) r,
WORD_POSN_BEGIN);
dict2pid->ldiph_lc[b][r][l] = bin_mdef_pid2ssid(mdef, p);
}
}
/* Populate rdiph_rc */
l = dict_second_last_phone(dict, w);
b = dict_last_phone(dict, w);
if (bitvec_is_clear(rdiph, b * mdef->n_ciphone + l)) {
/* Mark this diphone as done */
bitvec_set(rdiph, b * mdef->n_ciphone + l);
for (r = 0; r < bin_mdef_n_ciphone(mdef); r++) {
p = bin_mdef_phone_id_nearest(mdef, (s3cipid_t) b,
(s3cipid_t) l, (s3cipid_t) r,
WORD_POSN_END);
rdiph_rc[b][l][r] = bin_mdef_pid2ssid(mdef, p);
}
}
}
else if (pronlen == 1) {
b = dict_pron(dict, w, 0);
E_DEBUG(1,("Building tables for single phone word %s phone %d = %s\n",
dict_wordstr(dict, w), b, bin_mdef_ciphone_str(mdef, b)));
/* Populate lrdiph_rc (and also ldiph_lc, rdiph_rc if needed) */
if (bitvec_is_clear(single, b)) {
populate_lrdiph(dict2pid, rdiph_rc, b);
bitvec_set(single, b);
}
}
}
bitvec_free(ldiph);
bitvec_free(rdiph);
bitvec_free(single);
/* Try to compress rdiph_rc into rdiph_rc_compressed */
compress_right_context_tree(dict2pid, rdiph_rc);
compress_left_right_context_tree(dict2pid);
ckd_free_3d(rdiph_rc);
dict2pid_report(dict2pid);
return dict2pid;
}
main (int32 argc, char *argv[])
{
kb_t kb;
kbcore_t *kbcore;
bitvec_t active;
int32 w;
cmd_ln_parse (arglist, argc, argv);
unlimit();
kbcore = kbcore_init (cmd_ln_float32("-logbase"),
cmd_ln_str("-feat"),
cmd_ln_str("-mdef"),
cmd_ln_str("-dict"),
cmd_ln_str("-fdict"),
cmd_ln_str("-compsep"),
cmd_ln_str("-lm"),
cmd_ln_str("-fillpen"),
cmd_ln_float32("-silprob"),
cmd_ln_float32("-fillprob"),
cmd_ln_float32("-lw"),
cmd_ln_float32("-wip"),
cmd_ln_str("-mean"),
cmd_ln_str("-var"),
cmd_ln_float32("-varfloor"),
cmd_ln_str("-senmgau"),
cmd_ln_str("-mixw"),
cmd_ln_float32("-mixwfloor"),
cmd_ln_str("-tmat"),
cmd_ln_float32("-tmatfloor"));
/* Here's the perfect candidate for inheritance */
kb.mdef = kbcore->mdef;
kb.dict = kbcore->dict;
kb.lm = kbcore->lm;
kb.fillpen = kbcore->fillpen;
kb.tmat = kbcore->tmat;
kb.dict2lmwid = kbcore->dict2lmwid;
if ((kb.am = acoustic_init (kbcore->fcb, kbcore->gau, kbcore->sen, cmd_ln_float32("-mgaubeam"),
S3_MAX_FRAMES)) == NULL) {
E_FATAL("Acoustic models initialization failed\n");
}
kb.beam = logs3 (cmd_ln_float64("-beam"));
kb.wordbeam = logs3 (cmd_ln_float64("-wordbeam"));
kb.wordmax = cmd_ln_int32("-wordmax");
/* Mark the active words and build lextree */
active = bitvec_alloc (dict_size (kb.dict));
bitvec_clear_all (active, dict_size(kb.dict));
for (w = 0; w < dict_size(kb.dict); w++) {
if (IS_LMWID(kb.dict2lmwid[w]) || dict_filler_word (kb.dict, w))
bitvec_set (active, w);
}
kb.lextree_root = lextree_build (kb.dict, kb.mdef, active, cmd_ln_int32("-flatdepth"));
kb.vithist = (glist_t *) ckd_calloc (S3_MAX_FRAMES+2, sizeof(glist_t));
kb.vithist++; /* Allow for dummy frame -1 for start word */
kb.lextree_active = NULL;
kb.wd_last_sf = (int32 *) ckd_calloc (dict_size(kb.dict), sizeof(int32));
kb.tm = (ptmr_t *) ckd_calloc (1, sizeof(ptmr_t));
kb.tm_search = (ptmr_t *) ckd_calloc (1, sizeof(ptmr_t));
ctl_process (cmd_ln_str("-ctl"), cmd_ln_int32("-ctloffset"), cmd_ln_int32("-ctlcount"),
decode_utt, &kb);
exit(0);
}
