AccumDiagGmm Class Reference

#include <mle-diag-gmm.h>

Collaboration diagram for AccumDiagGmm:

Public Member Functions
	AccumDiagGmm ()
	AccumDiagGmm (const DiagGmm &gmm, GmmFlagsType flags)
	AccumDiagGmm (const AccumDiagGmm &other)
void	Read (std::istream &in_stream, bool binary, bool add)
void	Write (std::ostream &out_stream, bool binary) const
void	Resize (int32 num_gauss, int32 dim, GmmFlagsType flags)
	Allocates memory for accumulators. More...
void	Resize (const DiagGmm &gmm, GmmFlagsType flags)
	Calls ResizeAccumulators with arguments based on gmm. More...
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	AccumulateFromDiag (const DiagGmm &gmm, const VectorBase< BaseFloat > &data, BaseFloat frame_posterior)
	Accumulate for all components given a diagonal-covariance GMM. More...
BaseFloat	AccumulateFromDiagMultiThreaded (const DiagGmm &gmm, const MatrixBase< BaseFloat > &data, const VectorBase< BaseFloat > &frame_weights, int32 num_threads)
	This does the same job as AccumulateFromDiag, but using multiple threads. More...
void	AddStatsForComponent (int32 comp_id, double occ, const VectorBase< double > &x_stats, const VectorBase< double > &x2_stats)
	Increment the stats for this component by the specified amount (not all parts may be taken, depending on flags). More...
void	Add (double scale, const AccumDiagGmm &acc)
	Increment with stats from this other accumulator (times scale) More...
void	SmoothStats (BaseFloat tau)
	Smooths the accumulated counts by adding 'tau' extra frames. More...
void	SmoothWithAccum (BaseFloat tau, const AccumDiagGmm &src_acc)
	Smooths the accumulated counts using some other accumulator. More...
void	SmoothWithModel (BaseFloat tau, const DiagGmm &src_gmm)
	Smooths the accumulated counts using the parameters of a given model. More...
GmmFlagsType	Flags () const
const VectorBase< double > &	occupancy () const
const MatrixBase< double > &	mean_accumulator () const
const MatrixBase< double > &	variance_accumulator () const
void	AssertEqual (const AccumDiagGmm &other)

Private Attributes
int32	dim_
int32	num_comp_
GmmFlagsType	flags_
	Flags corresponding to the accumulators that are stored. More...
Vector< double >	occupancy_
Matrix< double >	mean_accumulator_
Matrix< double >	variance_accumulator_

Detailed Description

Definition at line 106 of file mle-diag-gmm.h.

Constructor & Destructor Documentation

AccumDiagGmm() [1/3]

AccumDiagGmm ( )

inline

Definition at line 108 of file mle-diag-gmm.h.

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

AccumDiagGmm() [2/3]

AccumDiagGmm ( const DiagGmm &  gmm, GmmFlagsType  flags  )

inlineexplicit

Definition at line 109 of file mle-diag-gmm.h.

                                                                {
    Resize(gmm, flags);
  }

AccumDiagGmm() [3/3]

AccumDiagGmm ( const AccumDiagGmm &  other )

explicit

Definition at line 255 of file mle-diag-gmm.cc.

    : dim_(other.dim_), num_comp_(other.num_comp_),
      flags_(other.flags_), occupancy_(other.occupancy_),
      mean_accumulator_(other.mean_accumulator_),
      variance_accumulator_(other.variance_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 140 of file mle-diag-gmm.cc.

References VectorBase< Real >::ApplyPow(), VectorBase< Real >::Dim(), AccumDiagGmm::Dim(), AccumDiagGmm::flags_, KALDI_ASSERT, kaldi::kGmmMeans, kaldi::kGmmVariances, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy_, MatrixBase< Real >::Row(), and AccumDiagGmm::variance_accumulator_.

Referenced by main(), and TestComponentAcc().

                                                                              {
  if (flags_ & kGmmMeans)
    KALDI_ASSERT(data.Dim() == Dim());
  double wt = static_cast<double>(weight);
  KALDI_ASSERT(comp_index < NumGauss());
  // 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) {
      data_d.ApplyPow(2.0);
      variance_accumulator_.Row(comp_index).AddVec(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 191 of file mle-diag-gmm.cc.

References AccumDiagGmm::AccumulateFromPosteriors(), DiagGmm::ComponentPosteriors(), VectorBase< Real >::Dim(), DiagGmm::Dim(), AccumDiagGmm::Dim(), KALDI_ASSERT, DiagGmm::NumGauss(), and AccumDiagGmm::NumGauss().

Referenced by main(), test_flags_driven_update(), TestComponentAcc(), kaldi::UnitTestDiagGmmGenerate(), UnitTestEstimateDiagGmm(), and kaldi::UnitTestEstimateMmieDiagGmm().

                                                                      {
  KALDI_ASSERT(gmm.NumGauss() == NumGauss());
  KALDI_ASSERT(gmm.Dim() == Dim());
  KALDI_ASSERT(static_cast<int32>(data.Dim()) == Dim());

  Vector<BaseFloat> posteriors(NumGauss());
  BaseFloat log_like = gmm.ComponentPosteriors(data, &posteriors);
  posteriors.Scale(frame_posterior);

  AccumulateFromPosteriors(data, posteriors);
  return log_like;
}

AccumulateFromDiagMultiThreaded()

BaseFloat AccumulateFromDiagMultiThreaded	(	const DiagGmm &	gmm,
		const MatrixBase< BaseFloat > &	data,
		const VectorBase< BaseFloat > &	frame_weights,
		int32	num_threads
	)

This does the same job as AccumulateFromDiag, but using multiple threads.

Returns sum of (log-likelihood times frame weight) over all frames.

Definition at line 538 of file mle-diag-gmm.cc.

Referenced by kaldi::TrainOneIter(), and UnitTestEstimateDiagGmm().

                       {

  double tot_like = 0.0;
  AccumulateMultiThreadedClass accumulator(gmm, data, frame_weights,
                                           this, &tot_like);
  {
    // Note: everything happens in the constructor and destructor of
    // the object created below.
    MultiThreader<AccumulateMultiThreadedClass> threader(num_threads,
                                                         accumulator);
    // we need to make sure it's destroyed before we access the
    // value of tot_like.
  }
  return tot_like;
}

AccumulateFromPosteriors()

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

Accumulate for all components, given the posteriors.

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

References VectorBase< Real >::AddVec(), MatrixBase< Real >::AddVecVec(), VectorBase< Real >::ApplyPow(), VectorBase< Real >::Dim(), AccumDiagGmm::Dim(), AccumDiagGmm::flags_, KALDI_ASSERT, kaldi::kGmmMeans, kaldi::kGmmVariances, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy_, and AccumDiagGmm::variance_accumulator_.

Referenced by AccumAmDiagGmm::AccumulateForGmmTwofeats(), AccumDiagGmm::AccumulateFromDiag(), and main().

                                             {
  if (flags_ & kGmmMeans)
    KALDI_ASSERT(static_cast<int32>(data.Dim()) == Dim());
  KALDI_ASSERT(static_cast<int32>(posteriors.Dim()) == NumGauss());
  Vector<double> post_d(posteriors);  // Copy with type-conversion

  // accumulate
  occupancy_.AddVec(1.0, post_d);
  if (flags_ & kGmmMeans) {
    Vector<double> data_d(data);  // Copy with type-conversion
    mean_accumulator_.AddVecVec(1.0, post_d, data_d);
    if (flags_ & kGmmVariances) {
      data_d.ApplyPow(2.0);
      variance_accumulator_.AddVecVec(1.0, post_d, data_d);
    }
  }
}

Add()

void Add	(	double	scale,
		const AccumDiagGmm &	acc
	)

Increment with stats from this other accumulator (times scale)

Definition at line 399 of file mle-diag-gmm.cc.

References MatrixBase< Real >::AddMat(), VectorBase< Real >::AddVec(), AccumDiagGmm::flags_, kaldi::kGmmMeans, kaldi::kGmmVariances, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::occupancy_, and AccumDiagGmm::variance_accumulator_.

                                                            {
  // The functions called here will crash if the dimensions etc.
  // or the flags don't match.
  occupancy_.AddVec(scale, acc.occupancy_);
  if (flags_ & kGmmMeans)
    mean_accumulator_.AddMat(scale, acc.mean_accumulator_);
  if (flags_ & kGmmVariances)
    variance_accumulator_.AddMat(scale, acc.variance_accumulator_);
}

AddStatsForComponent()

void AddStatsForComponent	(	int32	comp_id,
		double	occ,
		const VectorBase< double > &	x_stats,
		const VectorBase< double > &	x2_stats
	)

Increment the stats for this component by the specified amount (not all parts may be taken, depending on flags).

Note: x_stats and x2_stats are assumed to already be multiplied by "occ"

Definition at line 158 of file mle-diag-gmm.cc.

References AccumDiagGmm::flags_, KALDI_ASSERT, kaldi::kGmmMeans, kaldi::kGmmVariances, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy_, MatrixBase< Real >::Row(), and AccumDiagGmm::variance_accumulator_.

Referenced by kaldi::DiagGmmToStats(), kaldi::GetStatsDerivative(), and kaldi::IsmoothStatsDiagGmm().

                                                                            {
  KALDI_ASSERT(g < NumGauss());
  occupancy_(g) += occ;
  if (flags_ & kGmmMeans)
    mean_accumulator_.Row(g).AddVec(1.0, x_stats);
  if (flags_ & kGmmVariances)
    variance_accumulator_.Row(g).AddVec(1.0, x2_stats);
}

AssertEqual()

void AssertEqual

(

const AccumDiagGmm &

other

)

Definition at line 558 of file mle-diag-gmm.cc.

References VectorBase< Real >::ApproxEqual(), MatrixBase< Real >::ApproxEqual(), AccumDiagGmm::dim_, AccumDiagGmm::flags_, KALDI_ASSERT, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::num_comp_, AccumDiagGmm::occupancy_, and AccumDiagGmm::variance_accumulator_.

Referenced by UnitTestEstimateDiagGmm().

                                                        {
  KALDI_ASSERT(dim_ == other.dim_ && num_comp_ == other.num_comp_ &&
               flags_ == other.flags_);
  KALDI_ASSERT(occupancy_.ApproxEqual(other.occupancy_));
  KALDI_ASSERT(mean_accumulator_.ApproxEqual(other.mean_accumulator_));
  KALDI_ASSERT(variance_accumulator_.ApproxEqual(other.variance_accumulator_));
}

Dim()

int32 Dim ( ) const

inline

Returns the dimensionality of the feature vectors.

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

Referenced by AccumDiagGmm::AccumulateForComponent(), AccumDiagGmm::AccumulateFromDiag(), AccumDiagGmm::AccumulateFromPosteriors(), kaldi::DoRescalingUpdate(), kaldi::GetStatsDerivative(), kaldi::IsmoothStatsDiagGmm(), kaldi::MapDiagGmmUpdate(), kaldi::MleDiagGmmUpdate(), AccumDiagGmm::Read(), AccumDiagGmm::SmoothWithAccum(), test_io(), and kaldi::UpdateEbwDiagGmm().

{ return dim_; }

Flags()

GmmFlagsType Flags ( ) const

inline

Definition at line 182 of file mle-diag-gmm.h.

Referenced by kaldi::DoRescalingUpdate(), kaldi::GetStatsDerivative(), kaldi::IsmoothStatsDiagGmm(), kaldi::MapDiagGmmUpdate(), kaldi::MleDiagGmmUpdate(), kaldi::MlObjective(), AccumDiagGmm::Read(), AccumAmDiagGmm::Scale(), test_io(), and kaldi::UpdateEbwDiagGmm().

{ return flags_; }

mean_accumulator()

const MatrixBase<double>& mean_accumulator ( ) const

inline

Definition at line 184 of file mle-diag-gmm.h.

Referenced by kaldi::ComputeAmGmmFeatureDeriv(), kaldi::DoRescalingUpdate(), kaldi::GetStatsDerivative(), kaldi::IsmoothStatsDiagGmm(), kaldi::MapDiagGmmUpdate(), kaldi::MleDiagGmmUpdate(), kaldi::MlObjective(), and kaldi::UpdateEbwDiagGmm().

{ return mean_accumulator_; }

NumGauss()

int32 NumGauss ( ) const

inline

Returns the number of mixture components.

Definition at line 124 of file mle-diag-gmm.h.

Referenced by AccumDiagGmm::AccumulateForComponent(), AccumDiagGmm::AccumulateFromDiag(), AccumDiagGmm::AccumulateFromPosteriors(), AccumDiagGmm::AddStatsForComponent(), kaldi::DoRescalingUpdate(), kaldi::GetStatsDerivative(), kaldi::IsmoothStatsDiagGmm(), kaldi::MapDiagGmmUpdate(), kaldi::MleDiagGmmUpdate(), AccumDiagGmm::Read(), AccumDiagGmm::SmoothWithAccum(), test_flags_driven_update(), test_io(), TestComponentAcc(), and kaldi::UpdateEbwDiagGmm().

{ return num_comp_; }

occupancy()

const VectorBase<double>& occupancy ( ) const

inline

Definition at line 183 of file mle-diag-gmm.h.

Referenced by kaldi::DoRescalingUpdate(), kaldi::GetStatsDerivative(), kaldi::IsmoothStatsDiagGmm(), main(), kaldi::MapDiagGmmUpdate(), kaldi::MleDiagGmmUpdate(), kaldi::MlObjective(), AccumAmDiagGmm::TotStatsCount(), kaldi::UpdateEbwDiagGmm(), and kaldi::UpdateEbwWeightsDiagGmm().

{ return occupancy_; }

Read()

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

Definition at line 33 of file mle-diag-gmm.cc.

References AccumDiagGmm::Dim(), kaldi::ExpectToken(), AccumDiagGmm::Flags(), kaldi::GmmFlagsToString(), KALDI_ERR, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy_, Vector< Real >::Read(), Matrix< Real >::Read(), kaldi::ReadBasicType(), kaldi::ReadToken(), AccumDiagGmm::Resize(), and AccumDiagGmm::variance_accumulator_.

Referenced by main(), test_io(), and UnitTestEstimateDiagGmm().

                                                                    {
  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);
  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 << " (mixing accs from different "
                  << "models?";
    } else {
      Resize(num_components, dimension, flags);
    }
  } else {
    Resize(num_components, dimension, flags);
  }

  ReadToken(in_stream, binary, &token);
  while (token != "</GMMACCS>") {
    if (token == "<OCCUPANCY>") {
      occupancy_.Read(in_stream, binary, add);
    } else if (token == "<MEANACCS>") {
      mean_accumulator_.Read(in_stream, binary, add);
    } else if (token == "<DIAGVARACCS>") {
      variance_accumulator_.Read(in_stream, binary, add);
    } else {
      KALDI_ERR << "Unexpected token '" << token << "' in model file ";
    }
    ReadToken(in_stream, binary, &token);
  }
}

Resize() [1/2]

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

Allocates memory for accumulators.

Definition at line 106 of file mle-diag-gmm.cc.

References kaldi::AugmentGmmFlags(), AccumDiagGmm::dim_, AccumDiagGmm::flags_, KALDI_ASSERT, kaldi::kGmmMeans, kaldi::kGmmVariances, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::num_comp_, AccumDiagGmm::occupancy_, Vector< Real >::Resize(), Matrix< Real >::Resize(), and AccumDiagGmm::variance_accumulator_.

Referenced by kaldi::DiagGmmToStats(), kaldi::GetStatsDerivative(), main(), AccumDiagGmm::Read(), test_flags_driven_update(), test_io(), TestComponentAcc(), UnitTestEstimateDiagGmm(), and kaldi::UnitTestEstimateMmieDiagGmm().

                                                                       {
  KALDI_ASSERT(num_comp > 0 && dim > 0);
  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)
    variance_accumulator_.Resize(num_comp, dim);
  else
    variance_accumulator_.Resize(0, 0);
}

Resize() [2/2]

void Resize ( const DiagGmm &  gmm, GmmFlagsType  flags  )

inline

Calls ResizeAccumulators with arguments based on gmm.

Definition at line 206 of file mle-diag-gmm.h.

References DiagGmm::Dim(), kaldi::MapDiagGmmUpdate(), kaldi::MleDiagGmmUpdate(), kaldi::MlObjective(), and DiagGmm::NumGauss().

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

Scale()

void Scale	(	BaseFloat	f,
		GmmFlagsType	flags
	)

Definition at line 131 of file mle-diag-gmm.cc.

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

Referenced by AccumAmDiagGmm::Scale(), and 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) variance_accumulator_.Scale(d);
}

SetZero()

void SetZero

(

GmmFlagsType

flags

)

Definition at line 122 of file mle-diag-gmm.cc.

References AccumDiagGmm::flags_, KALDI_ERR, kaldi::kGmmMeans, kaldi::kGmmVariances, kaldi::kGmmWeights, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::occupancy_, VectorBase< Real >::SetZero(), MatrixBase< Real >::SetZero(), and AccumDiagGmm::variance_accumulator_.

Referenced by test_flags_driven_update(), TestComponentAcc(), UnitTestEstimateDiagGmm(), and kaldi::UnitTestEstimateMmieDiagGmm().

                                             {
  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) variance_accumulator_.SetZero();
}

SmoothStats()

void SmoothStats

(

BaseFloat

tau

)

Smooths the accumulated counts by adding 'tau' extra frames.

An example use for this is I-smoothing for MMIE. Calls SmoothWithAccum.

Definition at line 208 of file mle-diag-gmm.cc.

References VectorBase< Real >::Add(), VectorBase< Real >::InvertElements(), AccumDiagGmm::mean_accumulator_, MatrixBase< Real >::MulRowsVec(), AccumDiagGmm::occupancy_, VectorBase< Real >::Scale(), and AccumDiagGmm::variance_accumulator_.

                                            {
  Vector<double> smoothing_vec(occupancy_);
  smoothing_vec.InvertElements();
  smoothing_vec.Scale(static_cast<double>(tau));
  smoothing_vec.Add(1.0);
  // now smoothing_vec = (tau + occ) / occ

  mean_accumulator_.MulRowsVec(smoothing_vec);
  variance_accumulator_.MulRowsVec(smoothing_vec);
  occupancy_.Add(static_cast<double>(tau));
}

SmoothWithAccum()

void SmoothWithAccum	(	BaseFloat	tau,
		const AccumDiagGmm &	src_acc
	)

Smooths the accumulated counts using some other accumulator.

Performs a weighted sum of the current accumulator with the given one. An example use for this is I-smoothing for MMI and MPE. Both accumulators must have the same dimension and number of components.

Definition at line 225 of file mle-diag-gmm.cc.

References AccumDiagGmm::Dim(), AccumDiagGmm::dim_, rnnlm::i, KALDI_ASSERT, KALDI_WARN, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::num_comp_, AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy_, MatrixBase< Real >::Row(), and AccumDiagGmm::variance_accumulator_.

                                                                             {
  KALDI_ASSERT(src_acc.NumGauss() == num_comp_ && src_acc.Dim() == dim_);
  for (int32 i = 0; i < num_comp_; i++) {
    if (src_acc.occupancy_(i) != 0.0) { // can only smooth if src was nonzero...
      occupancy_(i) += tau;
      mean_accumulator_.Row(i).AddVec(tau / src_acc.occupancy_(i),
                                      src_acc.mean_accumulator_.Row(i));
      variance_accumulator_.Row(i).AddVec(tau / src_acc.occupancy_(i),
                                          src_acc.variance_accumulator_.Row(i));
    } else
      KALDI_WARN << "Could not smooth since source acc had zero occupancy.";
  }
}

SmoothWithModel()

void SmoothWithModel	(	BaseFloat	tau,
		const DiagGmm &	src_gmm
	)

Smooths the accumulated counts using the parameters of a given model.

An example use of this is MAP-adaptation. The model must have the same dimension and number of components as the current accumulator.

Definition at line 240 of file mle-diag-gmm.cc.

References VectorBase< Real >::Add(), MatrixBase< Real >::AddMat(), DiagGmm::Dim(), AccumDiagGmm::dim_, DiagGmm::GetMeans(), DiagGmm::GetVars(), KALDI_ASSERT, kaldi::kNoTrans, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::num_comp_, DiagGmm::NumGauss(), AccumDiagGmm::occupancy_, and AccumDiagGmm::variance_accumulator_.

                                                                    {
  KALDI_ASSERT(gmm.NumGauss() == num_comp_ && gmm.Dim() == dim_);
  Matrix<double> means(num_comp_, dim_);
  Matrix<double> vars(num_comp_, dim_);
  gmm.GetMeans(&means);
  gmm.GetVars(&vars);

  mean_accumulator_.AddMat(tau, means);
  means.ApplyPow(2.0);
  vars.AddMat(1.0, means, kNoTrans);
  variance_accumulator_.AddMat(tau, vars);

  occupancy_.Add(tau);
}

variance_accumulator()

const MatrixBase<double>& variance_accumulator ( ) const

inline

Definition at line 185 of file mle-diag-gmm.h.

References kaldi::AssertEqual().

Referenced by kaldi::ComputeAmGmmFeatureDeriv(), kaldi::DoRescalingUpdate(), kaldi::GetStatsDerivative(), kaldi::IsmoothStatsDiagGmm(), kaldi::MapDiagGmmUpdate(), kaldi::MleDiagGmmUpdate(), kaldi::MlObjective(), and kaldi::UpdateEbwDiagGmm().

{ return variance_accumulator_; }

Write()

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

Definition at line 77 of file mle-diag-gmm.cc.

References MatrixBase< Real >::CopyFromMat(), VectorBase< Real >::Dim(), AccumDiagGmm::dim_, AccumDiagGmm::flags_, AccumDiagGmm::mean_accumulator_, AccumDiagGmm::num_comp_, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), AccumDiagGmm::occupancy_, AccumDiagGmm::variance_accumulator_, kaldi::WriteBasicType(), and kaldi::WriteToken().

Referenced by main(), test_io(), and UnitTestEstimateDiagGmm().

                                                                  {
  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_);

  // convert into BaseFloat before writing things
  Vector<BaseFloat> occupancy_bf(occupancy_.Dim());
  Matrix<BaseFloat> mean_accumulator_bf(mean_accumulator_.NumRows(),
                                        mean_accumulator_.NumCols());
  Matrix<BaseFloat> variance_accumulator_bf(variance_accumulator_.NumRows(),
                                            variance_accumulator_.NumCols());
  occupancy_bf.CopyFromVec(occupancy_);
  mean_accumulator_bf.CopyFromMat(mean_accumulator_);
  variance_accumulator_bf.CopyFromMat(variance_accumulator_);

  WriteToken(out_stream, binary, "<OCCUPANCY>");
  occupancy_bf.Write(out_stream, binary);
  WriteToken(out_stream, binary, "<MEANACCS>");
  mean_accumulator_bf.Write(out_stream, binary);
  WriteToken(out_stream, binary, "<DIAGVARACCS>");
  variance_accumulator_bf.Write(out_stream, binary);
  WriteToken(out_stream, binary, "</GMMACCS>");
}

Member Data Documentation

dim_

int32 dim_

private

Definition at line 190 of file mle-diag-gmm.h.

Referenced by AccumDiagGmm::AssertEqual(), AccumDiagGmm::Resize(), AccumDiagGmm::SmoothWithAccum(), AccumDiagGmm::SmoothWithModel(), and AccumDiagGmm::Write().

flags_

GmmFlagsType flags_

private

Flags corresponding to the accumulators that are stored.

Definition at line 193 of file mle-diag-gmm.h.

Referenced by AccumDiagGmm::AccumulateForComponent(), AccumDiagGmm::AccumulateFromPosteriors(), AccumDiagGmm::Add(), AccumDiagGmm::AddStatsForComponent(), AccumDiagGmm::AssertEqual(), AccumDiagGmm::Resize(), AccumDiagGmm::Scale(), AccumDiagGmm::SetZero(), and AccumDiagGmm::Write().

mean_accumulator_

Matrix<double> mean_accumulator_

private

Definition at line 196 of file mle-diag-gmm.h.

Referenced by AccumDiagGmm::AccumulateForComponent(), AccumDiagGmm::AccumulateFromPosteriors(), AccumDiagGmm::Add(), AccumDiagGmm::AddStatsForComponent(), AccumDiagGmm::AssertEqual(), AccumDiagGmm::Read(), AccumDiagGmm::Resize(), AccumDiagGmm::Scale(), AccumDiagGmm::SetZero(), AccumDiagGmm::SmoothStats(), AccumDiagGmm::SmoothWithAccum(), AccumDiagGmm::SmoothWithModel(), and AccumDiagGmm::Write().

num_comp_

int32 num_comp_

private

Definition at line 191 of file mle-diag-gmm.h.

Referenced by AccumDiagGmm::AssertEqual(), AccumDiagGmm::Resize(), AccumDiagGmm::SmoothWithAccum(), AccumDiagGmm::SmoothWithModel(), and AccumDiagGmm::Write().

occupancy_

Vector<double> occupancy_

private

Definition at line 195 of file mle-diag-gmm.h.

Referenced by AccumDiagGmm::AccumulateForComponent(), AccumDiagGmm::AccumulateFromPosteriors(), AccumDiagGmm::Add(), AccumDiagGmm::AddStatsForComponent(), AccumDiagGmm::AssertEqual(), AccumDiagGmm::Read(), AccumDiagGmm::Resize(), AccumDiagGmm::Scale(), AccumDiagGmm::SetZero(), AccumDiagGmm::SmoothStats(), AccumDiagGmm::SmoothWithAccum(), AccumDiagGmm::SmoothWithModel(), and AccumDiagGmm::Write().

variance_accumulator_

Matrix<double> variance_accumulator_

private

Definition at line 197 of file mle-diag-gmm.h.

Referenced by AccumDiagGmm::AccumulateForComponent(), AccumDiagGmm::AccumulateFromPosteriors(), AccumDiagGmm::Add(), AccumDiagGmm::AddStatsForComponent(), AccumDiagGmm::AssertEqual(), AccumDiagGmm::Read(), AccumDiagGmm::Resize(), AccumDiagGmm::Scale(), AccumDiagGmm::SetZero(), AccumDiagGmm::SmoothStats(), AccumDiagGmm::SmoothWithAccum(), AccumDiagGmm::SmoothWithModel(), and AccumDiagGmm::Write().

---

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

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