AccumFullGmm Class Reference

Class for computing the maximum-likelihood estimates of the parameters of a Gaussian mixture model. More...

#include <mle-full-gmm.h>

Collaboration diagram for AccumFullGmm:

Public Member Functions
	AccumFullGmm ()
	AccumFullGmm (int32 num_comp, int32 dim, GmmFlagsType flags)
	AccumFullGmm (const FullGmm &gmm, GmmFlagsType flags)
	AccumFullGmm (const AccumFullGmm &other)
void	Read (std::istream &in_stream, bool binary, bool add)
void	Write (std::ostream &out_stream, bool binary) const
void	Resize (int32 num_components, int32 dim, GmmFlagsType flags)
	Allocates memory for accumulators. More...
void	Resize (const FullGmm &gmm, GmmFlagsType flags)
	Calls Resize with arguments based on gmm_ptr_. More...
void	ResizeVarAccumulator (int32 num_comp, int32 dim)
int32	NumGauss () const
	Returns the number of mixture components. More...
int32	Dim () const
	Returns the dimensionality of the feature vectors. More...
void	SetZero (GmmFlagsType flags)
void	Scale (BaseFloat f, GmmFlagsType flags)
void	AccumulateForComponent (const VectorBase< BaseFloat > &data, int32 comp_index, BaseFloat weight)
	Accumulate for a single component, given the posterior. More...
void	AccumulateFromPosteriors (const VectorBase< BaseFloat > &data, const VectorBase< BaseFloat > &gauss_posteriors)
	Accumulate for all components, given the posteriors. More...
BaseFloat	AccumulateFromFull (const FullGmm &gmm, const VectorBase< BaseFloat > &data, BaseFloat frame_posterior)
	Accumulate for all components given a full-covariance GMM. More...
BaseFloat	AccumulateFromDiag (const DiagGmm &gmm, const VectorBase< BaseFloat > &data, BaseFloat frame_posterior)
	Accumulate for all components given a diagonal-covariance GMM. More...
GmmFlagsType	Flags () const
	Accessors. More...
const Vector< double > &	occupancy () const
const Matrix< double > &	mean_accumulator () const
const std::vector< SpMatrix< double > > &	covariance_accumulator () const

Private Attributes
int32	dim_
int32	num_comp_
GmmFlagsType	flags_
Vector< double >	occupancy_
Matrix< double >	mean_accumulator_
std::vector< SpMatrix< double > >	covariance_accumulator_

Detailed Description

Class for computing the maximum-likelihood estimates of the parameters of a Gaussian mixture model.

Definition at line 74 of file mle-full-gmm.h.

Constructor & Destructor Documentation

AccumFullGmm() [1/4]

AccumFullGmm ( )

inline

Definition at line 76 of file mle-full-gmm.h.

: dim_(0), num_comp_(0), flags_(0) { }

AccumFullGmm() [2/4]

AccumFullGmm ( int32  num_comp, int32  dim, GmmFlagsType  flags  )

inline

Definition at line 77 of file mle-full-gmm.h.

                                                             :
      dim_(0), num_comp_(0), flags_(0) {
    Resize(num_comp, dim, flags);
  }

AccumFullGmm() [3/4]

AccumFullGmm ( const FullGmm &  gmm, GmmFlagsType  flags  )

inlineexplicit

Definition at line 81 of file mle-full-gmm.h.

                                                                {
    Resize(gmm, flags);
  }

AccumFullGmm() [4/4]

AccumFullGmm ( const AccumFullGmm &  other )

explicit

Definition at line 31 of file mle-full-gmm.cc.

  : dim_(other.dim_), num_comp_(other.num_comp_),
    flags_(other.flags_), occupancy_(other.occupancy_),
    mean_accumulator_(other.mean_accumulator_),
    covariance_accumulator_(other.covariance_accumulator_) {}

Member Function Documentation

AccumulateForComponent()

void AccumulateForComponent	(	const VectorBase< BaseFloat > &	data,
		int32	comp_index,
		BaseFloat	weight
	)

Accumulate for a single component, given the posterior.

Definition at line 96 of file mle-full-gmm.cc.

References AccumFullGmm::covariance_accumulator_, VectorBase< Real >::Dim(), AccumFullGmm::Dim(), AccumFullGmm::flags_, KALDI_ASSERT, kaldi::kGmmMeans, kaldi::kGmmVariances, AccumFullGmm::mean_accumulator_, AccumFullGmm::occupancy_, and MatrixBase< Real >::Row().

Referenced by kaldi::AccumulateForUtterance(), main(), and TestComponentAcc().

                                                                           {
  KALDI_ASSERT(data.Dim() == Dim());
  double wt = static_cast<double>(weight);

  // accumulate
  occupancy_(comp_index) += wt;
  if (flags_ & kGmmMeans) {
    Vector<double> data_d(data);  // Copy with type-conversion
    mean_accumulator_.Row(comp_index).AddVec(wt, data_d);
    if (flags_ & kGmmVariances) {
      covariance_accumulator_[comp_index].AddVec2(wt, data_d);
    }
  }
}

AccumulateFromDiag()

BaseFloat AccumulateFromDiag	(	const DiagGmm &	gmm,
		const VectorBase< BaseFloat > &	data,
		BaseFloat	frame_posterior
	)

Accumulate for all components given a diagonal-covariance GMM.

Computes posteriors and returns log-likelihood

Definition at line 157 of file mle-full-gmm.cc.

References AccumFullGmm::AccumulateFromPosteriors(), DiagGmm::ComponentPosteriors(), DiagGmm::Dim(), AccumFullGmm::Dim(), KALDI_ASSERT, DiagGmm::NumGauss(), and AccumFullGmm::NumGauss().

Referenced by kaldi::AccumulateForUtterance().

                                                                  {
  KALDI_ASSERT(gmm.NumGauss() == NumGauss());
  KALDI_ASSERT(gmm.Dim() == Dim());

  Vector<BaseFloat> component_posterior(NumGauss());

  BaseFloat log_like = gmm.ComponentPosteriors(data, &component_posterior);
  component_posterior.Scale(frame_posterior);

  AccumulateFromPosteriors(data, component_posterior);
  return log_like;
}

AccumulateFromFull()

BaseFloat AccumulateFromFull	(	const FullGmm &	gmm,
		const VectorBase< BaseFloat > &	data,
		BaseFloat	frame_posterior
	)

Accumulate for all components given a full-covariance GMM.

Computes posteriors and returns log-likelihood

Definition at line 143 of file mle-full-gmm.cc.

References AccumFullGmm::AccumulateFromPosteriors(), FullGmm::ComponentPosteriors(), FullGmm::Dim(), AccumFullGmm::Dim(), KALDI_ASSERT, FullGmm::NumGauss(), and AccumFullGmm::NumGauss().

Referenced by main(), test_flags_driven_update(), TestComponentAcc(), UnitTestEstimateFullGmm(), and UnitTestFullGmmEst().

                                                                  {
  KALDI_ASSERT(gmm.NumGauss() == NumGauss());
  KALDI_ASSERT(gmm.Dim() == Dim());

  Vector<BaseFloat> component_posterior(NumGauss());

  BaseFloat log_like = gmm.ComponentPosteriors(data, &component_posterior);
  component_posterior.Scale(frame_posterior);

  AccumulateFromPosteriors(data, component_posterior);
  return log_like;
}

AccumulateFromPosteriors()

void AccumulateFromPosteriors	(	const VectorBase< BaseFloat > &	data,
		const VectorBase< BaseFloat > &	gauss_posteriors
	)

Accumulate for all components, given the posteriors.

Definition at line 112 of file mle-full-gmm.cc.

References VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2(), MatrixBase< Real >::AddVecVec(), VectorBase< Real >::CopyFromVec(), AccumFullGmm::covariance_accumulator_, VectorBase< Real >::Dim(), AccumFullGmm::Dim(), AccumFullGmm::flags_, rnnlm::i, KALDI_ASSERT, kaldi::kGmmMeans, kaldi::kGmmVariances, AccumFullGmm::mean_accumulator_, AccumFullGmm::NumGauss(), AccumFullGmm::occupancy_, and MatrixBase< Real >::Row().

Referenced by AccumFullGmm::AccumulateFromDiag(), and AccumFullGmm::AccumulateFromFull().

                                                   {
  KALDI_ASSERT(gauss_posteriors.Dim() == NumGauss());
  KALDI_ASSERT(data.Dim() == Dim());
  Vector<double> data_d(data.Dim());
  data_d.CopyFromVec(data);
  Vector<double> post_d(gauss_posteriors.Dim());
  post_d.CopyFromVec(gauss_posteriors);

  occupancy_.AddVec(1.0, post_d);
  if (flags_ & (kGmmMeans|kGmmVariances)) {  // mean stats.
    if (static_cast<int32>(post_d.Norm(0.0)*2.0) > post_d.Dim()) {
      // If we're not very sparse... note: zero-norm is number of
      // nonzero elements.
      mean_accumulator_.AddVecVec(1.0, post_d, data_d);
    } else {
      for (int32 i = 0; i < post_d.Dim(); i++)
        if (post_d(i) != 0.0)
          mean_accumulator_.Row(i).AddVec(post_d(i), data_d);
    }
    if (flags_ & kGmmVariances) {
      SpMatrix<double> data_sq_d(data_d.Dim());
      data_sq_d.AddVec2(1.0, data_d);
      for (int32 mix = 0; mix < NumGauss(); mix++)
        if (post_d(mix) !=  0.0)
          covariance_accumulator_[mix].AddSp(post_d(mix), data_sq_d);
    }
  }
}

covariance_accumulator()

const std::vector<SpMatrix<double> >& covariance_accumulator ( ) const

inline

Definition at line 129 of file mle-full-gmm.h.

Referenced by FmllrDiagGmmAccs::FmllrDiagGmmAccs(), kaldi::MleFullGmmUpdate(), and kaldi::MlObjective().

{ return covariance_accumulator_; }

Dim()

int32 Dim ( ) const

inline

Returns the dimensionality of the feature vectors.

Definition at line 99 of file mle-full-gmm.h.

Referenced by AccumFullGmm::AccumulateForComponent(), AccumFullGmm::AccumulateFromDiag(), AccumFullGmm::AccumulateFromFull(), AccumFullGmm::AccumulateFromPosteriors(), FmllrDiagGmmAccs::FmllrDiagGmmAccs(), and AccumFullGmm::Read().

{ return dim_; }

Flags()

GmmFlagsType Flags ( ) const

inline

Accessors.

Definition at line 126 of file mle-full-gmm.h.

Referenced by kaldi::MleFullGmmUpdate(), kaldi::MlObjective(), AccumFullGmm::Read(), and test_io().

{ return flags_; }

mean_accumulator()

const Matrix<double>& mean_accumulator ( ) const

inline

Definition at line 128 of file mle-full-gmm.h.

Referenced by FmllrDiagGmmAccs::FmllrDiagGmmAccs(), kaldi::MleFullGmmUpdate(), and kaldi::MlObjective().

{ return mean_accumulator_; }

NumGauss()

int32 NumGauss ( ) const

inline

Returns the number of mixture components.

Definition at line 97 of file mle-full-gmm.h.

Referenced by AccumFullGmm::AccumulateFromDiag(), AccumFullGmm::AccumulateFromFull(), AccumFullGmm::AccumulateFromPosteriors(), FmllrDiagGmmAccs::FmllrDiagGmmAccs(), AccumFullGmm::Read(), and TestComponentAcc().

{ return num_comp_; }

occupancy()

const Vector<double>& occupancy ( ) const

inline

Definition at line 127 of file mle-full-gmm.h.

Referenced by FmllrDiagGmmAccs::FmllrDiagGmmAccs(), kaldi::MleFullGmmUpdate(), and kaldi::MlObjective().

{ return occupancy_; }

Read()

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

Definition at line 171 of file mle-full-gmm.cc.

References MatrixBase< Real >::AddMat(), VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2(), AccumFullGmm::covariance_accumulator_, AccumFullGmm::Dim(), kaldi::ExpectToken(), AccumFullGmm::Flags(), kaldi::GmmFlagsToString(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, AccumFullGmm::mean_accumulator_, AccumFullGmm::NumGauss(), AccumFullGmm::occupancy_, PackedMatrix< Real >::Read(), Vector< Real >::Read(), Matrix< Real >::Read(), kaldi::ReadBasicType(), kaldi::ReadToken(), AccumFullGmm::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::SetZero(), and MatrixBase< Real >::SetZero().

Referenced by main(), and test_io().

                                                                    {
  int32 dimension, num_components;
  GmmFlagsType flags;
  std::string token;

  ExpectToken(in_stream, binary, "<GMMACCS>");
  ExpectToken(in_stream, binary, "<VECSIZE>");
  ReadBasicType(in_stream, binary, &dimension);
  ExpectToken(in_stream, binary, "<NUMCOMPONENTS>");
  ReadBasicType(in_stream, binary, &num_components);
  KALDI_ASSERT(dimension > 0 && num_components > 0);
  ExpectToken(in_stream, binary, "<FLAGS>");
  ReadBasicType(in_stream, binary, &flags);

  if (add) {
    if ((NumGauss() != 0 || Dim() != 0 || Flags() != 0)) {
      if (num_components != NumGauss() || dimension != Dim()
          || flags != Flags())
        KALDI_ERR << "MlEstimatediagGmm::Read, dimension or flags mismatch, "
                  << NumGauss() << ", " << Dim() << ", "
                  << GmmFlagsToString(Flags()) << " vs. " << num_components << ", "
                  << dimension << ", " << flags;
    } else {
      Resize(num_components, dimension, flags);
    }
  } else {
    Resize(num_components, dimension, flags);
  }

  // these are needed for demangling the variances.
  Vector<double> tmp_occs;
  Matrix<double> tmp_means;

  ReadToken(in_stream, binary, &token);
  while (token != "</GMMACCS>") {
    if (token == "<OCCUPANCY>") {
      tmp_occs.Read(in_stream, binary, false);
      if (!add) occupancy_.SetZero();
      occupancy_.AddVec(1.0, tmp_occs);
    } else if (token == "<MEANACCS>") {
      tmp_means.Read(in_stream, binary, false);
      if (!add) mean_accumulator_.SetZero();
      mean_accumulator_.AddMat(1.0, tmp_means);
    } else if (token == "<FULLVARACCS>") {
      for (int32 i = 0; i < num_components; i++) {
        SpMatrix<double> tmp_acc;
        tmp_acc.Read(in_stream, binary, add);
        if (tmp_occs(i) != 0) tmp_acc.AddVec2(1.0 / tmp_occs(i), tmp_means.Row(
            i));
        if (!add) covariance_accumulator_[i].SetZero();
        covariance_accumulator_[i].AddSp(1.0, tmp_acc);
      }
    } else {
      KALDI_ERR << "Unexpected token '" << token << "' in model file ";
    }
    ReadToken(in_stream, binary, &token);
  }
}

Resize() [1/2]

void Resize	(	int32	num_components,
		int32	dim,
		GmmFlagsType	flags
	)

Allocates memory for accumulators.

Definition at line 37 of file mle-full-gmm.cc.

References kaldi::AugmentGmmFlags(), AccumFullGmm::covariance_accumulator_, AccumFullGmm::dim_, AccumFullGmm::flags_, kaldi::kGmmMeans, kaldi::kGmmVariances, AccumFullGmm::mean_accumulator_, AccumFullGmm::num_comp_, AccumFullGmm::occupancy_, Vector< Real >::Resize(), Matrix< Real >::Resize(), and AccumFullGmm::ResizeVarAccumulator().

Referenced by main(), AccumFullGmm::Read(), test_flags_driven_update(), test_io(), TestComponentAcc(), and UnitTestEstimateFullGmm().

                                                                       {
  num_comp_ = num_comp;
  dim_ = dim;
  flags_ = AugmentGmmFlags(flags);
  occupancy_.Resize(num_comp);
  if (flags_ & kGmmMeans)
    mean_accumulator_.Resize(num_comp, dim);
  else
    mean_accumulator_.Resize(0, 0);
    
  if (flags_ & kGmmVariances)
    ResizeVarAccumulator(num_comp, dim);
  else
    covariance_accumulator_.clear();
}

Resize() [2/2]

void Resize ( const FullGmm &  gmm, GmmFlagsType  flags  )

inline

Calls Resize with arguments based on gmm_ptr_.

Definition at line 141 of file mle-full-gmm.h.

References FullGmm::Dim(), kaldi::MleFullGmmUpdate(), kaldi::MlObjective(), and FullGmm::NumGauss().

                                                                       {
  Resize(gmm.NumGauss(), gmm.Dim(), flags);
}

ResizeVarAccumulator()

void ResizeVarAccumulator	(	int32	num_comp,
		int32	dim
	)

Definition at line 53 of file mle-full-gmm.cc.

References AccumFullGmm::covariance_accumulator_, rnnlm::i, and KALDI_ASSERT.

Referenced by AccumFullGmm::Resize().

                                                                 {
  KALDI_ASSERT(num_comp > 0 && dim > 0);
  if (covariance_accumulator_.size() != static_cast<size_t>(num_comp))
    covariance_accumulator_.resize(num_comp);
  for (int32 i = 0; i < num_comp; i++) {
    if (covariance_accumulator_[i].NumRows() != dim)
      covariance_accumulator_[i].Resize(dim);
  }
}

Scale()

void Scale	(	BaseFloat	f,
		GmmFlagsType	flags
	)

Definition at line 79 of file mle-full-gmm.cc.

References AccumFullGmm::covariance_accumulator_, rnnlm::d, AccumFullGmm::flags_, rnnlm::i, KALDI_ERR, kaldi::kGmmMeans, kaldi::kGmmVariances, kaldi::kGmmWeights, AccumFullGmm::mean_accumulator_, AccumFullGmm::occupancy_, MatrixBase< Real >::Scale(), and VectorBase< Real >::Scale().

Referenced by test_io().

                                                        {
  if (flags & ~flags_)
    KALDI_ERR << "Flags in argument do not match the active accumulators";
    
  double d = static_cast<double>(f);
  if (flags & kGmmWeights) 
    occupancy_.Scale(d);
  
  if (flags & kGmmMeans) 
    mean_accumulator_.Scale(d);
  
  if (flags & kGmmVariances) {
    for (int32 i = 0, end = covariance_accumulator_.size(); i < end; i++)
      covariance_accumulator_[i].Scale(d);
  }
}

SetZero()

void SetZero

(

GmmFlagsType

flags

)

Definition at line 63 of file mle-full-gmm.cc.

References AccumFullGmm::covariance_accumulator_, AccumFullGmm::flags_, rnnlm::i, KALDI_ERR, kaldi::kGmmMeans, kaldi::kGmmVariances, kaldi::kGmmWeights, AccumFullGmm::mean_accumulator_, AccumFullGmm::occupancy_, VectorBase< Real >::SetZero(), and MatrixBase< Real >::SetZero().

Referenced by test_flags_driven_update(), TestComponentAcc(), and UnitTestEstimateFullGmm().

                                             {
  if (flags & ~flags_)
    KALDI_ERR << "Flags in argument do not match the active accumulators";
  
  if (flags & kGmmWeights) 
    occupancy_.SetZero();
  
  if (flags & kGmmMeans) 
    mean_accumulator_.SetZero();
  
  if (flags & kGmmVariances) {
    for (int32 i = 0, end = covariance_accumulator_.size(); i < end; i++)
      covariance_accumulator_[i].SetZero();
  }
}

Write()

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

Definition at line 230 of file mle-full-gmm.cc.

References SpMatrix< Real >::AddVec2(), AccumFullGmm::covariance_accumulator_, AccumFullGmm::dim_, AccumFullGmm::flags_, rnnlm::i, KALDI_ASSERT, kaldi::kGmmVariances, AccumFullGmm::mean_accumulator_, AccumFullGmm::num_comp_, AccumFullGmm::occupancy_, MatrixBase< Real >::Row(), PackedMatrix< Real >::Write(), VectorBase< Real >::Write(), MatrixBase< Real >::Write(), kaldi::WriteBasicType(), and kaldi::WriteToken().

Referenced by main(), and test_io().

                                                                  {
  WriteToken(out_stream, binary, "<GMMACCS>");
  WriteToken(out_stream, binary, "<VECSIZE>");
  WriteBasicType(out_stream, binary, dim_);
  WriteToken(out_stream, binary, "<NUMCOMPONENTS>");
  WriteBasicType(out_stream, binary, num_comp_);
  WriteToken(out_stream, binary, "<FLAGS>");
  WriteBasicType(out_stream, binary, flags_);

  Vector<BaseFloat> occupancy_bf(occupancy_);
  WriteToken(out_stream, binary, "<OCCUPANCY>");
  occupancy_bf.Write(out_stream, binary);
  Matrix<BaseFloat> mean_accumulator_bf(mean_accumulator_);
  WriteToken(out_stream, binary, "<MEANACCS>");
  mean_accumulator_bf.Write(out_stream, binary);

  if (num_comp_ != 0) KALDI_ASSERT(((flags_ & kGmmVariances) != 0 )
      == (covariance_accumulator_.size() != 0));  // sanity check.
  if (covariance_accumulator_.size() != 0) {
    WriteToken(out_stream, binary, "<FULLVARACCS>");
    for (int32 i = 0; i < num_comp_; i++) {
      SpMatrix<double> tmp_acc(covariance_accumulator_[i]);
      if (occupancy_(i) != 0) tmp_acc.AddVec2(-1.0 / occupancy_(i),
          mean_accumulator_.Row(i));
      SpMatrix<float> tmp_acc_bf(tmp_acc);
      tmp_acc_bf.Write(out_stream, binary);
    }
  }
  WriteToken(out_stream, binary, "</GMMACCS>");
}

Member Data Documentation

covariance_accumulator_

std::vector<SpMatrix<double> > covariance_accumulator_

private

Definition at line 138 of file mle-full-gmm.h.

Referenced by AccumFullGmm::AccumulateForComponent(), AccumFullGmm::AccumulateFromPosteriors(), AccumFullGmm::Read(), AccumFullGmm::Resize(), AccumFullGmm::ResizeVarAccumulator(), AccumFullGmm::Scale(), AccumFullGmm::SetZero(), and AccumFullGmm::Write().

dim_

int32 dim_

private

Definition at line 132 of file mle-full-gmm.h.

Referenced by AccumFullGmm::Resize(), and AccumFullGmm::Write().

flags_

GmmFlagsType flags_

private

Definition at line 134 of file mle-full-gmm.h.

Referenced by AccumFullGmm::AccumulateForComponent(), AccumFullGmm::AccumulateFromPosteriors(), AccumFullGmm::Resize(), AccumFullGmm::Scale(), AccumFullGmm::SetZero(), and AccumFullGmm::Write().

mean_accumulator_

Matrix<double> mean_accumulator_

private

Definition at line 137 of file mle-full-gmm.h.

Referenced by AccumFullGmm::AccumulateForComponent(), AccumFullGmm::AccumulateFromPosteriors(), AccumFullGmm::Read(), AccumFullGmm::Resize(), AccumFullGmm::Scale(), AccumFullGmm::SetZero(), and AccumFullGmm::Write().

num_comp_

int32 num_comp_

private

Definition at line 133 of file mle-full-gmm.h.

Referenced by AccumFullGmm::Resize(), and AccumFullGmm::Write().

occupancy_

Vector<double> occupancy_

private

Definition at line 136 of file mle-full-gmm.h.

Referenced by AccumFullGmm::AccumulateForComponent(), AccumFullGmm::AccumulateFromPosteriors(), AccumFullGmm::Read(), AccumFullGmm::Resize(), AccumFullGmm::Scale(), AccumFullGmm::SetZero(), and AccumFullGmm::Write().

---

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

• gmm/mle-full-gmm.h
• gmm/mle-full-gmm.cc