#include <vector>
#include "base/kaldi-math.h"
#include "gmm/model-test-common.h"
#include "sgmm2/am-sgmm2.h"
#include "sgmm2/fmllr-sgmm2.h"
#include "util/kaldi-io.h"

Include dependency graph for fmllr-sgmm2-test.cc:

Functions
void	ApplyFmllrXform (const kaldi::VectorBase< BaseFloat > &in, const Matrix< BaseFloat > &xf, Vector< BaseFloat > *out)

void	TestSgmm2FmllrAccsIO (const AmSgmm2 &sgmm, const kaldi::Matrix< BaseFloat > &feats)

void	TestSgmm2FmllrSubspace (const AmSgmm2 &sgmm, const kaldi::Matrix< BaseFloat > &feats)

void	TestSgmm2Fmllr ()

int	main ()

Function Documentation

◆ ApplyFmllrXform()

void ApplyFmllrXform	(	const kaldi::VectorBase< BaseFloat > &	in,
		const Matrix< BaseFloat > &	xf,
		Vector< BaseFloat > *	out
	)

Definition at line 38 of file fmllr-sgmm2-test.cc.

References VectorBase< Real >::AddMatVec(), VectorBase< Real >::Dim(), KALDI_ASSERT, kaldi::kNoTrans, kaldi::kSetZero, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and Vector< Real >::Resize().

Referenced by TestSgmm2FmllrAccsIO().

                                              {
   int32 dim = in.Dim();
   KALDI_ASSERT(xf.NumRows() == dim && xf.NumCols() == dim + 1);
   Vector<BaseFloat> tmp(dim + 1);
   tmp.Range(0, dim).CopyFromVec(in);
   tmp(dim) = 1.0;
   out->Resize(dim, kaldi::kSetZero);
   out->AddMatVec(1.0, xf, kaldi::kNoTrans, tmp, 0.0);
 }

◆ main()

int main ( )

Definition at line 237 of file fmllr-sgmm2-test.cc.

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

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

◆ TestSgmm2Fmllr()

void TestSgmm2Fmllr ( )

Definition at line 200 of file fmllr-sgmm2-test.cc.

References AmSgmm2::ComputeNormalizers(), rnnlm::d, kaldi::Exp(), AmSgmm2::InitializeFromFullGmm(), kaldi::unittest::InitRandFullGmm(), kaldi::unittest::RandDiagGaussFeatures(), kaldi::RandGauss(), kaldi::RandInt(), Matrix< Real >::Resize(), MatrixBase< Real >::Row(), TestSgmm2FmllrAccsIO(), and TestSgmm2FmllrSubspace().

Referenced by main().

                       {
   // srand(time(NULL));
   int32 dim = 1 + kaldi::RandInt(0, 9);  // random dimension of the gmm
   int32 num_comp = 2 + kaldi::RandInt(0, 9);  // random number of mixtures
   kaldi::FullGmm full_gmm;
   ut::InitRandFullGmm(dim, num_comp, &full_gmm);
 
   AmSgmm2 sgmm;
   kaldi::Sgmm2GselectConfig config;
   std::vector<int32> pdf2group;
   pdf2group.push_back(0);
   sgmm.InitializeFromFullGmm(full_gmm, pdf2group, dim+1, dim, true, 0.9);
   sgmm.ComputeNormalizers();
 
   kaldi::Matrix<BaseFloat> feats;
 
   {  // First, generate random means and variances
     int32 num_feat_comp = num_comp + kaldi::RandInt(-num_comp/2, num_comp/2);
     kaldi::Matrix<BaseFloat> means(num_feat_comp, dim),
         vars(num_feat_comp, dim);
     for (int32 m = 0; m < num_feat_comp; m++) {
       for (int32 d= 0; d < dim; d++) {
         means(m, d) = kaldi::RandGauss();
         vars(m, d) = Exp(kaldi::RandGauss()) + 1e-2;
       }
     }
     // Now generate random features with those means and variances.
     feats.Resize(num_feat_comp * 200, dim);
     for (int32 m = 0; m < num_feat_comp; m++) {
       kaldi::SubMatrix<BaseFloat> tmp(feats, m*200, 200, 0, dim);
       ut::RandDiagGaussFeatures(200, means.Row(m), vars.Row(m), &tmp);
     }
   }
   TestSgmm2FmllrAccsIO(sgmm, feats);
   TestSgmm2FmllrSubspace(sgmm, feats);
 }

◆ TestSgmm2FmllrAccsIO()

void TestSgmm2FmllrAccsIO	(	const AmSgmm2 &	sgmm,
		const kaldi::Matrix< BaseFloat > &	feats
	)

Definition at line 52 of file fmllr-sgmm2-test.cc.

References FmllrSgmm2Accs::Accumulate(), ApplyFmllrXform(), kaldi::AssertEqual(), AmSgmm2::ComputeFmllrPreXform(), AmSgmm2::ComputePerFrameVars(), AmSgmm2::FeatureDim(), Sgmm2FmllrConfig::fmllr_min_count, Sgmm2GselectConfig::full_gmm_nbest, AmSgmm2::GaussianSelection(), rnnlm::i, FmllrSgmm2Accs::Init(), Sgmm2FmllrGlobalParams::inv_xform_, KALDI_LOG, KALDI_WARN, AmSgmm2::LogLikelihood(), Sgmm2FmllrGlobalParams::mean_scatter_, AmSgmm2::NumGauss(), AmSgmm2::NumGroups(), AmSgmm2::NumPdfs(), MatrixBase< Real >::NumRows(), AmSgmm2::PhoneSpaceDim(), Sgmm2FmllrGlobalParams::pre_xform_, FmllrSgmm2Accs::Read(), Sgmm2PerFrameDerivedVars::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::Set(), MatrixBase< Real >::SetUnit(), Input::Stream(), FmllrSgmm2Accs::Update(), and FmllrSgmm2Accs::Write().

Referenced by TestSgmm2Fmllr().

                                                               {
   KALDI_LOG << "Test IO start.";
   using namespace kaldi;
   int32 dim = sgmm.FeatureDim();
   kaldi::Sgmm2PerFrameDerivedVars frame_vars;
   kaldi::Sgmm2PerSpkDerivedVars empty;
   kaldi::Sgmm2FmllrGlobalParams fmllr_globals;
   kaldi::Sgmm2GselectConfig sgmm_config;
 
   frame_vars.Resize(sgmm.NumGauss(), dim, sgmm.PhoneSpaceDim());
   sgmm_config.full_gmm_nbest = std::min(sgmm_config.full_gmm_nbest,
                                         sgmm.NumGauss());
   kaldi::Vector<BaseFloat> occs(sgmm.NumPdfs());
   occs.Set(feats.NumRows());
   sgmm.ComputeFmllrPreXform(occs, &fmllr_globals.pre_xform_,
                             &fmllr_globals.inv_xform_,
                             &fmllr_globals.mean_scatter_);
   if (fmllr_globals.mean_scatter_.Min() == 0.0) {
     KALDI_WARN << "Global covariances low rank!";
     KALDI_WARN << "Diag-scatter = " << fmllr_globals.mean_scatter_;
     return;
   }
 
 //  std::cout << "Pre-Xform = " << fmllr_globals.pre_xform_;
 //  std::cout << "Inv-Xform = " << fmllr_globals.inv_xform_;
 
   FmllrSgmm2Accs accs;
   accs.Init(sgmm.FeatureDim(), sgmm.NumGauss());
   BaseFloat loglike = 0.0;
   std::vector<int32> gselect;
   for (int32 i = 0; i < feats.NumRows(); i++) {
     sgmm.GaussianSelection(sgmm_config, feats.Row(i), &gselect);
     sgmm.ComputePerFrameVars(feats.Row(i), gselect, empty, &frame_vars);
     loglike += accs.Accumulate(sgmm, feats.Row(i), frame_vars, 0, 1.0,
                                &empty);
   }
 
   kaldi::Sgmm2FmllrConfig update_opts;
   update_opts.fmllr_min_count = 999; // Make sure it doesn't
   // divide 200, because the test can fail when we cross the boundary
   // of 1000 due to roundoff.  Actually it's weird because 1000 should
   // be exactly representable in float and in text.  But something's going wrong.
   kaldi::Matrix<BaseFloat> xform_mat(dim, dim+1);
   xform_mat.SetUnit();
   BaseFloat frames, impr;
   accs.Update(sgmm, fmllr_globals, update_opts, &xform_mat, &frames, &impr);
 
   Vector<BaseFloat> xformed_feat(dim);
   ApplyFmllrXform(feats.Row(0), xform_mat, &xformed_feat);
   sgmm.GaussianSelection(sgmm_config, xformed_feat, &gselect);
   sgmm.ComputePerFrameVars(xformed_feat, gselect, empty, &frame_vars);
 
   Sgmm2LikelihoodCache like_cache(sgmm.NumGroups(), sgmm.NumPdfs());
   BaseFloat loglike1 = sgmm.LogLikelihood(frame_vars, 0,
                                           &like_cache, &empty);
 
   bool binary_in;
   // First, non-binary write
   KALDI_LOG << "Test ASCII IO.";
   accs.Write(kaldi::Output("tmpf", false).Stream(), false);
   FmllrSgmm2Accs *accs1 = new FmllrSgmm2Accs();
   // Non-binary read
   kaldi::Input ki1("tmpf", &binary_in);
   accs1->Read(ki1.Stream(), binary_in, false);
   xform_mat.SetUnit();
   accs1->Update(sgmm, fmllr_globals, update_opts, &xform_mat, NULL, NULL);
   ApplyFmllrXform(feats.Row(0), xform_mat, &xformed_feat);
   sgmm.GaussianSelection(sgmm_config, xformed_feat, &gselect);
   sgmm.ComputePerFrameVars(xformed_feat, gselect, empty, &frame_vars);
   like_cache.NextFrame();
   BaseFloat loglike2 = sgmm.LogLikelihood(frame_vars, 0,
                                           &like_cache, &empty);
   std::cout << "LL1 = " << loglike1 << ", LL2 = " << loglike2 << std::endl;
   
   kaldi::AssertEqual(loglike1, loglike2, 1e-2);
   delete accs1;
 
   // Next, binary write
   KALDI_LOG << "Test Binary IO.";
   accs.Write(kaldi::Output("tmpfb", true).Stream(), true);
   FmllrSgmm2Accs *accs2 = new FmllrSgmm2Accs();
   // Binary read
   kaldi::Input ki2("tmpfb", &binary_in);
   accs2->Read(ki2.Stream(), binary_in, false);
   xform_mat.SetUnit();
   accs2->Update(sgmm, fmllr_globals, update_opts, &xform_mat, NULL, NULL);
   ApplyFmllrXform(feats.Row(0), xform_mat, &xformed_feat);
   sgmm.GaussianSelection(sgmm_config, xformed_feat, &gselect);
   sgmm.ComputePerFrameVars(xformed_feat, gselect, empty,  &frame_vars);
   BaseFloat loglike3 = sgmm.LogLikelihood(frame_vars, 0,
                                           &like_cache, &empty);
   std::cout << "LL1 = " << loglike1 << ", LL3 = " << loglike3 << std::endl;
   kaldi::AssertEqual(loglike1, loglike3, 1e-4);
   delete accs2;
   
   unlink("tmpf");
   unlink("tmpfb");
   KALDI_LOG << "Test IO end.";
 }

◆ TestSgmm2FmllrSubspace()

void TestSgmm2FmllrSubspace	(	const AmSgmm2 &	sgmm,
		const kaldi::Matrix< BaseFloat > &	feats
	)

Definition at line 153 of file fmllr-sgmm2-test.cc.

References FmllrSgmm2Accs::Accumulate(), FmllrSgmm2Accs::AccumulateForFmllrSubspace(), AmSgmm2::ComputeFmllrPreXform(), AmSgmm2::ComputePerFrameVars(), kaldi::EstimateSgmm2FmllrSubspace(), AmSgmm2::FeatureDim(), Sgmm2GselectConfig::full_gmm_nbest, AmSgmm2::GaussianSelection(), rnnlm::i, FmllrSgmm2Accs::Init(), Sgmm2FmllrGlobalParams::inv_xform_, KALDI_LOG, KALDI_WARN, Sgmm2FmllrGlobalParams::mean_scatter_, Sgmm2FmllrConfig::num_fmllr_bases, AmSgmm2::NumGauss(), AmSgmm2::NumPdfs(), MatrixBase< Real >::NumRows(), AmSgmm2::PhoneSpaceDim(), Sgmm2FmllrGlobalParams::pre_xform_, Sgmm2PerFrameDerivedVars::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::Set(), MatrixBase< Real >::SetUnit(), and FmllrSgmm2Accs::Update().