gmm-init-biphone.cc File Reference

#include "base/kaldi-common.h"
#include "util/common-utils.h"
#include "gmm/am-diag-gmm.h"
#include "tree/event-map.h"
#include "tree/context-dep.h"
#include "hmm/hmm-topology.h"
#include "hmm/transition-model.h"

Include dependency graph for gmm-init-biphone.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	ReadSharedPhonesList (std::string rxfilename, std::vector< std::vector< int32 > > *list_out)
EventMap *	GetFullBiphoneStubMap (const std::vector< std::vector< int32 > > &phone_sets, const std::vector< int32 > &phone2num_pdf_classes, const std::vector< int32 > &ci_phones_list, const std::vector< std::vector< int32 > > &bi_counts, int32 biphone_min_count, const std::vector< int32 > &mono_counts, int32 mono_min_count)
ContextDependency *	BiphoneContextDependencyFull (std::vector< std::vector< int32 > > phone_sets, const std::vector< int32 > phone2num_pdf_classes, const std::vector< int32 > &ci_phones_list, const std::vector< std::vector< int32 > > &bi_counts, int32 biphone_min_count, const std::vector< int32 > &mono_counts, int32 mono_min_count)
static void	ReadPhoneCounts (std::string &filename, int32 num_phones, std::vector< int32 > *mono_counts, std::vector< std::vector< int32 > > *bi_counts)
int	main (int argc, char *argv[])

Function Documentation

main()

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

Definition at line 254 of file gmm-init-biphone.cc.

References AmDiagGmm::AddPdf(), kaldi::BiphoneContextDependencyFull(), DiagGmm::ComputeGconsts(), kaldi::ConvertStringToInteger(), ParseOptions::GetArg(), HmmTopology::GetPhones(), rnnlm::i, kaldi::IsSortedAndUniq(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, ParseOptions::NumArgs(), HmmTopology::NumPdfClasses(), ContextDependency::NumPdfs(), ParseOptions::PrintUsage(), ParseOptions::Read(), HmmTopology::Read(), ReadPhoneCounts(), kaldi::ReadSharedPhonesList(), ParseOptions::Register(), DiagGmm::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::Set(), DiagGmm::SetInvVarsAndMeans(), DiagGmm::SetWeights(), kaldi::SplitStringToIntegers(), Output::Stream(), Input::Stream(), AmDiagGmm::Write(), ContextDependency::Write(), and TransitionModel::Write().

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

    const char *usage =
        "Initialize a biphone context-dependency tree with all the\n"
        "leaves (i.e. a full tree). Intended for end-to-end tree-free models.\n"
        "Usage:  gmm-init-biphone <topology-in> <dim> <model-out> <tree-out> \n"
        "e.g.: \n"
        " gmm-init-biphone topo 39 bi.mdl bi.tree\n";

    bool binary = true;
    std::string shared_phones_rxfilename, phone_counts_rxfilename;
    int32 min_biphone_count = 100, min_mono_count = 20;
    std::string ci_phones_str;
    std::vector<int32> ci_phones;  // Sorted, uniqe vector of
    // context-independent phones.

    ParseOptions po(usage);
    po.Register("binary", &binary, "Write output in binary mode");
    po.Register("shared-phones", &shared_phones_rxfilename,
                "rxfilename containing, on each line, a list of phones "
                "whose pdfs should be shared.");
    po.Register("ci-phones", &ci_phones_str, "Colon-separated list of "
                "integer indices of context-independent phones.");
    po.Register("phone-counts", &phone_counts_rxfilename,
                "rxfilename containing, on each line, a biphone/phone and "
                "its count in the training data.");
    po.Register("min-biphone-count", &min_biphone_count, "Minimum number of "
                "occurences of a biphone in training data to reserve pdfs "
                "for it.");
    po.Register("min-monophone-count", &min_mono_count, "Minimum number of "
                "occurences of a monophone in training data to reserve pdfs "
                "for it.");
    po.Read(argc, argv);

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


    std::string topo_filename = po.GetArg(1);
    int dim = 0;
    if (!ConvertStringToInteger(po.GetArg(2), &dim) || dim <= 0 || dim > 10000)
      KALDI_ERR << "Bad dimension:" << po.GetArg(2)
                << ". It should be a positive integer.";
    std::string model_filename = po.GetArg(3);
    std::string tree_filename = po.GetArg(4);

    if (!ci_phones_str.empty()) {
      SplitStringToIntegers(ci_phones_str, ":", false, &ci_phones);
      std::sort(ci_phones.begin(), ci_phones.end());
      if (!IsSortedAndUniq(ci_phones) || ci_phones.empty() || ci_phones[0] == 0)
        KALDI_ERR << "Invalid --ci-phones option: " << ci_phones_str;
    }

    Vector<BaseFloat> glob_inv_var(dim);
    glob_inv_var.Set(1.0);
    Vector<BaseFloat> glob_mean(dim);
    glob_mean.Set(1.0);

    HmmTopology topo;
    bool binary_in;
    Input ki(topo_filename, &binary_in);
    topo.Read(ki.Stream(), binary_in);

    const std::vector<int32> &phones = topo.GetPhones();

    std::vector<int32> phone2num_pdf_classes(1 + phones.back());
    for (size_t i = 0; i < phones.size(); i++) {
      phone2num_pdf_classes[phones[i]] = topo.NumPdfClasses(phones[i]);
      // For now we only support 1 or 2 pdf's per phone
      KALDI_ASSERT(phone2num_pdf_classes[phones[i]] == 1 ||
                   phone2num_pdf_classes[phones[i]] == 2);
    }

    std::vector<int32> mono_counts;
    std::vector<std::vector<int32> > bi_counts;
    if (!phone_counts_rxfilename.empty()) {
      ReadPhoneCounts(phone_counts_rxfilename, phones.size(),
                      &mono_counts, &bi_counts);
      KALDI_LOG << "Loaded mono/bi phone counts.";
    }


    // Now the tree:
    ContextDependency *ctx_dep = NULL;
    std::vector<std::vector<int32> > shared_phones;
    if (shared_phones_rxfilename == "") {
      shared_phones.resize(phones.size());
      for (size_t i = 0; i < phones.size(); i++)
        shared_phones[i].push_back(phones[i]);
    } else {
      ReadSharedPhonesList(shared_phones_rxfilename, &shared_phones);
      // ReadSharedPhonesList crashes on error.
    }
    ctx_dep = BiphoneContextDependencyFull(shared_phones, phone2num_pdf_classes,
                                           ci_phones, bi_counts,
                                           min_biphone_count,
                                           mono_counts, min_mono_count);

    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(glob_inv_var);
      Matrix<BaseFloat> mu(1, dim);
      mu.Row(0).CopyFromVec(glob_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);

    // Now the transition model:
    TransitionModel trans_model(*ctx_dep, topo);

    {
      Output ko(model_filename, binary);
      trans_model.Write(ko.Stream(), binary);
      am_gmm.Write(ko.Stream(), binary);
    }

    // Now write the tree.
    ctx_dep->Write(Output(tree_filename, binary).Stream(),
                   binary);

    delete ctx_dep;
    return 0;
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}

ReadPhoneCounts()

static void ReadPhoneCounts ( std::string &  filename, int32  num_phones, std::vector< int32 > *  mono_counts, std::vector< std::vector< int32 > > *  bi_counts  )

static

Definition at line 225 of file gmm-init-biphone.cc.

References KALDI_ASSERT, and KALDI_ERR.

Referenced by main().

                                                                     {
  // The actual phones start from id = 1 (so the last phone has id = num_phones).
  mono_counts->resize(num_phones + 1, 0);
  bi_counts->resize(num_phones + 1, std::vector<int>(num_phones + 1, 0));
  std::ifstream infile(filename);
  std::string line;
  while (std::getline(infile, line)) {
    std::istringstream iss(line);
    int a, b;
    long c;
    if ((std::istringstream(line) >> a >> b >> c)) {
      // It's a biphone count.
      KALDI_ASSERT(a >= 0 && a <= num_phones);  // 0 means no-left-context
      KALDI_ASSERT(b > 0 && b <= num_phones);
      KALDI_ASSERT(c >= 0);
      (*bi_counts)[a][b] = c;
    } else if ((std::istringstream(line) >> b >> c)) {
      // It's a monophone count.
      KALDI_ASSERT(b > 0 && b <= num_phones);
      KALDI_ASSERT(c >= 0);
      (*mono_counts)[b] = c;
    } else {
      KALDI_ERR << "Bad line in phone stats file: " << line;
    }
  }
}