Esempio n. 1
0
int32
subvq_frame_eval(subvq_t * vq, mgau_model_t * g, int32 beam,
                 float32 * feat, uint8 * sen_active, int32 * senscr)
{
    int32 s;
    int32 best, ns, ng;

    best = MAX_NEG_INT32;
    ns = 0;
    ng = 0;
    if (!vq) {
        /* No subvq model, use the original (SLOW!!) */
        for (s = 0; s < g->n_mgau; s++) {
            if ((!sen_active) || sen_active[s]) {
                senscr[s] = mgau_eval(g, s, NULL, feat);
                if (best < senscr[s])
                    best = senscr[s];
                ns++;
                ng += mgau_n_comp(g, s);
            }
            else
                senscr[s] = S3_LOGPROB_ZERO;
        }
    }
    else {
        /* Evaluate subvq model for given feature vector */
        subvq_gautbl_eval_logs3(vq, feat);

        /* Find mixture component shortlists using subvq scores, and evaluate senones */
        for (s = 0; s < g->n_mgau; s++) {
            if ((!sen_active) || sen_active[s]) {
                ng += subvq_mgau_shortlist(vq, s, mgau_n_comp(g, s), beam);

                senscr[s] = mgau_eval(g, s, vq->mgau_sl, feat);
                if (best < senscr[s])
                    best = senscr[s];

                ns++;
            }
            else
                senscr[s] = S3_LOGPROB_ZERO;
        }
    }

    /* Normalize senone scores */
    for (s = 0; s < g->n_mgau; s++)
        senscr[s] -= best;

    g->frm_sen_eval = ns;
    g->frm_gau_eval = ng;

    return best;
}
Esempio n. 2
0
static void
get_frame_classes(s3_endpointer_t *_ep,
		  float32 **_frames,
		  int _n_frames,
		  int *_classes)
{
    int i, c, k;
    int32 best_class, best_votes, best_score, score;
    int votes[NUM_CLASSES];
    int *voters;

    assert(_ep != NULL);
    assert(_classes != NULL);

    for (i = 0; i < _n_frames; i++) {
	best_score = S3_LOGPROB_ZERO;
	best_class = -1;
	for (c = 0; c < NUM_CLASSES; c++) {
	    score = _ep->priors[c];
	    score += mgau_eval(_ep->gmm, c, NULL, _frames[i], i, 0);
	    if (best_score < score) {
		best_score = score;
		best_class = c;
	    }
	}

	_classes[i] = best_class;
    }

    if (_ep->post_classify) {
	voters = _ep->voters;

	/* reset the totals and tally up the votes from the frames*/
	for (i = 0; i < NUM_CLASSES; votes[i++] = 0);
	for (i = 0; i < VOTING_LEN; i++)
	    votes[voters[i]]++;

	for (i = 0; i < _n_frames; i++) {
	    /* subtract the vote from the oldest frame */
	    votes[voters[0]]--;
	    /* shift the frames down */
	    for (k = 0; k < VOTING_LEN - 1; k++)
		voters[k] = voters[k + 1];

	    /* add the vote from the newest frame */
	    votes[voters[VOTING_LEN - 1] = _classes[i]]++;

	    /* re-tally the votes */
	    best_class = 0;
	    best_votes = votes[0];
	    for (k = 1; k < NUM_CLASSES; k++) {
		if (votes[k] > best_votes) {
		    best_class = k;
		    best_votes = votes[k];
		}
	    }

	    _classes[i] = best_class;
	}
    }

#if 0
    printf("%d:\t", count * 10); count++;
    for (i = 0; i < _n_frames; i++)
	printf(_classes[i] == CLASS_OWNER ? "O" : ".");
    printf("\n");
#endif

}
Esempio n. 3
0
void
gmm_compute(void *data, utt_res_t * ur, int32 sf, int32 ef, char *uttid)
{
    kb_t *kb;
    kbcore_t *kbcore;
    mdef_t *mdef;
    dict_t *dict;
    dict2pid_t *d2p;
    mgau_model_t *mgau;
    subvq_t *svq;
    gs_t *gs;


    int32 ptranskip;
    int32 s, f, t;
    int32 single_el_list[2];
    stats_t cur_ci_st;
    stats_t cur_cd_st;
    stats_t cur_cd_Nbest_st;
    stats_t *stptr;
    char str[100];
    int32 *idx;

    int32 *cur_bstidx;
    int32 *last_bstidx;
    int32 *cur_scr;
    int32 *last_scr;
    int32 tmpint;
    s3senid_t *cd2cisen;

    int32 pheurtype;
    E_INFO("Processing: %s\n", uttid);

    kb = (kb_t *) data;
    kbcore = kb->kbcore;
    mdef = kbcore_mdef(kbcore);
    dict = kbcore_dict(kbcore);
    d2p = kbcore_dict2pid(kbcore);
    mgau = kbcore_mgau(kbcore);
    svq = kbcore_svq(kbcore);
    gs = kbcore_gs(kbcore);
    kb->uttid = uttid;

    ptranskip = kb->beam->ptranskip;

    pheurtype = kb->pl->pheurtype;

    single_el_list[0] = -1;
    single_el_list[1] = -1;


    /* Read mfc file and build feature vectors for entire utterance */
    kb->stat->nfr =
        feat_s2mfc2feat(kbcore_fcb(kbcore), ur->uttfile,
                        cmd_ln_str("-cepdir"), ".mfc", sf, ef, kb->feat,
                        S3_MAX_FRAMES);

    cd2cisen = mdef_cd2cisen(mdef);
    /*This should be a procedure instead of just logic */

    init_stat(&cur_cd_st, "Current CD Senone");
    init_stat(&cur_ci_st, "Current CI Senone");
    init_stat(&cur_cd_Nbest_st, "Current CD NBest Senone");

    for (s = 0; s < mdef->n_ci_sen; s++) {
        sprintf(str, "Cur Senone %d", s);
        init_stat(&cur_sen_st[s], str);
    }

    for (t = 0; t < (int32) (mdef->n_sen - mdef->n_ci_sen) / NBEST_STEP;
         t++) {
        sprintf(str, " %d -Cur Best Senone", t * NBEST_STEP);
        init_stat(&cur_sen_Nbest_st[t], str);
    }

    idx = ckd_calloc(mdef->n_sen - mdef->n_ci_sen, sizeof(int32));
    /* Allocate temporary array for CurScr and Curbst indx and Lat index */

    cur_bstidx = ckd_calloc(mdef->n_sen, sizeof(int32));
    last_bstidx = ckd_calloc(mdef->n_sen, sizeof(int32));
    cur_scr = ckd_calloc(mdef->n_sen, sizeof(int32));
    last_scr = ckd_calloc(mdef->n_sen, sizeof(int32));



    for (f = 0; f < kb->stat->nfr; f++) {
        for (s = 0; s < mgau->n_mgau; s++) {
            /*1, Compute the approximate scores with the last best index. */

            if (mgau->mgau[s].bstidx != NO_BSTIDX) {
                single_el_list[0] = mgau->mgau[s].bstidx;
                last_bstidx[s] = mgau->mgau[s].bstidx;
                last_scr[s] =
                    mgau_eval(mgau, s, single_el_list, kb->feat[f][0], f,
                              0);
            }
            else {
                last_bstidx[s] = NO_BSTIDX;
            }

            /*2, Compute the exact scores and sort them and get the ranking. */

            kb->ascr->senscr[s] =
                mgau_eval(mgau, s, NULL, kb->feat[f][0], f, 1);

            /*3, Compute the approximate scores with the current best index */
            if (mgau->mgau[s].bstidx != NO_BSTIDX) {
                single_el_list[0] = mgau->mgau[s].bstidx;
                cur_bstidx[s] = mgau->mgau[s].bstidx;
                cur_scr[s] =
                    mgau_eval(mgau, s, single_el_list, kb->feat[f][0], f,
                              0);
            }
            else {
                cur_bstidx[s] = NO_BSTIDX;

            }

            /* Only test for CD senones, test for best index hit */

            /*Update either CI senone and CD senone) */


            if (!mdef_is_cisenone(mdef, s))
                stptr = &cur_cd_st;
            else
                stptr = &cur_ci_st;

            increment_stat(stptr,
                           abs(last_scr[s] - kb->ascr->senscr[s]),
                           abs(cur_scr[s] - kb->ascr->senscr[s]),
                           abs(kb->ascr->senscr[cd2cisen[s]] -
                               kb->ascr->senscr[s]),
                           (cur_bstidx[s] == last_bstidx[s]));


            if (!mdef_is_cisenone(mdef, s)) {
                stptr = &cur_sen_st[cd2cisen[s]];
                increment_stat(stptr,
                               abs(last_scr[s] - kb->ascr->senscr[s]),
                               abs(cur_scr[s] - kb->ascr->senscr[s]),
                               abs(kb->ascr->senscr[cd2cisen[s]] -
                                   kb->ascr->senscr[s]),
                               (cur_bstidx[s] == last_bstidx[s]));

                stptr->total_senone += 1;
            }
        }

        cur_cd_st.total_fr++;
        cur_cd_st.total_senone += mdef->n_sen - mdef->n_ci_sen;
        cur_ci_st.total_fr++;
        cur_ci_st.total_senone += mdef->n_ci_sen;

        for (s = 0; s < mdef->n_ci_sen; s++) {
            cur_sen_st[s].total_fr++;
        }

        /*This is the part we need to do sorting */
        /*1, sort the scores in the current frames */
        /*E_INFO("At frame %d\n",f); */

        /*Pointer trick at here. */
        for (s = 0; s < mdef->n_sen - mdef->n_ci_sen; s++) {
            idx[s] = s;
        }

        cd = &(kb->ascr->senscr[mdef->n_ci_sen]);
        qsort(idx, mdef->n_sen - mdef->n_ci_sen, sizeof(int32),
              intcmp_gmm_compute);

        /*This loop is stupid and it is just a hack. */
        for (s = 0; s < mdef->n_sen - mdef->n_ci_sen; s++) {
            tmpint = idx[s] + mdef->n_ci_sen;

            for (t = 0;
                 t <
                 (int32) ((float) (mdef->n_sen - mdef->n_ci_sen) /
                          (float) NBEST_STEP); t++) {

                if (s < t * NBEST_STEP) {

                    increment_stat(&cur_sen_Nbest_st[t],
                                   abs(last_scr[tmpint] -
                                       kb->ascr->senscr[tmpint]),
                                   abs(cur_scr[tmpint] -
                                       kb->ascr->senscr[tmpint]),
                                   abs(kb->ascr->senscr[cd2cisen[tmpint]] -
                                       kb->ascr->senscr[tmpint]),
                                   (cur_bstidx[tmpint] ==
                                    last_bstidx[tmpint]));

                    cur_sen_Nbest_st[t].total_senone += 1;

                }
            }

        }

        for (t = 0;
             t <
             (int32) ((float) (mdef->n_sen - mdef->n_ci_sen) /
                      (float) NBEST_STEP); t++) {
            cur_sen_Nbest_st[t].total_fr++;
        }
    }

    print_stat(&cur_cd_st);
    print_stat(&cur_ci_st);
    print_stat(&cur_sen_Nbest_st[1]);   /*Only show the first NBEST_STEP best */




    add_stat(&cd_st, &cur_cd_st);
    add_stat(&ci_st, &cur_ci_st);

    for (s = 0; s < mdef->n_ci_sen; s++) {
        add_stat(&sen_st[s], &cur_sen_st[s]);
    }

    for (s = 0; s < (int32) (mdef->n_sen - mdef->n_ci_sen) / NBEST_STEP;
         s++) {
        add_stat(&sen_Nbest_st[s], &cur_sen_Nbest_st[s]);
    }

    ckd_free(idx);
    ckd_free(cur_bstidx);
    ckd_free(last_bstidx);
    ckd_free(cur_scr);
    ckd_free(last_scr);
}