regtree-mllr-diag-gmm-test.cc File Reference

#include "util/common-utils.h"
#include "gmm/diag-gmm.h"
#include "gmm/mle-diag-gmm.h"
#include "gmm/mle-am-diag-gmm.h"
#include "gmm/model-test-common.h"
#include "transform/regtree-mllr-diag-gmm.h"

Include dependency graph for regtree-mllr-diag-gmm-test.cc:

Go to the source code of this file.

Functions
void	TestMllrAccsIO (const kaldi::AmDiagGmm &am_gmm, const kaldi::RegressionTree &regtree, const RegtreeMllrDiagGmmAccs &accs, const kaldi::Matrix< BaseFloat > adapt_data)
void	TestXformMean (const kaldi::AmDiagGmm &am_gmm, const kaldi::RegressionTree &regtree, const RegtreeMllrDiagGmmAccs &accs, const kaldi::Matrix< BaseFloat > adapt_data)
void	UnitTestRegtreeMllrDiagGmm ()
int	main ()

Function Documentation

main()

int main

(

)

Definition at line 188 of file regtree-mllr-diag-gmm-test.cc.

References kaldi::g_kaldi_verbose_level, rnnlm::i, and UnitTestRegtreeMllrDiagGmm().

           {
  kaldi::g_kaldi_verbose_level = 5;
  for (int i = 0; i <= 10; i++)
    UnitTestRegtreeMllrDiagGmm();
  std::cout << "Test OK.\n";
}

TestMllrAccsIO()

void TestMllrAccsIO	(	const kaldi::AmDiagGmm &	am_gmm,
		const kaldi::RegressionTree &	regtree,
		const RegtreeMllrDiagGmmAccs &	accs,
		const kaldi::Matrix< BaseFloat >	adapt_data
	)

Definition at line 33 of file regtree-mllr-diag-gmm-test.cc.

References kaldi::AssertEqual(), AmDiagGmm::CopyFromAmDiagGmm(), AmDiagGmm::Dim(), DiagGmm::Generate(), kaldi::unittest::InitRandDiagGmm(), rnnlm::j, KALDI_LOG, AmDiagGmm::LogLikelihood(), RegtreeMllrOptions::min_count, MatrixBase< Real >::NumRows(), kaldi::RandInt(), RegtreeMllrDiagGmmAccs::Read(), MatrixBase< Real >::Row(), Input::Stream(), RegtreeMllrDiagGmm::TransformModel(), RegtreeMllrDiagGmmAccs::Update(), RegtreeMllrOptions::use_regtree, and RegtreeMllrDiagGmmAccs::Write().

Referenced by UnitTestRegtreeMllrDiagGmm().

                                                             {
  // First, non-binary write
  accs.Write(kaldi::Output("tmpf", false).Stream(), false);

  kaldi::RegtreeMllrDiagGmm mllr;
  kaldi::RegtreeMllrOptions opts;
  opts.min_count = 100;
  opts.use_regtree = false;
  accs.Update(regtree, opts, &mllr, NULL, NULL);
  kaldi::AmDiagGmm am1;
  am1.CopyFromAmDiagGmm(am_gmm);
  mllr.TransformModel(regtree, &am1);

  BaseFloat loglike = 0;
  int32 npoints = adapt_data.NumRows();
  for (int32 j = 0; j < npoints; j++) {
    loglike += am1.LogLikelihood(0, adapt_data.Row(j));
  }
  KALDI_LOG << "Per-frame loglike after adaptation = " << (loglike/npoints)
            << " over " << npoints << " frames.";

  size_t num_comp2 = 1 + kaldi::RandInt(0, 9);  // random number of mixtures
  int32 dim = am_gmm.Dim();
  kaldi::DiagGmm gmm2;
  ut::InitRandDiagGmm(dim, num_comp2, &gmm2);
  kaldi::Vector<BaseFloat> data(dim);
  gmm2.Generate(&data);
  BaseFloat loglike1 = am1.LogLikelihood(0, data);
//  KALDI_LOG << "LL0 = " << loglike0 << "; LL1 = " << loglike1;

  KALDI_LOG << "Test ASCII IO.";
  bool binary_in;
  kaldi::RegtreeMllrDiagGmm mllr1;
  RegtreeMllrDiagGmmAccs *accs1 = new RegtreeMllrDiagGmmAccs();
  // Non-binary read
  kaldi::Input ki1("tmpf", &binary_in);
  accs1->Read(ki1.Stream(), binary_in, false);
  accs1->Update(regtree, opts, &mllr1, NULL, NULL);
  delete accs1;
  kaldi::AmDiagGmm am2;
  am2.CopyFromAmDiagGmm(am_gmm);
  mllr.TransformModel(regtree, &am2);
  BaseFloat loglike2 = am2.LogLikelihood(0, data);
//  KALDI_LOG << "LL1 = " << loglike1 << "; LL2 = " << loglike2;
  kaldi::AssertEqual(loglike1, loglike2, 1e-6);

  kaldi::RegtreeMllrDiagGmm mllr2;
  // Next, binary write
  KALDI_LOG << "Test Binary IO.";
  accs.Write(kaldi::Output("tmpfb", true).Stream(), true);
  RegtreeMllrDiagGmmAccs *accs2 = new RegtreeMllrDiagGmmAccs();
  // Binary read
  kaldi::Input ki2("tmpfb", &binary_in);
  accs2->Read(ki2.Stream(), binary_in, false);
  accs2->Update(regtree, opts, &mllr2, NULL, NULL);
  delete accs2;
  kaldi::AmDiagGmm am3;
  am3.CopyFromAmDiagGmm(am_gmm);
  mllr.TransformModel(regtree, &am3);
  BaseFloat loglike3 = am3.LogLikelihood(0, data);
//  KALDI_LOG << "LL1 = " << loglike1 << "; LL3 = " << loglike3;
  kaldi::AssertEqual(loglike1, loglike3, 1e-6);
  
  unlink("tmpf");
  unlink("tmpfb");
}

TestXformMean()

void TestXformMean	(	const kaldi::AmDiagGmm &	am_gmm,
		const kaldi::RegressionTree &	regtree,
		const RegtreeMllrDiagGmmAccs &	accs,
		const kaldi::Matrix< BaseFloat >	adapt_data
	)

Definition at line 103 of file regtree-mllr-diag-gmm-test.cc.

References kaldi::AssertEqual(), DiagGmm::ComputeGconsts(), AmDiagGmm::CopyFromAmDiagGmm(), DiagGmm::CopyFromDiagGmm(), AmDiagGmm::Dim(), AmDiagGmm::GetPdf(), RegtreeMllrDiagGmm::GetTransformedMeans(), DiagGmm::inv_vars(), rnnlm::j, KALDI_LOG, AmDiagGmm::LogLikelihood(), DiagGmm::LogLikelihood(), RegtreeMllrOptions::min_count, DiagGmm::NumGauss(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::Row(), DiagGmm::SetInvVarsAndMeans(), RegtreeMllrDiagGmm::TransformModel(), RegtreeMllrDiagGmmAccs::Update(), and RegtreeMllrOptions::use_regtree.

Referenced by UnitTestRegtreeMllrDiagGmm().

                                                            {
  kaldi::RegtreeMllrDiagGmm mllr;
  kaldi::RegtreeMllrOptions opts;
  opts.min_count = 100;
  opts.use_regtree = false;
  accs.Update(regtree, opts, &mllr, NULL, NULL);

  kaldi::AmDiagGmm am1;
  am1.CopyFromAmDiagGmm(am_gmm);
  mllr.TransformModel(regtree, &am1);

  kaldi::DiagGmm tmp_pdf;
  tmp_pdf.CopyFromDiagGmm(am_gmm.GetPdf(0));
  kaldi::Matrix<BaseFloat> tmp_means(am_gmm.GetPdf(0).NumGauss(), am_gmm.Dim());
  mllr.GetTransformedMeans(regtree, am_gmm, 0, &tmp_means);
  tmp_pdf.SetInvVarsAndMeans(tmp_pdf.inv_vars(), tmp_means);
  tmp_pdf.ComputeGconsts();

  BaseFloat loglike0 = 0, loglike = 0;
  int32 npoints = adapt_data.NumRows();
  for (int32 j = 0; j < npoints; j++) {
    loglike0 += am1.LogLikelihood(0, adapt_data.Row(j));
    loglike += tmp_pdf.LogLikelihood(adapt_data.Row(j));
  }
  KALDI_LOG << "Per-frame loglike after adaptation = " << (loglike0/npoints)
            << " over " << npoints << " frames.";
//  KALDI_LOG << "LL0 = " << loglike0 << "; LL = " << loglike;
  kaldi::AssertEqual(loglike0, loglike, 1e-6);

  kaldi::Matrix<BaseFloat> tmp_means2(am_gmm.GetPdf(0).NumGauss(), am_gmm.Dim());
  mllr.GetTransformedMeans(regtree, am_gmm, 0, &tmp_means2);
  tmp_pdf.SetInvVarsAndMeans(tmp_pdf.inv_vars(), tmp_means2);
  tmp_pdf.ComputeGconsts();

  BaseFloat loglike1 = 0;
  for (int32 j = 0; j < npoints; j++) {
    loglike1 += tmp_pdf.LogLikelihood(adapt_data.Row(j));
  }
//  KALDI_LOG << "LL = " << loglike << "; LL1 = " << loglike1;
  kaldi::AssertEqual(loglike, loglike1, 1e-6);
}

UnitTestRegtreeMllrDiagGmm()

void UnitTestRegtreeMllrDiagGmm

(

)

Definition at line 149 of file regtree-mllr-diag-gmm-test.cc.

References RegtreeMllrDiagGmmAccs::AccumulateForGmm(), RegressionTree::BuildTree(), DiagGmm::Generate(), AmDiagGmm::Init(), RegtreeMllrDiagGmmAccs::Init(), kaldi::unittest::InitRandDiagGmm(), rnnlm::j, KALDI_LOG, RegressionTree::NumBaseclasses(), kaldi::RandInt(), TestMllrAccsIO(), and TestXformMean().

Referenced by main().

                                  {
  size_t dim = 1 + kaldi::RandInt(1, 9);  // random dimension of the gmm
  size_t num_comp = 1 + kaldi::RandInt(0, 5);  // random number of mixtures
  kaldi::DiagGmm gmm;
  ut::InitRandDiagGmm(dim, num_comp, &gmm);
  kaldi::AmDiagGmm am_gmm;
  am_gmm.Init(gmm, 1);

  size_t num_comp2 = 1 + kaldi::RandInt(0, 5);  // random number of mixtures
  kaldi::DiagGmm gmm2;
  ut::InitRandDiagGmm(dim, num_comp2, &gmm2);
  int32 npoints = dim*(dim+1)*10 + 500;
  kaldi::Matrix<BaseFloat> adapt_data(npoints, dim);
  for (int32 j = 0; j < npoints; j++) {
    kaldi::SubVector<BaseFloat> row(adapt_data, j);
    gmm2.Generate(&row);
  }

  kaldi::RegressionTree regtree;
  std::vector<int32> sil_indices;
  kaldi::Vector<BaseFloat> state_occs(1);
  state_occs(0) = npoints;
  regtree.BuildTree(state_occs, sil_indices, am_gmm, 1);
  int32 num_bclass = regtree.NumBaseclasses();

  kaldi::RegtreeMllrDiagGmmAccs accs;
  BaseFloat loglike = 0;
  accs.Init(num_bclass, dim);
  for (int32 j = 0; j < npoints; j++) {
    loglike += accs.AccumulateForGmm(regtree, am_gmm, adapt_data.Row(j),
                                     0, 1.0);
  }
  KALDI_LOG << "Per-frame loglike during accumulations = " << (loglike/npoints)
            << " over " << npoints << " frames.";

  TestMllrAccsIO(am_gmm, regtree, accs, adapt_data);
  TestXformMean(am_gmm, regtree, accs, adapt_data);
}