gmm-init-model-flat.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-flat.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	GetFeatureMeanAndVariance (const std::string &feat_rspecifier, Vector< BaseFloat > *inv_var_out, Vector< BaseFloat > *mean_out)
int	main (int argc, char *argv[])

Function Documentation

main()

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

Definition at line 70 of file gmm-init-model-flat.cc.

References AmDiagGmm::AddPdf(), DiagGmm::ComputeGconsts(), VectorBase< Real >::Dim(), ParseOptions::GetArg(), kaldi::GetFeatureMeanAndVariance(), ParseOptions::GetOptArg(), rnnlm::i, KALDI_LOG, ParseOptions::NumArgs(), ContextDependency::NumPdfs(), ParseOptions::PrintUsage(), ParseOptions::Read(), kaldi::ReadKaldiObject(), ParseOptions::Register(), DiagGmm::Resize(), Vector< Real >::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::Set(), DiagGmm::SetInvVarsAndMeans(), DiagGmm::SetWeights(), Output::Stream(), AmDiagGmm::Write(), and TransitionModel::Write().

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

    const char *usage =
        "Initialize GMM, with Gaussians initialized to mean and variance\n"
        "of some provided example data (or to 0,1 if not provided: in that\n"
        "case, provide --dim option)\n"
        "Usage:  gmm-init-model-flat [options] <tree-in> <topo-file> <model-out> [<features-rspecifier>]\n"
        "e.g.: \n"
        "  gmm-init-model-flat tree topo 1.mdl ark:feats.scp\n";
    
    bool binary = true;
    int32 dim = 40;

    ParseOptions po(usage);
    po.Register("binary", &binary, "Write output in binary mode");
    po.Register("dim", &dim, "Dimension of model (this matters only if not providing features).");
    
    po.Read(argc, argv);

    if (po.NumArgs() < 3 || po.NumArgs() > 4) {
      po.PrintUsage();
      exit(1);
    }

    std::string
        tree_filename = po.GetArg(1),
        topo_filename = po.GetArg(2),
        model_out_filename = po.GetArg(3),
        feats_rspecifier = po.GetOptArg(4);

    ContextDependency ctx_dep;
    ReadKaldiObject(tree_filename, &ctx_dep);

    HmmTopology topo; 
    ReadKaldiObject(topo_filename, &topo);

    Vector<BaseFloat> global_inverse_var, global_mean;
    if (po.NumArgs() == 4) {
      GetFeatureMeanAndVariance(feats_rspecifier,
                                &global_inverse_var,
                                &global_mean);
      dim = global_mean.Dim();
    } else {
      global_inverse_var.Resize(dim);
      global_inverse_var.Set(1.0);
      global_mean.Resize(dim); // leave it at zero.
    }

    int32 num_pdfs = ctx_dep.NumPdfs();

    AmDiagGmm am_gmm;
    DiagGmm gmm;
    gmm.Resize(1, dim);
    {  // Initialize the gmm.
      Matrix<BaseFloat> inv_var(1, dim);
      inv_var.Row(0).CopyFromVec(global_inverse_var);
      Matrix<BaseFloat> mu(1, dim);
      mu.Row(0).CopyFromVec(global_mean);
      Vector<BaseFloat> weights(1);
      weights.Set(1.0);
      gmm.SetInvVarsAndMeans(inv_var, mu);
      gmm.SetWeights(weights);
      gmm.ComputeGconsts();
    }
    for (int i = 0; i < num_pdfs; i++)
      am_gmm.AddPdf(gmm);
    
    TransitionModel trans_model(ctx_dep, topo);

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