gmm-init-model.cc File Reference

#include "base/kaldi-common.h"
#include "util/common-utils.h"
#include "gmm/am-diag-gmm.h"
#include "hmm/transition-model.h"
#include "gmm/mle-am-diag-gmm.h"
#include "tree/build-tree-utils.h"
#include "tree/context-dep.h"
#include "tree/clusterable-classes.h"
#include "util/text-utils.h"

Include dependency graph for gmm-init-model.cc:

Go to the source code of this file.

Namespaces
	kaldi
	This code computes Goodness of Pronunciation (GOP) and extracts phone-level pronunciation feature for mispronunciations detection tasks, the reference:

Functions
void	InitAmGmm (const BuildTreeStatsType &stats, const EventMap &to_pdf_map, AmDiagGmm *am_gmm, const TransitionModel &trans_model, BaseFloat var_floor)
	InitAmGmm initializes the GMM with one Gaussian per state. More...
void	GetOccs (const BuildTreeStatsType &stats, const EventMap &to_pdf_map, Vector< BaseFloat > *occs)
	Get state occupation counts. More...
void	InitAmGmmFromOld (const BuildTreeStatsType &stats, const EventMap &to_pdf_map, int32 N, int32 P, const std::string &old_tree_rxfilename, const std::string &old_model_rxfilename, BaseFloat var_floor, AmDiagGmm *am_gmm)
	InitAmGmmFromOld initializes the GMM based on a previously trained model and tree, which must require no more phonetic context than the current tree. More...
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 220 of file gmm-init-model.cc.

References ContextDependency::CentralPosition(), ContextDependency::ContextWidth(), kaldi::DeleteBuildTreeStats(), ParseOptions::GetArg(), kaldi::GetOccs(), ParseOptions::GetOptArg(), kaldi::InitAmGmm(), kaldi::InitAmGmmFromOld(), KALDI_LOG, ParseOptions::NumArgs(), ParseOptions::PrintUsage(), ParseOptions::Read(), kaldi::ReadBuildTreeStats(), kaldi::ReadKaldiObject(), ParseOptions::Register(), Output::Stream(), Input::Stream(), ContextDependency::ToPdfMap(), AmDiagGmm::Write(), TransitionModel::Write(), and VectorBase< Real >::Write().

                                 {
  using namespace kaldi;
  try {
    using namespace kaldi;
    typedef kaldi::int32 int32;

    const char *usage =
        "Initialize GMM from decision tree and tree stats\n"
        "Usage:  gmm-init-model [options] <tree-in> <tree-stats-in> <topo-file> <model-out> [<old-tree> <old-model>]\n"
        "e.g.: \n"
        "  gmm-init-model tree treeacc topo 1.mdl\n"
        "or (initializing GMMs with old model):\n"
        "  gmm-init-model tree treeacc topo 1.mdl prev/tree prev/30.mdl\n";

    bool binary = true;
    double var_floor = 0.01;
    std::string occs_out_filename;


    ParseOptions po(usage);
    po.Register("binary", &binary, "Write output in binary mode");
    po.Register("write-occs", &occs_out_filename, "File to write state "
                "occupancies to.");
    po.Register("var-floor", &var_floor, "Variance floor used while "
                "initializing Gaussians");
    
    po.Read(argc, argv);

    if (po.NumArgs() != 4 && po.NumArgs() != 6) {
      po.PrintUsage();
      exit(1);
    }

    std::string
        tree_filename = po.GetArg(1),
        stats_filename = po.GetArg(2),
        topo_filename = po.GetArg(3),
        model_out_filename = po.GetArg(4),
        old_tree_filename = po.GetOptArg(5),
        old_model_filename = po.GetOptArg(6);

    ContextDependency ctx_dep;
    ReadKaldiObject(tree_filename, &ctx_dep);

    BuildTreeStatsType stats;
    {
      bool binary_in;
      GaussClusterable gc;  // dummy needed to provide type.
      Input ki(stats_filename, &binary_in);
      ReadBuildTreeStats(ki.Stream(), binary_in, gc, &stats);
    }
    KALDI_LOG << "Number of separate statistics is " << stats.size();

    HmmTopology topo;
    ReadKaldiObject(topo_filename, &topo);

    const EventMap &to_pdf = ctx_dep.ToPdfMap();  // not owned here.

    TransitionModel trans_model(ctx_dep, topo);
    
    // Now, the summed_stats will be used to initialize the GMM.
    AmDiagGmm am_gmm;
    if (old_tree_filename.empty())
      InitAmGmm(stats, to_pdf, &am_gmm, trans_model, var_floor);  // Normal case: initialize 1 Gauss/model from tree stats.
    else {
      InitAmGmmFromOld(stats, to_pdf,
                       ctx_dep.ContextWidth(),
                       ctx_dep.CentralPosition(),
                       old_tree_filename,
                       old_model_filename,
                       var_floor,
                       &am_gmm);
    }

    if (!occs_out_filename.empty()) {  // write state occs
      Vector<BaseFloat> occs;
      GetOccs(stats, to_pdf, &occs);
      Output ko(occs_out_filename, binary);
      occs.Write(ko.Stream(), binary);
    }

    {
      Output ko(model_out_filename, binary);
      trans_model.Write(ko.Stream(), binary);
      am_gmm.Write(ko.Stream(), binary);
    }
    KALDI_LOG << "Wrote model.";
    
    DeleteBuildTreeStats(&stats);
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}