Class for computing the maximum-likelihood estimates of the parameters of an acoustic model that uses diagonal Gaussian mixture models as emission densities. More...

#include <regtree-mllr-diag-gmm.h>

Collaboration diagram for RegtreeMllrDiagGmmAccs:

[legend]

Public Member Functions
	RegtreeMllrDiagGmmAccs ()

	~RegtreeMllrDiagGmmAccs ()

void	Init (int32 num_bclass, int32 dim)

void	SetZero ()

BaseFloat	AccumulateForGmm (const RegressionTree &regtree, const AmDiagGmm &am, const VectorBase< BaseFloat > &data, int32 pdf_index, BaseFloat weight)
	Accumulate stats for a single GMM in the model; returns log likelihood. More...

void	AccumulateForGaussian (const RegressionTree &regtree, const AmDiagGmm &am, const VectorBase< BaseFloat > &data, int32 pdf_index, int32 gauss_index, BaseFloat weight)
	Accumulate stats for a single Gaussian component in the model. More...

void	Update (const RegressionTree &regtree, const RegtreeMllrOptions &opts, RegtreeMllrDiagGmm out_mllr, BaseFloat auxf_impr, BaseFloat *t) const

void	Write (std::ostream &out_stream, bool binary) const

void	Read (std::istream &in_stream, bool binary, bool add)

int32	Dim () const
	Accessors. More...

int32	NumBaseClasses () const

const std::vector< AffineXformStats * > &	baseclass_stats () const

Private Member Functions
BaseFloat	MllrObjFunction (const Matrix< BaseFloat > &xform, int32 bclass_id) const
	Returns the MLLR objective function for a given transform and baseclass. More...

	KALDI_DISALLOW_COPY_AND_ASSIGN (RegtreeMllrDiagGmmAccs)

Private Attributes
std::vector< AffineXformStats * >	baseclass_stats_
	Per-baseclass stats; used for accumulation. More...

int32	num_baseclasses_
	Number of baseclasses. More...

int32	dim_
	Dimension of feature vectors. More...

Detailed Description

Class for computing the maximum-likelihood estimates of the parameters of an acoustic model that uses diagonal Gaussian mixture models as emission densities.

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

Constructor & Destructor Documentation

◆ RegtreeMllrDiagGmmAccs()

RegtreeMllrDiagGmmAccs ( )

inline

Definition at line 105 of file regtree-mllr-diag-gmm.h.

105 {}

◆ ~RegtreeMllrDiagGmmAccs()

~RegtreeMllrDiagGmmAccs ( )

inline

Definition at line 106 of file regtree-mllr-diag-gmm.h.

References kaldi::DeletePointers().

106 { DeletePointers(&baseclass_stats_); }

kaldi::DeletePointers

void DeletePointers(std::vector< A *> *v)

Deletes any non-NULL pointers in the vector v, and sets the corresponding entries of v to NULL...

Definition: stl-utils.h:184

kaldi::RegtreeMllrDiagGmmAccs::baseclass_stats_

std::vector< AffineXformStats * > baseclass_stats_

Per-baseclass stats; used for accumulation.

Definition: regtree-mllr-diag-gmm.h:141

Member Function Documentation

◆ AccumulateForGaussian()

void AccumulateForGaussian	(	const RegressionTree &	regtree,
		const AmDiagGmm &	am,
		const VectorBase< BaseFloat > &	data,
		int32	pdf_index,
		int32	gauss_index,
		BaseFloat	weight
	)

Accumulate stats for a single Gaussian component in the model.

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

References SpMatrix< Real >::AddVec2(), VectorBase< Real >::CopyFromVec(), rnnlm::d, RegtreeMllrDiagGmm::dim_, RegressionTree::Gauss2BaseclassId(), DiagGmm::GetComponentMean(), AmDiagGmm::GetPdf(), DiagGmm::inv_vars(), VectorBase< Real >::MulElements(), and MatrixBase< Real >::Row().

                       {
   const DiagGmm &pdf = am.GetPdf(pdf_index);
   Vector<double> data_d(data);
   Vector<double> inv_var_x(dim_);
   Vector<double> extended_mean(dim_+1);
   double weight_d = static_cast<double>(weight);
 
   unsigned bclass = regtree.Gauss2BaseclassId(pdf_index, gauss_index);
   inv_var_x.CopyFromVec(pdf.inv_vars().Row(gauss_index));
   inv_var_x.MulElements(data_d);
 
   // Using SubVector to stop compiler warning
   SubVector<double> tmp_mean(extended_mean, 0, dim_);
   pdf.GetComponentMean(gauss_index, &tmp_mean);  // modifies extended_mean
   extended_mean(dim_) = 1.0;
   SpMatrix<double> mean_scatter(dim_+1);
   mean_scatter.AddVec2(1.0, extended_mean);
 
   baseclass_stats_[bclass]->beta_ += weight_d;
   baseclass_stats_[bclass]->K_.AddVecVec(weight_d, inv_var_x, extended_mean);
   vector< SpMatrix<double> > &G = baseclass_stats_[bclass]->G_;
   for (int32 d = 0; d < dim_; d++)
     G[d].AddSp((weight_d * pdf.inv_vars()(gauss_index, d)), mean_scatter);
 }

◆ AccumulateForGmm()

BaseFloat AccumulateForGmm	(	const RegressionTree &	regtree,
		const AmDiagGmm &	am,
		const VectorBase< BaseFloat > &	data,
		int32	pdf_index,
		BaseFloat	weight
	)

Accumulate stats for a single GMM in the model; returns log likelihood.

This does not work with multiple feature transforms.

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

References SpMatrix< Real >::AddVec2(), DiagGmm::ComponentPosteriors(), VectorBase< Real >::CopyFromVec(), rnnlm::d, RegtreeMllrDiagGmm::dim_, RegressionTree::Gauss2BaseclassId(), DiagGmm::GetComponentMean(), AmDiagGmm::GetPdf(), DiagGmm::inv_vars(), VectorBase< Real >::MulElements(), DiagGmm::NumGauss(), MatrixBase< Real >::Row(), VectorBase< Real >::Scale(), and PackedMatrix< Real >::SetZero().

Referenced by main(), and UnitTestRegtreeMllrDiagGmm().

                                                                           {
   const DiagGmm &pdf = am.GetPdf(pdf_index);
   int32 num_comp = static_cast<int32>(pdf.NumGauss());
   Vector<BaseFloat> posterior(num_comp);
   BaseFloat loglike = pdf.ComponentPosteriors(data, &posterior);
   posterior.Scale(weight);
   Vector<double> posterior_d(posterior);
 
   Vector<double> data_d(data);
   Vector<double> inv_var_x(dim_);
   Vector<double> extended_mean(dim_+1);
   SpMatrix<double> mean_scatter(dim_+1);
 
   for (int32 m = 0; m < num_comp; m++) {
     unsigned bclass = regtree.Gauss2BaseclassId(pdf_index, m);
     inv_var_x.CopyFromVec(pdf.inv_vars().Row(m));
     inv_var_x.MulElements(data_d);
 
     // Using SubVector to stop compiler warning
     SubVector<double> tmp_mean(extended_mean, 0, dim_);
     pdf.GetComponentMean(m, &tmp_mean);  // modifies extended_mean
     extended_mean(dim_) = 1.0;
     mean_scatter.SetZero();
     mean_scatter.AddVec2(1.0, extended_mean);
 
     baseclass_stats_[bclass]->beta_ += posterior_d(m);
     baseclass_stats_[bclass]->K_.AddVecVec(posterior_d(m), inv_var_x,
                                            extended_mean);
     vector< SpMatrix<double> > &G = baseclass_stats_[bclass]->G_;
     for (int32 d = 0; d < dim_; d++)
       G[d].AddSp((posterior_d(m) * pdf.inv_vars()(m, d)), mean_scatter);
   }
   return loglike;
 }

◆ baseclass_stats()

const std::vector<AffineXformStats*>& baseclass_stats ( ) const

inline

Definition at line 135 of file regtree-mllr-diag-gmm.h.

                                                               {
     return baseclass_stats_;
   }

◆ Dim()

int32 Dim ( ) const

inline

Accessors.

Definition at line 133 of file regtree-mllr-diag-gmm.h.

133 { return dim_; }

kaldi::RegtreeMllrDiagGmmAccs::dim_

int32 dim_

Dimension of feature vectors.

Definition: regtree-mllr-diag-gmm.h:143

◆ Init()

void Init	(	int32	num_bclass,
		int32	dim
	)

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

References kaldi::DeletePointers(), RegtreeMllrDiagGmm::dim_, and KALDI_ASSERT.

Referenced by main(), and UnitTestRegtreeMllrDiagGmm().

                                                              {
   if (num_bclass == 0) {  // empty stats
     DeletePointers(&baseclass_stats_);
     baseclass_stats_.clear();
     num_baseclasses_ = 0;
     dim_ = 0;  // non-zero dimension is meaningless in empty stats
   } else {
     KALDI_ASSERT(dim != 0);  // if not empty, dim = 0 is meaningless
     num_baseclasses_ = num_bclass;
     dim_ = dim;
     baseclass_stats_.resize(num_baseclasses_);
     for (vector<AffineXformStats*>::iterator it = baseclass_stats_.begin(),
         end = baseclass_stats_.end(); it != end; ++it) {
       *it = new AffineXformStats();
       (*it)->Init(dim_, dim_);
     }
   }
 }

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( RegtreeMllrDiagGmmAccs )

private

◆ MllrObjFunction()

BaseFloat MllrObjFunction	(	const Matrix< BaseFloat > &	xform,
		int32	bclass_id
	)		const

private

Returns the MLLR objective function for a given transform and baseclass.

◆ NumBaseClasses()

int32 NumBaseClasses ( ) const

inline

Definition at line 134 of file regtree-mllr-diag-gmm.h.

134 { return num_baseclasses_; }

kaldi::RegtreeMllrDiagGmmAccs::num_baseclasses_

int32 num_baseclasses_

Number of baseclasses.

Definition: regtree-mllr-diag-gmm.h:142

◆ Read()

void Read	(	std::istream &	in_stream,
		bool	binary,
		bool	add
	)

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

References RegtreeMllrDiagGmm::dim_, kaldi::ExpectToken(), KALDI_ASSERT, and kaldi::ReadBasicType().

Referenced by TestMllrAccsIO().

                                                                        {
   ExpectToken(in, binary, "<MLLRACCS>");
   ExpectToken(in, binary, "<NUMBASECLASSES>");
   ReadBasicType(in, binary, &num_baseclasses_);
   ExpectToken(in, binary, "<DIMENSION>");
   ReadBasicType(in, binary, &dim_);
   KALDI_ASSERT(num_baseclasses_ > 0 && dim_ > 0);
   baseclass_stats_.resize(num_baseclasses_);
   ExpectToken(in, binary, "<STATS>");
   vector<AffineXformStats*>::iterator itr = baseclass_stats_.begin(),
                                       end = baseclass_stats_.end();
   for ( ; itr != end; ++itr) {
     *itr = new AffineXformStats();
     (*itr)->Init(dim_, dim_);
     (*itr)->Read(in, binary, add);
   }
   ExpectToken(in, binary, "</MLLRACCS>");
 }

◆ SetZero()

void SetZero ( )

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

Referenced by main().

                                      {
   for (vector<AffineXformStats*>::iterator it = baseclass_stats_.begin(),
       end = baseclass_stats_.end(); it != end; ++it) {
     (*it)->SetZero();
   }
 }

◆ Update()

void Update	(	const RegressionTree &	regtree,
		const RegtreeMllrOptions &	opts,
		RegtreeMllrDiagGmm *	out_mllr,
		BaseFloat *	auxf_impr,
		BaseFloat *	t
	)		const

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

References kaldi::ComputeMllrMatrix(), kaldi::DeletePointers(), RegtreeMllrDiagGmm::dim_, RegressionTree::GatherStats(), RegtreeMllrDiagGmm::Init(), KALDI_ASSERT, KALDI_LOG, KALDI_WARN, RegtreeMllrOptions::min_count, kaldi::MllrAuxFunction(), RegtreeMllrDiagGmm::set_bclass2xforms(), RegtreeMllrDiagGmm::SetParameters(), MatrixBase< Real >::SetUnit(), and RegtreeMllrOptions::use_regtree.

Referenced by main(), TestMllrAccsIO(), and TestXformMean().

                                                         {
   BaseFloat tot_auxf_impr = 0, tot_t = 0;
   Matrix<BaseFloat> xform_mat(dim_, dim_ + 1);
   if (opts.use_regtree) {  // estimate transforms using a regression tree
     vector<AffineXformStats*> regclass_stats;
     vector<int32> base2regclass;
     bool update_xforms = regtree.GatherStats(baseclass_stats_, opts.min_count,
                                              &base2regclass, &regclass_stats);
     out_mllr->set_bclass2xforms(base2regclass);
     // If update_xforms == true, none should be negative, else all should be -1
     if (update_xforms) {
       out_mllr->Init(regclass_stats.size(), dim_);
       for (int32 rclass_index = 0, num_rclass = regclass_stats.size();
            rclass_index < num_rclass; ++rclass_index) {
         KALDI_ASSERT(regclass_stats[rclass_index]->beta_ >= opts.min_count);
         xform_mat.SetUnit();
         BaseFloat obj_old = MllrAuxFunction(xform_mat,
                                             *(regclass_stats[rclass_index]));
         ComputeMllrMatrix(regclass_stats[rclass_index]->K_,
                           regclass_stats[rclass_index]->G_, &xform_mat);
         out_mllr->SetParameters(xform_mat, rclass_index);
         BaseFloat obj_new = MllrAuxFunction(xform_mat,
                                             *(regclass_stats[rclass_index]));
         KALDI_LOG << "MLLR: regclass " << (rclass_index)
                   << ": Objective function impr per frame is "
                   << ((obj_new - obj_old)/regclass_stats[rclass_index]->beta_)
                   << " over " << regclass_stats[rclass_index]->beta_
                   << " frames.";
         KALDI_ASSERT(obj_new >= obj_old - (std::abs(obj_new)+std::abs(obj_old))*1.0e-05);
         tot_t += regclass_stats[rclass_index]->beta_;
         tot_auxf_impr += obj_new - obj_old;
       }
     } else {
       out_mllr->Init(1, dim_);  // Use a unit transform at the root.
     }
     DeletePointers(&regclass_stats);
     // end of estimation using regression tree
   } else {  // estimate 1 transform per baseclass (if enough count)
     out_mllr->Init(num_baseclasses_, dim_);
     vector<int32> base2xforms(num_baseclasses_, -1);
     for (int32 bclass_index = 0; bclass_index < num_baseclasses_;
          ++bclass_index) {
       if (baseclass_stats_[bclass_index]->beta_ > opts.min_count) {
         base2xforms[bclass_index] = bclass_index;
         xform_mat.SetUnit();
         BaseFloat obj_old = MllrAuxFunction(xform_mat,
                                             *(baseclass_stats_[bclass_index]));
         ComputeMllrMatrix(baseclass_stats_[bclass_index]->K_,
                           baseclass_stats_[bclass_index]->G_, &xform_mat);
         out_mllr->SetParameters(xform_mat, bclass_index);
         BaseFloat obj_new = MllrAuxFunction(xform_mat,
                                             *(baseclass_stats_[bclass_index]));
         KALDI_LOG << "MLLR: base-class " << (bclass_index)
                   << ": Auxiliary function impr per frame is "
                   << ((obj_new-obj_old)/baseclass_stats_[bclass_index]->beta_);
         KALDI_ASSERT(obj_new >= obj_old - (std::abs(obj_new)+std::abs(obj_old))*1.0e-05);
         tot_t += baseclass_stats_[bclass_index]->beta_;
         tot_auxf_impr += obj_new - obj_old;
       } else {
         KALDI_WARN << "For baseclass "  << (bclass_index) << " count = "
                    << (baseclass_stats_[bclass_index]->beta_) << " < "
                    << opts.min_count << ": not updating MLLR";
         tot_t += baseclass_stats_[bclass_index]->beta_;
       }
     }  // end looping over all baseclasses
     out_mllr->set_bclass2xforms(base2xforms);
   }  // end of estimating one transform per baseclass
   if (auxf_impr != NULL) *auxf_impr = tot_auxf_impr;
   if (t != NULL) *t = tot_t;
 }

◆ Write()

void Write	(	std::ostream &	out_stream,
		bool	binary
	)		const

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

References RegtreeMllrDiagGmm::dim_, kaldi::WriteBasicType(), and kaldi::WriteToken().

Referenced by TestMllrAccsIO().

                                                                      {
   WriteToken(out, binary, "<MLLRACCS>");
   WriteToken(out, binary, "<NUMBASECLASSES>");
   WriteBasicType(out, binary, num_baseclasses_);
   WriteToken(out, binary, "<DIMENSION>");
   WriteBasicType(out, binary, dim_);
   WriteToken(out, binary, "<STATS>");
   vector<AffineXformStats*>::const_iterator itr = baseclass_stats_.begin(),
                                             end = baseclass_stats_.end();
   for ( ; itr != end; ++itr)
     (*itr)->Write(out, binary);
   WriteToken(out, binary, "</MLLRACCS>");
 }

Member Data Documentation

◆ baseclass_stats_

std::vector<AffineXformStats*> baseclass_stats_

private

Per-baseclass stats; used for accumulation.

Definition at line 141 of file regtree-mllr-diag-gmm.h.

◆ dim_

int32 dim_

private

Dimension of feature vectors.

Definition at line 143 of file regtree-mllr-diag-gmm.h.

◆ num_baseclasses_

int32 num_baseclasses_

private

Number of baseclasses.

Definition at line 142 of file regtree-mllr-diag-gmm.h.

The documentation for this class was generated from the following files:

transform/regtree-mllr-diag-gmm.h
transform/regtree-mllr-diag-gmm.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RegtreeMllrDiagGmmAccs()

◆ ~RegtreeMllrDiagGmmAccs()

Member Function Documentation

◆ AccumulateForGaussian()

◆ AccumulateForGmm()

◆ baseclass_stats()

◆ Dim()

◆ Init()

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

◆ MllrObjFunction()

◆ NumBaseClasses()

◆ Read()

◆ SetZero()

◆ Update()

◆ Write()

Member Data Documentation

◆ baseclass_stats_

◆ dim_

◆ num_baseclasses_