kb_main.c

来自「WinCE平台上的语音识别程序」· C语言 代码 · 共 597 行 · 第 1/2 页

                if (strcmp(str, "}") != 0)
                    E_FATAL("Unexpected EOF(%s)\n", lm_ctl_filename);

                if (fscanf(ctlfp, "%s", str) != 1)
                    str[0] = '\0';
            }
        }
        else
            str[0] = '\0';

        /* Fill in dictionary word id information for each LMclass word */
        for (cl = lmclass_firstclass(lmclass_set);
             lmclass_isclass(cl);
             cl = lmclass_nextclass(lmclass_set, cl)) {
            kb_init_lmclass_dictwid(cl);
        }

        /* At this point if str[0] != '\0', we have an LM filename */
        n_lmclass = lmclass_get_nclass(lmclass_set);
        lmclass = ckd_calloc(n_lmclass, sizeof(lmclass_t));

        /* Read in one LM at a time */
        while (str[0] != '\0') {
            strcpy(lmfile, str);
            if (fscanf(ctlfp, "%s", lmname) != 1)
                E_FATAL("LMname missing after LMFileName '%s'\n",
                        lmfile);

            n_lmclass_used = 0;

            if (fscanf(ctlfp, "%s", str) == 1) {
                if (strcmp(str, "{") == 0) {
                    /* LM uses classes; read their names */
                    while ((fscanf(ctlfp, "%s", str) == 1) &&
                           (strcmp(str, "}") != 0)) {
                        if (n_lmclass_used >= n_lmclass)
                            E_FATAL
                                ("Too many LM classes specified for '%s'\n",
                                 lmfile);
                        lmclass[n_lmclass_used] =
                            lmclass_get_lmclass(lmclass_set, str);
                        if (!
                            (lmclass_isclass(lmclass[n_lmclass_used])))
                            E_FATAL("LM class '%s' not found\n", str);
                        n_lmclass_used++;
                    }
                    if (strcmp(str, "}") != 0)
                        E_FATAL("Unexpected EOF(%s)\n",
                                lm_ctl_filename);

                    if (fscanf(ctlfp, "%s", str) != 1)
                        str[0] = '\0';
                }
            }
            else
                str[0] = '\0';

            if (n_lmclass_used > 0)
                lm_read_clm(lmfile, lmname,
                            cmd_ln_float32("-lw"),
                            cmd_ln_float32("-uw"),
                            cmd_ln_float32("-wip"),
                            lmclass, n_lmclass_used);
            else
                lm_read(lmfile, lmname,
                        cmd_ln_float32("-lw"),
                        cmd_ln_float32("-uw"),
                        cmd_ln_float32("-wip"));
        }

        fclose(ctlfp);
    }

    /* Read "base" LM file, if specified */
    if (lm_file_name) {
        lmSetStartSym(lm_start_sym);
        lmSetEndSym(lm_end_sym);
        lm_read(lm_file_name, "",
                cmd_ln_float32("-lw"),
                cmd_ln_float32("-uw"),
                cmd_ln_float32("-wip"));

        /* Make initial OOV list known to this base LM */
        lm_init_oov();
    }
}

static void
dict_init(void)
{
    char *fdictfn = NULL;

    E_INFO("Reading dict file [%s]\n", cmd_ln_str("-dict"));
    word_dict = dict_new();
    /* Look for noise word dictionary in the HMM directory if not given */
    if (cmd_ln_str("-hmm") && !cmd_ln_str("-fdict")) {
        FILE *tmp;
        fdictfn = string_join(hmmdir, "/noisedict", NULL);
        if ((tmp = fopen(fdictfn, "r")) == NULL) {
            ckd_free(fdictfn);
            fdictfn = NULL;
        }
        else {
            fclose(tmp);
        }
    }

    if (dict_read(word_dict, cmd_ln_str("-dict"),
                  (fdictfn != NULL) ? fdictfn : cmd_ln_str("-fdict"),
                  !cmd_ln_boolean("-usewdphones"))) {
        ckd_free(fdictfn);
        E_FATAL("Failed to read dictionaries\n");
    }
    ckd_free(fdictfn);
}

static void
phonetp_init(int32 num_ci_phones)
{
    int i, j, n, logp;
    float32 p, uptp;
    float32 pip = cmd_ln_float32("-pip");
    float32 ptplw = cmd_ln_float32("-ptplw");
    float32 uptpwt = cmd_ln_float32("-uptpwt");

    phonetp =
        (int32 **) ckd_calloc_2d(num_ci_phones, num_ci_phones,
                                 sizeof(int32));
    if (cmd_ln_str("-phonetp")) {
        /* Load phone transition counts file */
        phonetp_load_file(cmd_ln_str("-phonetp"), phonetp);
    }
    else {
        /* No transition probs file specified; use uniform probs */
        for (i = 0; i < num_ci_phones; i++) {
            for (j = 0; j < num_ci_phones; j++) {
                phonetp[i][j] = 1;
            }
        }
    }
    /* Convert counts to probs; smooth; convert to LOG-probs; apply lw/pip */
    for (i = 0; i < num_ci_phones; i++) {
        n = 0;
        for (j = 0; j < num_ci_phones; j++)
            n += phonetp[i][j];
        assert(n >= 0);

        if (n == 0) {           /* No data here, use uniform probs */
            p = 1.0 / (float32) num_ci_phones;
            p *= pip;           /* Phone insertion penalty */
            logp = (int32) (LOG(p) * ptplw);

            for (j = 0; j < num_ci_phones; j++)
                phonetp[i][j] = logp;
        }
        else {
            uptp = 1.0 / (float32) num_ci_phones;       /* Uniform prob trans prob */

            for (j = 0; j < num_ci_phones; j++) {
                p = ((float32) phonetp[i][j] / (float32) n);
                p = ((1.0 - uptpwt) * p) + (uptpwt * uptp);     /* Smooth */
                p *= pip;       /* Phone insertion penalty */

                phonetp[i][j] = (int32) (LOG(p) * ptplw);
            }
        }
    }
}

void
kb_init(void)
{
    int32 num_phones, num_ci_phones;

    /* Get acoustic model filenames */
    if ((hmmdir = cmd_ln_str("-hmm")) != NULL) {
        FILE *tmp;

        mdeffn = string_join(hmmdir, "/mdef", NULL);
        meanfn = string_join(hmmdir, "/means", NULL);
        varfn = string_join(hmmdir, "/variances", NULL);
        mixwfn = string_join(hmmdir, "/mixture_weights", NULL);
        tmatfn = string_join(hmmdir, "/transition_matrices", NULL);

        /* These ones are optional, so make sure they exist. */
        sendumpfn = string_join(hmmdir, "/sendump", NULL);
        if ((tmp = fopen(sendumpfn, "rb")) == NULL) {
            ckd_free(sendumpfn);
            sendumpfn = NULL;
        }
        else {
            fclose(tmp);
        }
        kdtreefn = string_join(hmmdir, "/kdtrees", NULL);
        if ((tmp = fopen(kdtreefn, "rb")) == NULL) {
            ckd_free(kdtreefn);
            kdtreefn = NULL;
        }
        else {
            fclose(tmp);
        }
    }
    /* Allow overrides from the command line */
    if (cmd_ln_str("-mdef")) {
        ckd_free(mdeffn);
        mdeffn = cmd_ln_str("-mdef");
    }
    if (cmd_ln_str("-mean")) {
        ckd_free(meanfn);
        meanfn = cmd_ln_str("-mean");
    }
    if (cmd_ln_str("-var")) {
        ckd_free(varfn);
        varfn = cmd_ln_str("-var");
    }
    if (cmd_ln_str("-mixw")) {
        ckd_free(mixwfn);
        mixwfn = cmd_ln_str("-mixw");
    }
    if (cmd_ln_str("-tmat")) {
        ckd_free(tmatfn);
        tmatfn = cmd_ln_str("-tmat");
    }
    if (cmd_ln_str("-sendump")) {
        ckd_free(sendumpfn);
        sendumpfn = cmd_ln_str("-sendump");
    }
    if (cmd_ln_str("-kdtree")) {
        ckd_free(kdtreefn);
        kdtreefn = cmd_ln_str("-kdtree");
    }

    /* Read model definition. */
    if (mdeffn == NULL)
        E_FATAL("Must specify -mdeffn or -hmm\n");
    if ((mdef = bin_mdef_read(mdeffn)) == NULL)
        E_FATAL("Failed to read model definition from %s\n", mdeffn);
    num_ci_phones = bin_mdef_n_ciphone(mdef);
    num_phones = bin_mdef_n_phone(mdef);

    dict_init();

    lm_init();

    /* Read acoustic model files. */
    if ((meanfn == NULL)
        || (varfn == NULL)
        || (tmatfn == NULL))
        E_FATAL("No mean/var/tmat files specified\n");

    /* Read transition matrices. */
    tmat = tmat_init(tmatfn, cmd_ln_float32("-tmatfloor"), TRUE);

    /* Read the acoustic models. */
    E_INFO("Initializing SCGMM computation module\n");
    semi_mgau = s2_semi_mgau_init(meanfn,
                                  varfn,
                                  cmd_ln_float32("-varfloor"),
                                  mixwfn,
                                  cmd_ln_float32("-mixwfloor"),
                                  cmd_ln_int32("-topn"));
    if (kdtreefn)
        s2_semi_mgau_load_kdtree(semi_mgau,
                                 kdtreefn,
                                 cmd_ln_int32("-kdmaxdepth"),
                                 cmd_ln_int32("-kdmaxbbi"));
    semi_mgau->ds_ratio = cmd_ln_int32("-dsratio");

    /*
     * Create phone transition logprobs matrix
     */
    phonetp_init(num_ci_phones);
}

char *
kb_get_senprob_dump_file(void)
{
    return sendumpfn;
}

int32
kb_get_word_id(char const *word)
{
    return (dict_to_id(word_dict, word));
}

char *
kb_get_word_str(int32 wid)
{
    return (word_dict->dict_list[wid]->word);
}

int32
kb_dict_maxsize(void)
{
    return (hash_table_size(word_dict->dict));
}