FullGmm Class Reference

Definition for Gaussian Mixture Model with full covariances. More...

#include <full-gmm.h>

Collaboration diagram for FullGmm:

Public Member Functions
	FullGmm ()
	Empty constructor. More...
	FullGmm (const FullGmm &gmm)
	FullGmm (int32 nMix, int32 dim)
void	Resize (int32 nMix, int32 dim)
	Resizes arrays to this dim. Does not initialize data. More...
int32	NumGauss () const
	Returns the number of mixture components in the GMM. More...
int32	Dim () const
	Returns the dimensionality of the Gaussian mean vectors. More...
void	CopyFromFullGmm (const FullGmm &fullgmm)
	Copies from given FullGmm. More...
void	CopyFromDiagGmm (const DiagGmm &diaggmm)
	Copies from given DiagGmm. More...
BaseFloat	LogLikelihood (const VectorBase< BaseFloat > &data) const
	Returns the log-likelihood of a data point (vector) given the GMM. More...
void	LogLikelihoods (const VectorBase< BaseFloat > &data, Vector< BaseFloat > *loglikes) const
	Outputs the per-component contributions to the log-likelihood. More...
void	LogLikelihoodsPreselect (const VectorBase< BaseFloat > &data, const std::vector< int32 > &indices, Vector< BaseFloat > *loglikes) const
	Outputs the per-component log-likelihoods of a subset of mixture components. More...
BaseFloat	GaussianSelection (const VectorBase< BaseFloat > &data, int32 num_gselect, std::vector< int32 > *output) const
	Get gaussian selection information for one frame. More...
BaseFloat	GaussianSelectionPreselect (const VectorBase< BaseFloat > &data, const std::vector< int32 > &preselect, int32 num_gselect, std::vector< int32 > *output) const
	Get gaussian selection information for one frame. More...
BaseFloat	ComponentPosteriors (const VectorBase< BaseFloat > &data, VectorBase< BaseFloat > *posterior) const
	Computes the posterior probabilities of all Gaussian components given a data point. More...
BaseFloat	ComponentLogLikelihood (const VectorBase< BaseFloat > &data, int32 comp_id) const
	Computes the contribution log-likelihood of a data point from a single Gaussian component. More...
int32	ComputeGconsts ()
	Sets the gconsts. More...
void	Split (int32 target_components, float perturb_factor, std::vector< int32 > *history=NULL)
	Merge the components and remember the order in which the components were merged (flat list of pairs) More...
void	Perturb (float perturb_factor)
	Perturbs the component means with a random vector multiplied by the pertrub factor. More...
void	Merge (int32 target_components, std::vector< int32 > *history=NULL)
	Merge the components and remember the order in which the components were merged (flat list of pairs) More...
BaseFloat	MergePreselect (int32 target_components, const std::vector< std::pair< int32, int32 > > &preselect_pairs)
	Merge the components and remember the order in which the components were merged (flat list of pairs); this version only considers merging pairs in "preselect_pairs" (or their descendants after merging). More...
void	Write (std::ostream &os, bool binary) const
void	Read (std::istream &is, bool binary)
void	Interpolate (BaseFloat rho, const FullGmm &source, GmmFlagsType flags=kGmmAll)
	this = rho x source + (1-rho) x this More...
const Vector< BaseFloat > &	gconsts () const
	Const accessors. More...
const Vector< BaseFloat > &	weights () const
const Matrix< BaseFloat > &	means_invcovars () const
const std::vector< SpMatrix< BaseFloat > > &	inv_covars () const
Matrix< BaseFloat > &	means_invcovars ()
	Non-const accessors. More...
std::vector< SpMatrix< BaseFloat > > &	inv_covars ()
template<class Real >
void	SetWeights (const Vector< Real > &w)
	Mutators for both float or double. More...
template<class Real >
void	SetMeans (const Matrix< Real > &m)
	Use SetMeans to update only the Gaussian means (and not variances) More...
template<class Real >
void	SetInvCovarsAndMeans (const std::vector< SpMatrix< Real > > &invcovars, const Matrix< Real > &means)
	Use SetInvCovarsAndMeans if updating both means and (inverse) covariances. More...
template<class Real >
void	SetInvCovarsAndMeansInvCovars (const std::vector< SpMatrix< Real > > &invcovars, const Matrix< Real > &means_invcovars)
	Use this if setting both, in the class's native format. More...
template<class Real >
void	SetInvCovars (const std::vector< SpMatrix< Real > > &v)
	Set the (inverse) covariances and recompute means_invcovars_. More...
template<class Real >
void	GetCovars (std::vector< SpMatrix< Real > > *v) const
	Accessor for covariances. More...
template<class Real >
void	GetMeans (Matrix< Real > *m) const
	Accessor for means. More...
template<class Real >
void	GetCovarsAndMeans (std::vector< SpMatrix< Real > > *covars, Matrix< Real > *means) const
	Accessor for covariances and means. More...
void	RemoveComponent (int32 gauss, bool renorm_weights)
	Mutators for single component, supports float or double Removes single component from model. More...
void	RemoveComponents (const std::vector< int32 > &gauss, bool renorm_weights)
	Removes multiple components from model; "gauss" must not have dups. More...
template<class Real >
void	GetComponentMean (int32 gauss, VectorBase< Real > *out) const
	Accessor for component mean. More...

Private Member Functions
void	ResizeInvCovars (int32 nMix, int32 dim)
	Resizes arrays to this dim. Does not initialize data. More...
BaseFloat	MergedComponentsLogdet (BaseFloat w1, BaseFloat w2, const VectorBase< BaseFloat > &f1, const VectorBase< BaseFloat > &f2, const SpMatrix< BaseFloat > &s1, const SpMatrix< BaseFloat > &s2) const
const FullGmm &	operator= (const FullGmm &other)

Private Attributes
Vector< BaseFloat >	gconsts_
	Equals log(weight) - 0.5 * (log det(var) + mean'*inv(var)*mean) More...
bool	valid_gconsts_
	Recompute gconsts_ if false. More...
Vector< BaseFloat >	weights_
	weights (not log). More...
std::vector< SpMatrix< BaseFloat > >	inv_covars_
	Inverse covariances. More...
Matrix< BaseFloat >	means_invcovars_
	Means times inverse covariances. More...

Friends
class	FullGmmNormal
	this makes it a little easier to modify the internals More...

Detailed Description

Definition for Gaussian Mixture Model with full covariances.

Definition at line 40 of file full-gmm.h.

Constructor & Destructor Documentation

FullGmm() [1/3]

FullGmm ( )

inline

Empty constructor.

Definition at line 46 of file full-gmm.h.

Referenced by FullGmm::Split().

: valid_gconsts_(false) {}

FullGmm() [2/3]

FullGmm ( const FullGmm &  gmm )

inlineexplicit

Definition at line 48 of file full-gmm.h.

References FullGmm::CopyFromFullGmm().

                                      : valid_gconsts_(false) {
    CopyFromFullGmm(gmm);
  }

FullGmm() [3/3]

FullGmm ( int32  nMix, int32  dim  )

inline

Definition at line 52 of file full-gmm.h.

References FullGmm::Resize().

: valid_gconsts_(false) { Resize(nMix, dim); }

Member Function Documentation

ComponentLogLikelihood()

BaseFloat ComponentLogLikelihood	(	const VectorBase< BaseFloat > &	data,
		int32	comp_id
	)		const

Computes the contribution log-likelihood of a data point from a single Gaussian component.

NOTE: Currently we make no guarantees about what happens if one of the variances is zero.

Definition at line 562 of file full-gmm.cc.

References FullGmm::Dim(), VectorBase< Real >::Dim(), FullGmm::gconsts_, FullGmm::inv_covars_, KALDI_ERR, FullGmm::means_invcovars_, MatrixBase< Real >::Row(), FullGmm::valid_gconsts_, kaldi::VecSpVec(), and kaldi::VecVec().

Referenced by FullGmm::Dim().

                                                               {
  if (!valid_gconsts_)
    KALDI_ERR << "Must call ComputeGconsts() before computing likelihood";
  if (data.Dim() != Dim()) {
    KALDI_ERR << "DiagGmm::ComponentLogLikelihood, dimension "
        << "mismatch " << (data.Dim()) << "vs. "<< (Dim());
  }
  BaseFloat loglike;

  // loglike =  means * inv(vars) * data.
  loglike = VecVec(means_invcovars_.Row(comp_id), data);
  // loglike += -0.5 * tr(data*data'*inv(covar))
  loglike -= 0.5 * VecSpVec(data, inv_covars_[comp_id], data);
  return loglike + gconsts_(comp_id);
}

ComponentPosteriors()

BaseFloat ComponentPosteriors	(	const VectorBase< BaseFloat > &	data,
		VectorBase< BaseFloat > *	posterior
	)		const

Computes the posterior probabilities of all Gaussian components given a data point.

Returns the log-likehood of the data given the GMM.

Definition at line 719 of file full-gmm.cc.

References VectorBase< Real >::ApplySoftMax(), VectorBase< Real >::CopyFromVec(), KALDI_ERR, KALDI_ISINF, KALDI_ISNAN, and FullGmm::LogLikelihoods().

Referenced by IvectorExtractorStats::AccStatsForUtterance(), AccumFullGmm::AccumulateFromFull(), FullGmm::Dim(), TestComponentAcc(), kaldi::TestIvectorExtraction(), and UnitTestFullGmm().

                                                                               {
  if (posterior == NULL) KALDI_ERR << "NULL pointer passed as return argument.";
  Vector<BaseFloat> loglikes;
  LogLikelihoods(data, &loglikes);
  BaseFloat log_sum = loglikes.ApplySoftMax();
  if (KALDI_ISNAN(log_sum) || KALDI_ISINF(log_sum))
    KALDI_ERR << "Invalid answer (overflow or invalid variances/features?)";
  posterior->CopyFromVec(loglikes);
  return log_sum;
}

ComputeGconsts()

int32 ComputeGconsts

(

)

Sets the gconsts.

Returns the number that are "invalid" e.g. because of zero weights or variances.

Definition at line 92 of file full-gmm.cc.

References FullGmm::Dim(), FullGmm::gconsts_, FullGmm::inv_covars_, SpMatrix< Real >::InvertDouble(), KALDI_ASSERT, KALDI_ERR, KALDI_ISINF, KALDI_ISNAN, kaldi::Log(), SpMatrix< Real >::LogPosDefDet(), M_LOG_2PI, FullGmm::means_invcovars_, FullGmm::NumGauss(), MatrixBase< Real >::Row(), FullGmm::valid_gconsts_, kaldi::VecSpVec(), and FullGmm::weights_.

Referenced by Sgmm2Project::ApplyProjection(), FullGmm::CopyFromDiagGmm(), FullGmm::Dim(), kaldi::unittest::InitRandFullGmm(), FullGmm::Interpolate(), main(), FullGmm::Merge(), kaldi::MergeFullGmm(), FullGmm::MergePreselect(), kaldi::MleFullGmmUpdate(), FullGmm::Perturb(), FullGmm::Read(), FullGmm::Split(), test_flags_driven_update(), UnitTestEstimateFullGmm(), and UnitTestFullGmm().

                              {
  int32 num_mix = NumGauss(),
         dim = Dim();
  KALDI_ASSERT(num_mix > 0 && dim > 0);
  BaseFloat offset = -0.5 * M_LOG_2PI * dim;  // constant term in gconst.
  int32 num_bad = 0;

  // Resize if Gaussians have been removed during Update()
  if (num_mix != gconsts_.Dim()) gconsts_.Resize(num_mix);

  for (int32 mix = 0; mix < num_mix; mix++) {
    KALDI_ASSERT(weights_(mix) >= 0);  // Cannot have negative weights.
    BaseFloat gc = Log(weights_(mix)) + offset;  // May be -inf if weights == 0
    SpMatrix<BaseFloat> covar(inv_covars_[mix]);
    covar.InvertDouble();
    BaseFloat logdet = covar.LogPosDefDet();
    gc -= 0.5 * (logdet + VecSpVec(means_invcovars_.Row(mix),
                                   covar, means_invcovars_.Row(mix)));
    // Note that mean_invcovars(mix)' * covar(mix) * mean_invcovars(mix, d) is
    // really mean' * inv(covar) * mean, since mean_invcovars(mix, d) contains
    // the inverse covariance times mean.
    // So gc is the likelihood at zero feature value.

    if (KALDI_ISNAN(gc)) {  // negative infinity is OK but NaN is not acceptable
      KALDI_ERR << "At component " << mix
                << ", not a number in gconst computation";
    }
    if (KALDI_ISINF(gc)) {
      num_bad++;
      // If positive infinity, make it negative infinity.
      // Want to make sure the answer becomes -inf in the end, not NaN.
      if (gc > 0) gc = -gc;
    }
    gconsts_(mix) = gc;
  }

  valid_gconsts_ = true;
  return num_bad;
}

CopyFromDiagGmm()

void CopyFromDiagGmm

(

const DiagGmm &

diaggmm

)

Copies from given DiagGmm.

Definition at line 77 of file full-gmm.cc.

References FullGmm::ComputeGconsts(), MatrixBase< Real >::CopyFromMat(), rnnlm::d, FullGmm::Dim(), DiagGmm::Dim(), DiagGmm::gconsts(), FullGmm::gconsts_, FullGmm::inv_covars_, DiagGmm::inv_vars(), FullGmm::means_invcovars_, DiagGmm::means_invvars(), FullGmm::NumGauss(), DiagGmm::NumGauss(), FullGmm::Resize(), DiagGmm::weights(), and FullGmm::weights_.

Referenced by FullGmm::Dim(), main(), and UnitTestFullGmm().

                                                    {
  Resize(diaggmm.NumGauss(), diaggmm.Dim());
  gconsts_.CopyFromVec(diaggmm.gconsts());
  weights_.CopyFromVec(diaggmm.weights());
  means_invcovars_.CopyFromMat(diaggmm.means_invvars());
  int32 ncomp = NumGauss(), dim = Dim();
  for (int32 mix = 0; mix < ncomp; mix++) {
    inv_covars_[mix].SetZero();
    for (int32 d = 0; d < dim; d++) {
      inv_covars_[mix](d, d) = diaggmm.inv_vars()(mix, d);
    }
  }
  ComputeGconsts();
}

CopyFromFullGmm()

void CopyFromFullGmm

(

const FullGmm &

fullgmm

)

Copies from given FullGmm.

Definition at line 65 of file full-gmm.cc.

References MatrixBase< Real >::CopyFromMat(), FullGmm::Dim(), FullGmm::gconsts_, FullGmm::inv_covars_, FullGmm::means_invcovars_, FullGmm::NumGauss(), FullGmm::Resize(), FullGmm::valid_gconsts_, and FullGmm::weights_.

Referenced by FullGmm::Dim(), FullGmm::FullGmm(), kaldi::MergeFullGmm(), FullGmm::Split(), test_flags_driven_update(), test_io(), and UnitTestFullGmm().

                                                    {
  Resize(fullgmm.NumGauss(), fullgmm.Dim());
  gconsts_.CopyFromVec(fullgmm.gconsts_);
  weights_.CopyFromVec(fullgmm.weights_);
  means_invcovars_.CopyFromMat(fullgmm.means_invcovars_);
  int32 ncomp = NumGauss();
  for (int32 mix = 0; mix < ncomp; mix++) {
    inv_covars_[mix].CopyFromSp(fullgmm.inv_covars_[mix]);
  }
  valid_gconsts_ = fullgmm.valid_gconsts_;
}

Dim()

int32 Dim ( ) const

inline

Returns the dimensionality of the Gaussian mean vectors.

Definition at line 60 of file full-gmm.h.

References FullGmm::ComponentLogLikelihood(), FullGmm::ComponentPosteriors(), FullGmm::ComputeGconsts(), FullGmm::CopyFromDiagGmm(), FullGmm::CopyFromFullGmm(), FullGmm::GaussianSelection(), FullGmm::GaussianSelectionPreselect(), FullGmm::Interpolate(), kaldi::kGmmAll, FullGmm::LogLikelihood(), FullGmm::LogLikelihoods(), FullGmm::LogLikelihoodsPreselect(), FullGmm::means_invcovars_, FullGmm::Merge(), FullGmm::MergePreselect(), MatrixBase< Real >::NumCols(), FullGmm::Perturb(), FullGmm::Read(), FullGmm::Split(), and FullGmm::Write().

Referenced by AccumFullGmm::AccumulateFromFull(), FullGmm::ComponentLogLikelihood(), kaldi::ComputeFeatureNormalizingTransform(), FullGmm::ComputeGconsts(), Sgmm2Project::ComputeLdaStats(), FullGmm::CopyFromDiagGmm(), FullGmmNormal::CopyFromFullGmm(), FullGmm::CopyFromFullGmm(), DiagGmm::CopyFromFullGmm(), FullGmmNormal::CopyToFullGmm(), FullGmm::GetComponentMean(), FullGmm::GetCovars(), FullGmm::GetCovarsAndMeans(), GetLogLikeTest(), FullGmm::GetMeans(), AmSgmm2::InitializeFromFullGmm(), FullGmm::Interpolate(), DiagGmm::Interpolate(), FullGmm::LogLikelihoods(), FullGmm::LogLikelihoodsPreselect(), main(), FullGmm::Merge(), kaldi::MergeFullGmm(), FullGmm::MergePreselect(), kaldi::MleFullGmmUpdate(), kaldi::MlObjective(), FullGmm::Perturb(), AccumFullGmm::Resize(), FullGmm::SetInvCovars(), FullGmm::SetInvCovarsAndMeans(), FullGmm::Split(), test_flags_driven_update(), test_io(), TestComponentAcc(), UnitTestEstimateFullGmm(), and UnitTestFullGmm().

{ return means_invcovars_.NumCols(); }

GaussianSelection()

BaseFloat GaussianSelection	(	const VectorBase< BaseFloat > &	data,
		int32	num_gselect,
		std::vector< int32 > *	output
	)		const

Get gaussian selection information for one frame.

Returns log-like for this frame. Output is the best "num_gselect" indices, sorted from best to worst likelihood. If "num_gselect" > NumGauss(), sets it to NumGauss().

Definition at line 637 of file full-gmm.cc.

References VectorBase< Real >::Data(), rnnlm::j, KALDI_ASSERT, kaldi::kUndefined, kaldi::LogAdd(), FullGmm::LogLikelihoods(), and FullGmm::NumGauss().

Referenced by FullGmm::Dim(), and main().

                                                                     {
  int32 num_gauss = NumGauss();
  Vector<BaseFloat> loglikes(num_gauss, kUndefined);
  output->clear();
  this->LogLikelihoods(data, &loglikes);

  BaseFloat thresh;
  if (num_gselect < num_gauss) {
    Vector<BaseFloat> loglikes_copy(loglikes);
    BaseFloat *ptr = loglikes_copy.Data();
    std::nth_element(ptr, ptr+num_gauss-num_gselect, ptr+num_gauss);
    thresh = ptr[num_gauss-num_gselect];
  } else {
    thresh = -std::numeric_limits<BaseFloat>::infinity();
  }
  BaseFloat tot_loglike = -std::numeric_limits<BaseFloat>::infinity();
  std::vector<std::pair<BaseFloat, int32> > pairs;
  for (int32 p = 0; p < num_gauss; p++) {
    if (loglikes(p) >= thresh) {
      pairs.push_back(std::make_pair(loglikes(p), p));
    }
  }
  std::sort(pairs.begin(), pairs.end(),
            std::greater<std::pair<BaseFloat, int32> >());
  for (int32 j = 0;
       j < num_gselect && j < static_cast<int32>(pairs.size());
       j++) {
    output->push_back(pairs[j].second);
    tot_loglike = LogAdd(tot_loglike, pairs[j].first);
  }
  KALDI_ASSERT(!output->empty());
  return tot_loglike;
}

GaussianSelectionPreselect()

BaseFloat GaussianSelectionPreselect	(	const VectorBase< BaseFloat > &	data,
		const std::vector< int32 > &	preselect,
		int32	num_gselect,
		std::vector< int32 > *	output
	)		const

Get gaussian selection information for one frame.

Returns log-like for this frame. Output is the best "num_gselect" indices that were preselected, sorted from best to worst likelihood. If "num_gselect" > NumGauss(), sets it to NumGauss().

Definition at line 674 of file full-gmm.cc.

References VectorBase< Real >::Data(), rnnlm::j, KALDI_ASSERT, KALDI_WARN, kaldi::LogAdd(), and FullGmm::LogLikelihoodsPreselect().

Referenced by FullGmm::Dim(), and main().

                                    {
  static bool warned_size = false;
  int32 preselect_sz = preselect.size();
  int32 this_num_gselect = std::min(num_gselect, preselect_sz);
  if (preselect_sz <= num_gselect && !warned_size) {
    warned_size = true;
    KALDI_WARN << "Preselect size is less or equal to than final size, "
               << "doing nothing: " << preselect_sz << " < " <<  num_gselect
               << " [won't warn again]";
  }
  Vector<BaseFloat> loglikes(preselect_sz);
  LogLikelihoodsPreselect(data, preselect, &loglikes);

  Vector<BaseFloat> loglikes_copy(loglikes);
  BaseFloat *ptr = loglikes_copy.Data();
  std::nth_element(ptr, ptr+preselect_sz-this_num_gselect,
                   ptr+preselect_sz);
  BaseFloat thresh = ptr[preselect_sz-this_num_gselect];

  BaseFloat tot_loglike = -std::numeric_limits<BaseFloat>::infinity();
  // we want the output sorted from best likelihood to worse
  // (so we can prune further without the model)...
  std::vector<std::pair<BaseFloat, int32> > pairs;
  for (int32 p = 0; p < preselect_sz; p++)
    if (loglikes(p) >= thresh)
      pairs.push_back(std::make_pair(loglikes(p), preselect[p]));
  std::sort(pairs.begin(), pairs.end(),
            std::greater<std::pair<BaseFloat, int32> >());
  output->clear();
  for (int32 j = 0;
       j < this_num_gselect && j < static_cast<int32>(pairs.size());
       j++) {
    output->push_back(pairs[j].second);
    tot_loglike = LogAdd(tot_loglike, pairs[j].first);
  }
  KALDI_ASSERT(!output->empty());
  return tot_loglike;
}

gconsts()

const Vector<BaseFloat>& gconsts ( ) const

inline

Const accessors.

Definition at line 143 of file full-gmm.h.

References FullGmm::gconsts_.

Referenced by DiagGmm::CopyFromFullGmm(), and kaldi::MlObjective().

{ return gconsts_; }

GetComponentMean()

void GetComponentMean	(	int32	gauss,
		VectorBase< Real > *	out
	)		const

Accessor for component mean.

Definition at line 151 of file full-gmm-inl.h.

References VectorBase< Real >::AddSpVec(), SpMatrix< Real >::CopyFromSp(), VectorBase< Real >::CopyFromVec(), FullGmm::Dim(), VectorBase< Real >::Dim(), FullGmm::inv_covars_, SpMatrix< Real >::InvertDouble(), KALDI_ASSERT, FullGmm::means_invcovars_, FullGmm::NumGauss(), MatrixBase< Real >::Row(), and VectorBase< Real >::SetZero().

Referenced by FullGmm::inv_covars(), and UnitTestFullGmm().

                                                            {
  KALDI_ASSERT(gauss < NumGauss() && out != NULL);
  KALDI_ASSERT(out->Dim() == Dim());
  out->SetZero();
  SpMatrix<Real> covar(Dim());
  Vector<Real> mean_times_invcovar(Dim());
  covar.CopyFromSp(inv_covars_[gauss]);
  covar.InvertDouble();
  mean_times_invcovar.CopyFromVec(means_invcovars_.Row(gauss));
  out->AddSpVec(1.0, covar, mean_times_invcovar, 0.0);
}

GetCovars()

void GetCovars

(

std::vector< SpMatrix< Real > > *

v

)

const

Accessor for covariances.

Definition at line 106 of file full-gmm-inl.h.

References FullGmm::Dim(), rnnlm::i, FullGmm::inv_covars_, and KALDI_ASSERT.

Referenced by FullGmm::inv_covars(), test_flags_driven_update(), and UnitTestFullGmm().

                                                           {
  KALDI_ASSERT(v != NULL);
  v->resize(inv_covars_.size());
  size_t dim = Dim();
  for (size_t i = 0; i < inv_covars_.size(); i++) {
    (*v)[i].Resize(dim);
    (*v)[i].CopyFromSp(inv_covars_[i]);
    (*v)[i].InvertDouble();
  }
}

GetCovarsAndMeans()

void GetCovarsAndMeans	(	std::vector< SpMatrix< Real > > *	covars,
		Matrix< Real > *	means
	)		const

Accessor for covariances and means.

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

References VectorBase< Real >::CopyFromVec(), FullGmm::Dim(), rnnlm::i, FullGmm::inv_covars_, KALDI_ASSERT, FullGmm::means_invcovars_, FullGmm::NumGauss(), Matrix< Real >::Resize(), and MatrixBase< Real >::Row().

Referenced by kaldi::ComputeFeatureNormalizingTransform(), FullGmm::inv_covars(), and UnitTestFullGmm().

                                                           {
  KALDI_ASSERT(covars != NULL && means != NULL);
  size_t dim = Dim();
  size_t num_gauss = NumGauss();
  covars->resize(num_gauss);
  means->Resize(num_gauss, dim);
  Vector<Real> mean_times_invcovar(Dim());
  for (size_t i = 0; i < num_gauss; i++) {
    (*covars)[i].Resize(dim);
    (*covars)[i].CopyFromSp(inv_covars_[i]);
    (*covars)[i].InvertDouble();
    mean_times_invcovar.CopyFromVec(means_invcovars_.Row(i));
    (means->Row(i)).AddSpVec(1.0, (*covars)[i], mean_times_invcovar, 0.0);
  }
}

GetMeans()

void GetMeans

(

Matrix< Real > *

m

)

const

Accessor for means.

Definition at line 118 of file full-gmm-inl.h.

References SpMatrix< Real >::CopyFromSp(), VectorBase< Real >::CopyFromVec(), FullGmm::Dim(), rnnlm::i, FullGmm::inv_covars_, SpMatrix< Real >::InvertDouble(), KALDI_ASSERT, FullGmm::means_invcovars_, FullGmm::NumGauss(), Matrix< Real >::Resize(), and MatrixBase< Real >::Row().

Referenced by DiagGmm::CopyFromFullGmm(), GetLogLikeTest(), FullGmm::inv_covars(), IvectorExtractor::IvectorExtractor(), test_flags_driven_update(), and UnitTestFullGmm().

                                            {
  KALDI_ASSERT(M != NULL);
  M->Resize(NumGauss(), Dim());
  SpMatrix<Real> covar(Dim());
  Vector<Real> mean_times_invcovar(Dim());
  for (int32 i = 0; i < NumGauss(); i++) {
    covar.CopyFromSp(inv_covars_[i]);
    covar.InvertDouble();
    mean_times_invcovar.CopyFromVec(means_invcovars_.Row(i));
    (M->Row(i)).AddSpVec(1.0, covar, mean_times_invcovar, 0.0);
  }
}

Interpolate()

void Interpolate	(	BaseFloat	rho,
		const FullGmm &	source,
		GmmFlagsType	flags = kGmmAll
	)

this = rho x source + (1-rho) x this

Definition at line 784 of file full-gmm.cc.

References FullGmm::ComputeGconsts(), FullGmm::Dim(), rnnlm::i, KALDI_ASSERT, kaldi::kGmmMeans, kaldi::kGmmVariances, kaldi::kGmmWeights, FullGmmNormal::means_, FullGmm::NumGauss(), FullGmmNormal::vars_, and FullGmmNormal::weights_.

Referenced by FullGmm::Dim().

                                              {
  KALDI_ASSERT(NumGauss() == source.NumGauss());
  KALDI_ASSERT(Dim() == source.Dim());
  FullGmmNormal us(*this);
  FullGmmNormal them(source);

  if (flags & kGmmWeights) {
    us.weights_.Scale(1.0 - rho);
    us.weights_.AddVec(rho, them.weights_);
    us.weights_.Scale(1.0 / us.weights_.Sum());
  }

  if (flags & kGmmMeans) {
    us.means_.Scale(1.0 - rho);
    us.means_.AddMat(rho, them.means_);
  }

  if (flags & kGmmVariances) {
    for (int32 i = 0; i < NumGauss(); i++) {
      us.vars_[i].Scale(1.0 - rho);
      us.vars_[i].AddSp(rho, them.vars_[i]);
    }
  }

  us.CopyToFullGmm(this);
  ComputeGconsts();
}

inv_covars() [1/2]

const std::vector<SpMatrix<BaseFloat> >& inv_covars ( ) const

inline

Definition at line 146 of file full-gmm.h.

References FullGmm::inv_covars_.

Referenced by DiagGmm::CopyFromFullGmm(), GetLogLikeTest(), IvectorExtractor::IvectorExtractor(), kaldi::MergeFullGmm(), kaldi::MlObjective(), and UnitTestEstimateFullGmm().

                                                            {
    return inv_covars_; }

inv_covars() [2/2]

std::vector<SpMatrix<BaseFloat> >& inv_covars ( )

inline

Definition at line 151 of file full-gmm.h.

References FullGmm::GetComponentMean(), FullGmm::GetCovars(), FullGmm::GetCovarsAndMeans(), FullGmm::GetMeans(), FullGmm::inv_covars_, FullGmm::means_invcovars(), FullGmm::RemoveComponent(), FullGmm::RemoveComponents(), FullGmm::SetInvCovars(), FullGmm::SetInvCovarsAndMeans(), FullGmm::SetInvCovarsAndMeansInvCovars(), FullGmm::SetMeans(), and FullGmm::SetWeights().

{ return inv_covars_; }

LogLikelihood()

BaseFloat LogLikelihood

(

const VectorBase< BaseFloat > &

data

)

const

Returns the log-likelihood of a data point (vector) given the GMM.

Definition at line 582 of file full-gmm.cc.

References KALDI_ERR, KALDI_ISINF, KALDI_ISNAN, FullGmm::LogLikelihoods(), and VectorBase< Real >::LogSumExp().

Referenced by FullGmm::Dim(), main(), test_flags_driven_update(), test_io(), TestComponentAcc(), and UnitTestFullGmm().

                                                                        {
  Vector<BaseFloat> loglikes;
  LogLikelihoods(data, &loglikes);
  BaseFloat log_sum = loglikes.LogSumExp();
  if (KALDI_ISNAN(log_sum) || KALDI_ISINF(log_sum))
    KALDI_ERR << "Invalid answer (overflow or invalid variances/features?)";
  return log_sum;
}

LogLikelihoods()

void LogLikelihoods	(	const VectorBase< BaseFloat > &	data,
		Vector< BaseFloat > *	loglikes
	)		const

Outputs the per-component contributions to the log-likelihood.

Definition at line 591 of file full-gmm.cc.

References VectorBase< Real >::AddMatVec(), VectorBase< Real >::CopyFromVec(), FullGmm::Dim(), VectorBase< Real >::Dim(), FullGmm::gconsts_, FullGmm::inv_covars_, KALDI_ASSERT, kaldi::kNoTrans, kaldi::kUndefined, FullGmm::means_invcovars_, FullGmm::NumGauss(), Vector< Real >::Resize(), and kaldi::TraceSpSpLower().

Referenced by FullGmm::ComponentPosteriors(), FullGmm::Dim(), FullGmm::GaussianSelection(), FullGmm::LogLikelihood(), and UnitTestFullGmm().

                                                                {
  loglikes->Resize(gconsts_.Dim(), kUndefined);
  loglikes->CopyFromVec(gconsts_);
  int32 dim = Dim();
  KALDI_ASSERT(dim == data.Dim());
  SpMatrix<BaseFloat> data_sq(dim);  // Initialize and make zero
  data_sq.AddVec2(1.0, data);
  // The following enables an optimization below: TraceSpSpLower, which is
  // just like a dot product internally.
  data_sq.ScaleDiag(0.5);

  // loglikes += mean' * inv(covar) * data.
  loglikes->AddMatVec(1.0, means_invcovars_, kNoTrans, data, 1.0);
  // loglikes -= 0.5 * data'*inv(covar)*data = 0.5 * tr(data*data'*inv(covar))
  int32 num_comp = NumGauss();
  for (int32 mix = 0; mix < num_comp; mix++) {
    // was: (*loglikes)(mix) -= 0.5 * TraceSpSp(data_sq, inv_covars_[mix]);
    (*loglikes)(mix) -= TraceSpSpLower(data_sq, inv_covars_[mix]);
  }
}

LogLikelihoodsPreselect()

void LogLikelihoodsPreselect	(	const VectorBase< BaseFloat > &	data,
		const std::vector< int32 > &	indices,
		Vector< BaseFloat > *	loglikes
	)		const

Outputs the per-component log-likelihoods of a subset of mixture components.

Note: indices.size() will equal loglikes->Dim() at output. loglikes[i] will correspond to the log-likelihood of the Gaussian indexed indices[i].

Definition at line 613 of file full-gmm.cc.

References SpMatrix< Real >::AddVec2(), FullGmm::Dim(), VectorBase< Real >::Dim(), FullGmm::gconsts_, rnnlm::i, FullGmm::inv_covars_, KALDI_ASSERT, kaldi::kUndefined, FullGmm::means_invcovars_, Vector< Real >::Resize(), MatrixBase< Real >::Row(), PackedMatrix< Real >::ScaleDiag(), kaldi::TraceSpSpLower(), and kaldi::VecVec().

Referenced by FullGmm::Dim(), FullGmm::GaussianSelectionPreselect(), main(), and UnitTestFullGmm().

                                                                         {
  int32 dim = Dim();
  KALDI_ASSERT(dim == data.Dim());
  int32 num_indices = static_cast<int32>(indices.size());
  loglikes->Resize(num_indices, kUndefined);

  SpMatrix<BaseFloat> data_sq(dim);  // Initialize and make zero
  data_sq.AddVec2(1.0, data);
  // The following enables an optimization below: TraceSpSpLower, which is
  // just like a dot product internally.
  data_sq.ScaleDiag(0.5);

  for (int32 i = 0; i < num_indices; i++) {
    int32 idx = indices[i];
    (*loglikes)(i) = gconsts_(idx)
        + VecVec(means_invcovars_.Row(idx), data)
        - TraceSpSpLower(data_sq, inv_covars_[idx]);
  }
}

means_invcovars() [1/2]

const Matrix<BaseFloat>& means_invcovars ( ) const

inline

Definition at line 145 of file full-gmm.h.

References FullGmm::means_invcovars_.

Referenced by FullGmm::inv_covars(), kaldi::MergeFullGmm(), kaldi::MlObjective(), and UnitTestEstimateFullGmm().

{ return means_invcovars_; }

means_invcovars() [2/2]

Matrix<BaseFloat>& means_invcovars ( )

inline

Non-const accessors.

Definition at line 150 of file full-gmm.h.

References FullGmm::means_invcovars_.

{ return means_invcovars_; }

Merge()

void Merge	(	int32	target_components,
		std::vector< int32 > *	history = NULL
	)

Merge the components and remember the order in which the components were merged (flat list of pairs)

Definition at line 206 of file full-gmm.cc.

References VectorBase< Real >::AddVec(), kaldi::ApproxEqual(), FullGmm::ComputeGconsts(), FullGmm::Dim(), FullGmm::gconsts_, rnnlm::i, FullGmm::inv_covars_, rnnlm::j, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, FullGmm::means_invcovars_, FullGmm::MergedComponentsLogdet(), FullGmm::NumGauss(), Matrix< Real >::RemoveRow(), Matrix< Real >::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::Scale(), VectorBase< Real >::SetZero(), FullGmm::weights(), and FullGmm::weights_.

Referenced by FullGmm::Dim(), and UnitTestFullGmm().

                                                                   {
  if (target_components <= 0 || NumGauss() < target_components) {
    KALDI_ERR << "Invalid argument for target number of Gaussians (="
        << target_components << ")";
  }
  if (NumGauss() == target_components) {
    KALDI_WARN << "No components merged, as target = total.";
    return;
  }

  int32 num_comp = NumGauss(), dim = Dim();

  if (target_components == 1) {  // global mean and variance
    Vector<BaseFloat> weights(weights_);
    // Undo variance inversion and multiplication of mean by this
    vector<SpMatrix<BaseFloat> > covars(num_comp);
    Matrix<BaseFloat> means(num_comp, dim);
    for (int32 i = 0; i < num_comp; i++) {
      covars[i].Resize(dim);
      covars[i].CopyFromSp(inv_covars_[i]);
      covars[i].InvertDouble();
      means.Row(i).AddSpVec(1.0, covars[i], means_invcovars_.Row(i), 0.0);
      covars[i].AddVec2(1.0, means.Row(i));
    }

    // Slightly more efficient than calling this->Resize(1, dim)
    gconsts_.Resize(1);
    weights_.Resize(1);
    means_invcovars_.Resize(1, dim);
    inv_covars_.resize(1);
    inv_covars_[0].Resize(dim);
    Vector<BaseFloat> tmp_mean(dim);

    for (int32 i = 0; i < num_comp; i++) {
      weights_(0) += weights(i);
      tmp_mean.AddVec(weights(i), means.Row(i));
      inv_covars_[0].AddSp(weights(i), covars[i]);
    }
    if (!ApproxEqual(weights_(0), 1.0, 1e-6)) {
      KALDI_WARN << "Weights sum to " << weights_(0) << ": rescaling.";
      tmp_mean.Scale(weights_(0));
      inv_covars_[0].Scale(weights_(0));
      weights_(0) = 1.0;
    }
    inv_covars_[0].AddVec2(-1.0, tmp_mean);
    inv_covars_[0].InvertDouble();
    means_invcovars_.Row(0).AddSpVec(1.0, inv_covars_[0], tmp_mean, 0.0);
    ComputeGconsts();
    return;
  }

  // If more than 1 merged component is required, do greedy bottom-up
  // clustering, always picking the pair of components that lead to the smallest
  // decrease in likelihood.
  vector<bool> discarded_component(num_comp);
  Vector<BaseFloat> logdet(num_comp);   // logdet for each component
  logdet.SetZero();
  for (int32 i = 0; i < num_comp; i++) {
    discarded_component[i] = false;
    logdet(i) += 0.5 * inv_covars_[i].LogPosDefDet();
    // +0.5 because var is inverted
  }

  // Undo variance inversion and multiplication of mean by this
  // Makes copy of means and vars for all components.
  vector<SpMatrix<BaseFloat> > vars(num_comp);
  Matrix<BaseFloat> means(num_comp, dim);
  for (int32 i = 0; i < num_comp; i++) {
    vars[i].Resize(dim);
    vars[i].CopyFromSp(inv_covars_[i]);
    vars[i].InvertDouble();
    means.Row(i).AddSpVec(1.0, vars[i], means_invcovars_.Row(i), 0.0);

    // add means square to variances; get second-order stats
    // (normalized by zero-order stats)
    vars[i].AddVec2(1.0, means.Row(i));
  }

  // compute change of likelihood for all combinations of components
  SpMatrix<BaseFloat> delta_like(num_comp);
  for (int32 i = 0; i < num_comp; i++) {
    for (int32 j = 0; j < i; j++) {
      BaseFloat w1 = weights_(i), w2 = weights_(j), w_sum = w1 + w2;
      BaseFloat merged_logdet = MergedComponentsLogdet(w1, w2,
        means.Row(i), means.Row(j), vars[i], vars[j]);
      delta_like(i, j) = w_sum * merged_logdet
        - w1 * logdet(i) - w2 * logdet(j);
    }
  }

  // Merge components with smallest impact on the loglike
  for (int32 removed = 0; removed < num_comp - target_components; removed++) {
    // Search for the least significant change in likelihood
    // (maximum of negative delta_likes)
    BaseFloat max_delta_like = -std::numeric_limits<BaseFloat>::max();
    int32 max_i = 0, max_j = 0;
    for (int32 i = 0; i < NumGauss(); i++) {
      if (discarded_component[i]) continue;
      for (int32 j = 0; j < i; j++) {
        if (discarded_component[j]) continue;
        if (delta_like(i, j) > max_delta_like) {
          max_delta_like = delta_like(i, j);
          max_i = i;
          max_j = j;
        }
      }
    }

    // make sure that different components will be merged
    KALDI_ASSERT(max_i != max_j);

    // remember history
    if (history != NULL) {
      history->push_back(max_i);
      history->push_back(max_j);
    }

    // Merge components
    BaseFloat w1 = weights_(max_i), w2 = weights_(max_j);
    BaseFloat w_sum = w1 + w2;
    // merge means
    means.Row(max_i).AddVec(w2/w1, means.Row(max_j));
    means.Row(max_i).Scale(w1/w_sum);
    // merge vars
    vars[max_i].AddSp(w2/w1, vars[max_j]);
    vars[max_i].Scale(w1/w_sum);
    // merge weights
    weights_(max_i) = w_sum;

    // Update gmm for merged component
    // copy second-order stats (normalized by zero-order stats)
    inv_covars_[max_i].CopyFromSp(vars[max_i]);
    // centralize
    inv_covars_[max_i].AddVec2(-1.0, means.Row(max_i));
    // invert
    inv_covars_[max_i].InvertDouble();
    // copy first-order stats (normalized by zero-order stats)
    // and multiply by inv_vars
    means_invcovars_.Row(max_i).AddSpVec(1.0, inv_covars_[max_i],
      means.Row(max_i), 0.0);

    // Update logdet for merged component
    logdet(max_i) += 0.5 * inv_covars_[max_i].LogPosDefDet();
    // +0.5 because var is inverted

    // Label the removed component as discarded
    discarded_component[max_j] = true;

    // Update delta_like for merged component
    for (int32 j = 0; j < num_comp; j++) {
      if ((j == max_i) || (discarded_component[j])) continue;
      BaseFloat w1 = weights_(max_i), w2 = weights_(j), w_sum = w1 + w2;
      BaseFloat merged_logdet = MergedComponentsLogdet(w1, w2,
        means.Row(max_i), means.Row(j), vars[max_i], vars[j]);
      delta_like(max_i, j) = w_sum * merged_logdet
        - w1 * logdet(max_i) - w2 * logdet(j);
      // doesn't respect lower triangular indeces,
      // relies on implicitly performed swap of coordinates if necessary
    }
  }

  // Remove the consumed components
  int32 m = 0;
  for (int32 i = 0; i < num_comp; i++) {
    if (discarded_component[i]) {
      weights_.RemoveElement(m);
      means_invcovars_.RemoveRow(m);
      inv_covars_.erase(inv_covars_.begin() + m);
    } else {
      ++m;
    }
  }

  ComputeGconsts();
}

MergedComponentsLogdet()

BaseFloat MergedComponentsLogdet ( BaseFloat  w1, BaseFloat  w2, const VectorBase< BaseFloat > &  f1, const VectorBase< BaseFloat > &  f2, const SpMatrix< BaseFloat > &  s1, const SpMatrix< BaseFloat > &  s2  ) const

private

Definition at line 537 of file full-gmm.cc.

References SpMatrix< Real >::AddSp(), VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2(), SpMatrix< Real >::CopyFromSp(), VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Dim(), SpMatrix< Real >::LogPosDefDet(), PackedMatrix< Real >::Scale(), and VectorBase< Real >::Scale().

Referenced by FullGmm::Merge(), and FullGmm::MergePreselect().

          {
  int32 dim = f1.Dim();
  Vector<BaseFloat> tmp_mean(dim);
  SpMatrix<BaseFloat> tmp_var(dim);
  BaseFloat merged_logdet = 0.0;

  BaseFloat w_sum = w1 + w2;
  tmp_mean.CopyFromVec(f1);
  tmp_mean.AddVec(w2/w1, f2);
  tmp_mean.Scale(w1/w_sum);
  tmp_var.CopyFromSp(s1);
  tmp_var.AddSp(w2/w1, s2);
  tmp_var.Scale(w1/w_sum);
  tmp_var.AddVec2(-1.0, tmp_mean);
  merged_logdet -= 0.5 * tmp_var.LogPosDefDet();
  // -0.5 because var is not inverted
  return merged_logdet;
}

MergePreselect()

BaseFloat MergePreselect	(	int32	target_components,
		const std::vector< std::pair< int32, int32 > > &	preselect_pairs
	)

Merge the components and remember the order in which the components were merged (flat list of pairs); this version only considers merging pairs in "preselect_pairs" (or their descendants after merging).

This is for efficiency, for large models. Returns the delta likelihood.

Definition at line 382 of file full-gmm.cc.

References kaldi::ApproxEqual(), FullGmm::ComputeGconsts(), FullGmm::Dim(), FullGmm::gconsts_, rnnlm::i, FullGmm::inv_covars_, KALDI_ASSERT, KALDI_VLOG, KALDI_WARN, kaldi::kCopyData, FullGmm::means_invcovars_, FullGmm::MergedComponentsLogdet(), FullGmm::NumGauss(), Matrix< Real >::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::SetZero(), FullGmm::valid_gconsts_, and FullGmm::weights_.

Referenced by FullGmm::Dim().

                                                                                {
  KALDI_ASSERT(!preselect.empty());
  double ans = 0.0;
  if (target_components <= 0 || NumGauss() < target_components) {
    KALDI_WARN << "Invalid argument for target number of Gaussians (="
               << target_components << "), currently "
               << NumGauss() << ", not mixing down";
    return 0.0;
  }
  if (NumGauss() == target_components) {
    KALDI_WARN << "No components merged, as target = total.";
    return 0.0;
  }
  // likelihood change (a negative or zero value), and then the pair of indices.
  typedef pair<BaseFloat, pair<int32, int32> > QueueElem;
  std::priority_queue<QueueElem> queue;

  int32 num_comp = NumGauss(), dim = Dim();

  // Do greedy bottom-up clustering, always picking the pair of components that
  // lead to the smallest decrease in likelihood.
  vector<bool> discarded_component(num_comp);
  Vector<BaseFloat> logdet(num_comp);   // logdet for each component
  logdet.SetZero();
  for (int32 i = 0; i < num_comp; i++) {
    discarded_component[i] = false;
    logdet(i) = 0.5 * inv_covars_[i].LogPosDefDet();
    // +0.5 because var is inverted
  }

  // Undo variance inversion and multiplication of mean by
  // inverse variance.
  // Makes copy of means and vars for all components.
  vector<SpMatrix<BaseFloat> > vars(num_comp);
  Matrix<BaseFloat> means(num_comp, dim);
  for (int32 i = 0; i < num_comp; i++) {
    vars[i].Resize(dim);
    vars[i].CopyFromSp(inv_covars_[i]);
    vars[i].InvertDouble();
    means.Row(i).AddSpVec(1.0, vars[i], means_invcovars_.Row(i), 0.0);

    // add means square to variances; get second-order stats
    // (normalized by zero-order stats)
    vars[i].AddVec2(1.0, means.Row(i));
  }

  // compute change of likelihood for all combinations of components
  for (int32 i = 0; i < preselect.size(); i++) {
    int32 idx1 = preselect[i].first, idx2 = preselect[i].second;
    KALDI_ASSERT(static_cast<size_t>(idx1) < static_cast<size_t>(num_comp));
    KALDI_ASSERT(static_cast<size_t>(idx2) < static_cast<size_t>(num_comp));
    BaseFloat w1 = weights_(idx1), w2 = weights_(idx2), w_sum = w1 + w2;
    BaseFloat merged_logdet = MergedComponentsLogdet(w1, w2,
                                                     means.Row(idx1), means.Row(idx2),
                                                     vars[idx1], vars[idx2]),
        delta_like = w_sum * merged_logdet - w1 * logdet(idx1) - w2 * logdet(idx2);
    queue.push(std::make_pair(delta_like, preselect[i]));
  }

  vector<int32> mapping(num_comp);  // map of old index to where it
  // got merged to.
  for (int32 i = 0; i < num_comp; i++) mapping[i] = i;

  // Merge components with smallest impact on the loglike
  int32 removed;
  for (removed = 0;
       removed < num_comp - target_components && !queue.empty(); ) {
    QueueElem qelem = queue.top();
    queue.pop();
    BaseFloat delta_log_like_old = qelem.first;
    int32 idx1 = qelem.second.first, idx2 = qelem.second.second;
    // the next 3 lines are to handle when components got merged
    // and moved to different indices, but we still want to consider
    // merging their descendants. [descendant = current index where
    // their data is.]
    while (discarded_component[idx1]) idx1 = mapping[idx1];
    while (discarded_component[idx2]) idx2 = mapping[idx2];
    if (idx1 == idx2) continue;  // can't merge something with itself.

    BaseFloat delta_log_like;
    { // work out delta_log_like.
      BaseFloat w1 = weights_(idx1), w2 = weights_(idx2), w_sum = w1 + w2;
      BaseFloat merged_logdet = MergedComponentsLogdet(w1, w2,
                                                       means.Row(idx1), means.Row(idx2),
                                                       vars[idx1], vars[idx2]);
      delta_log_like = w_sum * merged_logdet - w1 * logdet(idx1) - w2 * logdet(idx2);
    }
    if (ApproxEqual(delta_log_like, delta_log_like_old) ||
        delta_log_like > delta_log_like_old) {
      // if the log-like change did not change, or if it actually got smaller
      // (closer to zero, more positive), then merge the components; otherwise
      // put it back on the queue.  Note: there is no test for "freshness" --
      // we assume nothing is fresh.
      BaseFloat w1 = weights_(idx1), w2 = weights_(idx2);
      BaseFloat w_sum = w1 + w2;
      // merge means
      means.Row(idx1).AddVec(w2/w1, means.Row(idx2));
      means.Row(idx1).Scale(w1/w_sum);
      // merge vars
      vars[idx1].AddSp(w2/w1, vars[idx2]);
      vars[idx1].Scale(w1/w_sum);
      // merge weights
      weights_(idx1) = w_sum;

      // Update gmm for merged component
      // copy second-order stats (normalized by zero-order stats)
      inv_covars_[idx1].CopyFromSp(vars[idx1]);
      // centralize
      inv_covars_[idx1].AddVec2(-1.0, means.Row(idx1));
      // invert
      inv_covars_[idx1].InvertDouble();
      // copy first-order stats (normalized by zero-order stats)
      // and multiply by inv_vars
      means_invcovars_.Row(idx1).AddSpVec(1.0, inv_covars_[idx1],
                                           means.Row(idx1), 0.0);

      // Update logdet for merged component
      logdet(idx1) = 0.5 * inv_covars_[idx1].LogPosDefDet();
      // +0.5 because var is inverted

      // Label the removed component as discarded
      discarded_component[idx2] = true;
      KALDI_VLOG(2) << "Delta-log-like is " << delta_log_like <<  " (merging "
                    << idx1 << " and " << idx2 << ")";
      ans += delta_log_like;
      mapping[idx2] = idx1;
      removed++;
    } else {
      QueueElem new_elem(delta_log_like, std::make_pair(idx1, idx2));
      queue.push(new_elem);  // push back more accurate elem.
    }
  }

  // Renumber the components.
  int32 cur_idx = 0;
  for (int32 i = 0; i < num_comp; i++) {
    if (mapping[i] == i) {  // This component is kept, not merged into another.
      weights_(cur_idx) = weights_(i);
      means_invcovars_.Row(cur_idx).CopyFromVec(means_invcovars_.Row(i));
      inv_covars_[cur_idx].CopyFromSp(inv_covars_[i]);
      cur_idx++;
    }
  }
  KALDI_ASSERT(cur_idx + removed == num_comp);
  gconsts_.Resize(cur_idx);
  valid_gconsts_ = false;
  weights_.Resize(cur_idx, kCopyData);
  means_invcovars_.Resize(cur_idx, Dim(), kCopyData);
  inv_covars_.resize(cur_idx);
  ComputeGconsts();
  return ans;
}

NumGauss()

int32 NumGauss ( ) const

inline

Returns the number of mixture components in the GMM.

Definition at line 58 of file full-gmm.h.

References FullGmm::weights_.

Referenced by IvectorExtractorStats::AccStatsForUtterance(), AccumFullGmm::AccumulateFromFull(), kaldi::ComputeFeatureNormalizingTransform(), FullGmm::ComputeGconsts(), Sgmm2Project::ComputeLdaStats(), FullGmm::CopyFromDiagGmm(), FullGmmNormal::CopyFromFullGmm(), FullGmm::CopyFromFullGmm(), DiagGmm::CopyFromFullGmm(), FullGmmNormal::CopyToFullGmm(), FullGmm::GaussianSelection(), FullGmm::GetComponentMean(), FullGmm::GetCovarsAndMeans(), GetLogLikeTest(), FullGmm::GetMeans(), FullGmm::Interpolate(), DiagGmm::Interpolate(), IvectorExtractor::IvectorExtractor(), FullGmm::LogLikelihoods(), main(), FullGmm::Merge(), kaldi::MergeFullGmm(), FullGmm::MergePreselect(), kaldi::MleFullGmmUpdate(), kaldi::MlObjective(), FullGmm::Perturb(), FullGmm::RemoveComponent(), AccumFullGmm::Resize(), FullGmm::SetInvCovars(), FullGmm::SetInvCovarsAndMeans(), FullGmm::SetInvCovarsAndMeansInvCovars(), FullGmm::SetMeans(), FullGmm::Split(), test_flags_driven_update(), test_io(), TestComponentAcc(), kaldi::TestIvectorExtraction(), UnitTestEstimateFullGmm(), UnitTestFullGmm(), and FullGmm::Write().

{ return weights_.Dim(); }

operator=()

const FullGmm& operator= ( const FullGmm &  other )

private

Perturb()

void Perturb

(

float

perturb_factor

)

Perturbs the component means with a random vector multiplied by the pertrub factor.

Definition at line 191 of file full-gmm.cc.

References TpMatrix< Real >::Cholesky(), FullGmm::ComputeGconsts(), FullGmm::Dim(), rnnlm::i, FullGmm::inv_covars_, kaldi::kTrans, FullGmm::means_invcovars_, VectorBase< Real >::MulTp(), FullGmm::NumGauss(), MatrixBase< Real >::Row(), and VectorBase< Real >::SetRandn().

Referenced by FullGmm::Dim().

                                          {
  int32 num_comps = NumGauss(),
      dim = Dim();
  Vector<BaseFloat> rand_vec(dim);
  for (int32 i = 0; i < num_comps; i++) {
    rand_vec.SetRandn();
    TpMatrix<BaseFloat> invcovar_l(dim);
    invcovar_l.Cholesky(inv_covars_[i]);
    rand_vec.MulTp(invcovar_l, kTrans);
    means_invcovars_.Row(i).AddVec(perturb_factor, rand_vec);
  }
  ComputeGconsts();
}

Read()

void Read	(	std::istream &	is,
		bool	binary
	)

Definition at line 813 of file full-gmm.cc.

References FullGmm::ComputeGconsts(), kaldi::ExpectToken(), FullGmm::gconsts_, rnnlm::i, FullGmm::inv_covars_, KALDI_ERR, FullGmm::means_invcovars_, MatrixBase< Real >::NumCols(), Matrix< Real >::Read(), kaldi::ReadToken(), FullGmm::ResizeInvCovars(), and FullGmm::weights_.

Referenced by FullGmm::Dim(), main(), kaldi::operator>>(), and UnitTestFullGmm().

                                                     {
//  ExpectToken(in_stream, binary, "<FullGMMBegin>");
  std::string token;
  ReadToken(in_stream, binary, &token);
  // <FullGMMBegin> is for compatibility. Will be deleted later
  if (token != "<FullGMMBegin>" && token != "<FullGMM>")
    KALDI_ERR << "Expected <FullGMM>, got " << token;
//  ExpectToken(in_stream, binary, "<GCONSTS>");
  ReadToken(in_stream, binary, &token);
  if (token == "<GCONSTS>") {  // The gconsts are optional.
    gconsts_.Read(in_stream, binary);
    ExpectToken(in_stream, binary, "<WEIGHTS>");
  } else {
    if (token != "<WEIGHTS>")
      KALDI_ERR << "FullGmm::Read, expected <WEIGHTS> or <GCONSTS>, got "
                << token;
  }
  weights_.Read(in_stream, binary);
  ExpectToken(in_stream, binary, "<MEANS_INVCOVARS>");
  means_invcovars_.Read(in_stream, binary);
  ExpectToken(in_stream, binary, "<INV_COVARS>");
  int32 ncomp = weights_.Dim(), dim = means_invcovars_.NumCols();
  ResizeInvCovars(ncomp, dim);
  for (int32 i = 0; i < ncomp; i++) {
    inv_covars_[i].Read(in_stream, binary);
  }
//  ExpectToken(in_stream, binary, "<FullGMMEnd>");
  ReadToken(in_stream, binary, &token);
  // <FullGMMEnd> is for compatibility. Will be deleted later
  if (token != "<FullGMMEnd>" && token != "</FullGMM>")
    KALDI_ERR << "Expected </FullGMM>, got " << token;

  ComputeGconsts();  // safer option than trusting the read gconsts
}

RemoveComponent()

void RemoveComponent	(	int32	gauss,
		bool	renorm_weights
	)

Mutators for single component, supports float or double Removes single component from model.

Definition at line 731 of file full-gmm.cc.

References FullGmm::gconsts_, FullGmm::inv_covars_, KALDI_ASSERT, FullGmm::means_invcovars_, FullGmm::NumGauss(), Matrix< Real >::RemoveRow(), FullGmm::valid_gconsts_, and FullGmm::weights_.

Referenced by FullGmm::inv_covars(), and FullGmm::RemoveComponents().

                                                              {
  KALDI_ASSERT(gauss < NumGauss());

  weights_.RemoveElement(gauss);
  gconsts_.RemoveElement(gauss);
  means_invcovars_.RemoveRow(gauss);
  inv_covars_.erase(inv_covars_.begin() + gauss);
  if (renorm_weights) {
    BaseFloat sum_weights = weights_.Sum();
    weights_.Scale(1.0/sum_weights);
    valid_gconsts_ = false;
  }
}

RemoveComponents()

void RemoveComponents	(	const std::vector< int32 > &	gauss,
		bool	renorm_weights
	)

Removes multiple components from model; "gauss" must not have dups.

Definition at line 745 of file full-gmm.cc.

References rnnlm::i, kaldi::IsSortedAndUniq(), rnnlm::j, KALDI_ASSERT, and FullGmm::RemoveComponent().

Referenced by FullGmm::inv_covars(), and kaldi::MleFullGmmUpdate().

                                                                                 {
  vector<int32> gauss(gauss_in);
  std::sort(gauss.begin(), gauss.end());
  KALDI_ASSERT(IsSortedAndUniq(gauss));
  // If efficiency is later an issue, will code this specially (unlikely,
  // except for quite large GMMs).
  for (size_t i = 0; i < gauss.size(); i++) {
    RemoveComponent(gauss[i], renorm_weights);
    for (size_t j = i + 1; j < gauss.size(); j++)
      gauss[j]--;
  }
}

Resize()

void Resize	(	int32	nMix,
		int32	dim
	)

Resizes arrays to this dim. Does not initialize data.

Definition at line 41 of file full-gmm.cc.

References FullGmm::gconsts_, KALDI_ASSERT, FullGmm::means_invcovars_, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Matrix< Real >::Resize(), FullGmm::ResizeInvCovars(), and FullGmm::weights_.

Referenced by Sgmm2Project::ApplyProjection(), FullGmm::CopyFromDiagGmm(), FullGmm::CopyFromFullGmm(), FullGmm::FullGmm(), kaldi::unittest::InitRandFullGmm(), kaldi::MergeFullGmm(), TestComponentAcc(), UnitTestEstimateFullGmm(), and UnitTestFullGmm().

                                          {
  KALDI_ASSERT(nmix > 0 && dim > 0);
  if (gconsts_.Dim() != nmix) gconsts_.Resize(nmix);
  if (weights_.Dim() != nmix) weights_.Resize(nmix);
  if (means_invcovars_.NumRows() != nmix
      || means_invcovars_.NumCols() != dim)
    means_invcovars_.Resize(nmix, dim);
  ResizeInvCovars(nmix, dim);
}

ResizeInvCovars()

void ResizeInvCovars ( int32  nMix, int32  dim  )

private

Resizes arrays to this dim. Does not initialize data.

Definition at line 51 of file full-gmm.cc.

References rnnlm::i, FullGmm::inv_covars_, and KALDI_ASSERT.

Referenced by FullGmm::Read(), FullGmm::Resize(), and FullGmm::Split().

                                                   {
  KALDI_ASSERT(nmix > 0 && dim > 0);
  if (inv_covars_.size() != static_cast<size_t>(nmix))
    inv_covars_.resize(nmix);
  for (int32 i = 0; i < nmix; i++) {
    if (inv_covars_[i].NumRows() != dim) {
      inv_covars_[i].Resize(dim);
      inv_covars_[i].SetUnit();
      // must be initialized to unit for case of calling SetMeans while having
      // covars/invcovars that are not set yet (i.e. zero)
    }
  }
}

SetInvCovars()

void SetInvCovars

(

const std::vector< SpMatrix< Real > > &

v

)

Set the (inverse) covariances and recompute means_invcovars_.

Definition at line 83 of file full-gmm-inl.h.

References VectorBase< Real >::AddSpVec(), SpMatrix< Real >::CopyFromSp(), VectorBase< Real >::CopyFromVec(), FullGmm::Dim(), rnnlm::i, FullGmm::inv_covars_, SpMatrix< Real >::InvertDouble(), KALDI_ASSERT, FullGmm::means_invcovars_, FullGmm::NumGauss(), MatrixBase< Real >::Row(), and FullGmm::valid_gconsts_.

Referenced by FullGmm::inv_covars(), test_flags_driven_update(), and UnitTestFullGmm().

                                                              {
  KALDI_ASSERT(inv_covars_.size() == v.size());
  size_t num_comp = NumGauss();

  Vector<Real> orig_mean_times_invvar(Dim());
  Vector<Real> orig_mean(Dim());
  Vector<Real> new_mean_times_invvar(Dim());
  SpMatrix<Real> covar(Dim());

  for (size_t i = 0; i < num_comp; i++) {
    orig_mean_times_invvar.CopyFromVec(means_invcovars_.Row(i));
    covar.CopyFromSp(inv_covars_[i]);
    covar.InvertDouble();
    orig_mean.AddSpVec(1.0, covar, orig_mean_times_invvar, 0.0);
    new_mean_times_invvar.AddSpVec(1.0, v[i], orig_mean, 0.0);
    // v[i] is already inverted covar
    means_invcovars_.Row(i).CopyFromVec(new_mean_times_invvar);
    inv_covars_[i].CopyFromSp(v[i]);
  }
  valid_gconsts_ = false;
}

SetInvCovarsAndMeans()

void SetInvCovarsAndMeans	(	const std::vector< SpMatrix< Real > > &	invcovars,
		const Matrix< Real > &	means
	)

Use SetInvCovarsAndMeans if updating both means and (inverse) covariances.

Definition at line 50 of file full-gmm-inl.h.

References VectorBase< Real >::AddSpVec(), FullGmm::Dim(), rnnlm::i, FullGmm::inv_covars_, KALDI_ASSERT, FullGmm::means_invcovars_, MatrixBase< Real >::NumCols(), FullGmm::NumGauss(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::Row(), and FullGmm::valid_gconsts_.

Referenced by kaldi::unittest::InitRandFullGmm(), FullGmm::inv_covars(), main(), UnitTestEstimateFullGmm(), and UnitTestFullGmm().

                                                                            {
  KALDI_ASSERT(means_invcovars_.NumRows() == means.NumRows()
    && means_invcovars_.NumCols() == means.NumCols()
    && inv_covars_.size() == invcovars.size());

  size_t num_comp = NumGauss();
  for (size_t i = 0; i < num_comp; i++) {
    inv_covars_[i].CopyFromSp(invcovars[i]);
    Vector<Real> mean_times_inv(Dim());
    mean_times_inv.AddSpVec(1.0, invcovars[i], means.Row(i), 0.0);
    means_invcovars_.Row(i).CopyFromVec(mean_times_inv);
  }
  valid_gconsts_ = false;
}

SetInvCovarsAndMeansInvCovars()

void SetInvCovarsAndMeansInvCovars	(	const std::vector< SpMatrix< Real > > &	invcovars,
		const Matrix< Real > &	means_invcovars
	)

Use this if setting both, in the class's native format.

Definition at line 67 of file full-gmm-inl.h.

References MatrixBase< Real >::CopyFromMat(), rnnlm::i, FullGmm::inv_covars_, KALDI_ASSERT, FullGmm::means_invcovars_, MatrixBase< Real >::NumCols(), FullGmm::NumGauss(), MatrixBase< Real >::NumRows(), and FullGmm::valid_gconsts_.

Referenced by FullGmm::inv_covars(), and kaldi::MergeFullGmm().

                                         {
  KALDI_ASSERT(means_invcovars_.NumRows() == means_invcovars.NumRows()
               && means_invcovars_.NumCols() == means_invcovars.NumCols()
               && inv_covars_.size() == invcovars.size());

  size_t num_comp = NumGauss();
  for (size_t i = 0; i < num_comp; i++) {
    inv_covars_[i].CopyFromSp(invcovars[i]);
  }
  means_invcovars_.CopyFromMat(means_invcovars);
  valid_gconsts_ = false;
}

SetMeans()

void SetMeans

(

const Matrix< Real > &

m

)

Use SetMeans to update only the Gaussian means (and not variances)

Definition at line 38 of file full-gmm-inl.h.

References rnnlm::i, FullGmm::inv_covars_, KALDI_ASSERT, FullGmm::means_invcovars_, MatrixBase< Real >::NumCols(), FullGmm::NumGauss(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::Row(), and FullGmm::valid_gconsts_.

Referenced by FullGmm::inv_covars(), test_flags_driven_update(), and UnitTestFullGmm().

                                            {
  KALDI_ASSERT(means_invcovars_.NumRows() == m.NumRows()
    && means_invcovars_.NumCols() == m.NumCols());
  size_t num_comp = NumGauss();
  Matrix<BaseFloat> m_bf(m);
  for (size_t i = 0; i < num_comp; i++) {
    means_invcovars_.Row(i).AddSpVec(1.0, inv_covars_[i], m_bf.Row(i), 0.0);
  }
  valid_gconsts_ = false;
}

SetWeights()

void SetWeights

(

const Vector< Real > &

w

)

Mutators for both float or double.

Set mixure weights

Definition at line 31 of file full-gmm-inl.h.

References VectorBase< Real >::Dim(), KALDI_ASSERT, FullGmm::valid_gconsts_, and FullGmm::weights_.

Referenced by kaldi::unittest::InitRandFullGmm(), FullGmm::inv_covars(), main(), kaldi::MergeFullGmm(), test_flags_driven_update(), UnitTestEstimateFullGmm(), and UnitTestFullGmm().

                                              {
  KALDI_ASSERT(weights_.Dim() == w.Dim());
  weights_.CopyFromVec(w);
  valid_gconsts_ = false;
}

Split()

void Split	(	int32	target_components,
		float	perturb_factor,
		std::vector< int32 > *	history = NULL
	)

Merge the components and remember the order in which the components were merged (flat list of pairs)

Definition at line 132 of file full-gmm.cc.

References TpMatrix< Real >::Cholesky(), FullGmm::ComputeGconsts(), FullGmm::CopyFromFullGmm(), FullGmm::Dim(), FullGmm::FullGmm(), FullGmm::gconsts_, rnnlm::i, FullGmm::inv_covars_, KALDI_WARN, kaldi::kTrans, FullGmm::means_invcovars_, VectorBase< Real >::MulTp(), FullGmm::NumGauss(), MatrixBase< Real >::Range(), Matrix< Real >::Resize(), FullGmm::ResizeInvCovars(), MatrixBase< Real >::Row(), VectorBase< Real >::SetRandn(), and FullGmm::weights_.

Referenced by FullGmm::Dim(), main(), UnitTestEstimateFullGmm(), and UnitTestFullGmm().

                                            {
  if (target_components <= NumGauss() || NumGauss() == 0) {
    KALDI_WARN << "Cannot split from " << NumGauss() <<  " to "
               << target_components << " components";
    return;
  }
  int32 current_components = NumGauss(), dim = Dim();
  FullGmm *tmp = new FullGmm();
  tmp->CopyFromFullGmm(*this);  // so we have copies of matrices...
  // First do the resize:
  weights_.Resize(target_components);
  weights_.Range(0, current_components).CopyFromVec(tmp->weights_);
  means_invcovars_.Resize(target_components, dim);
  means_invcovars_.Range(0, current_components, 0,
      dim).CopyFromMat(tmp->means_invcovars_);
  ResizeInvCovars(target_components, dim);
  for (int32 mix = 0; mix < current_components; mix++) {
    inv_covars_[mix].CopyFromSp(tmp->inv_covars_[mix]);
  }
  for (int32 mix = current_components; mix < target_components; mix++) {
    inv_covars_[mix].SetZero();
  }
  gconsts_.Resize(target_components);

  delete tmp;

  // future work(arnab): Use a priority queue instead?
  while (current_components < target_components) {
    BaseFloat max_weight = weights_(0);
    int32 max_idx = 0;
    for (int32 i = 1; i < current_components; i++) {
      if (weights_(i) > max_weight) {
        max_weight = weights_(i);
        max_idx = i;
      }
    }

    // remember history
    if (history != NULL)
      history->push_back(max_idx);

    weights_(max_idx) /= 2;
    weights_(current_components) = weights_(max_idx);
    Vector<BaseFloat> rand_vec(dim);
    rand_vec.SetRandn();
    TpMatrix<BaseFloat> invcovar_l(dim);
    invcovar_l.Cholesky(inv_covars_[max_idx]);
    rand_vec.MulTp(invcovar_l, kTrans);
    inv_covars_[current_components].CopyFromSp(inv_covars_[max_idx]);
    means_invcovars_.Row(current_components).CopyFromVec(means_invcovars_.Row(
        max_idx));
    means_invcovars_.Row(current_components).AddVec(perturb_factor, rand_vec);
    means_invcovars_.Row(max_idx).AddVec(-perturb_factor, rand_vec);
    current_components++;
  }
  ComputeGconsts();
}

weights()

const Vector<BaseFloat>& weights ( ) const

inline

Definition at line 144 of file full-gmm.h.

References FullGmm::weights_.

Referenced by kaldi::ComputeFeatureNormalizingTransform(), DiagGmm::CopyFromFullGmm(), GetLogLikeTest(), IvectorExtractor::IvectorExtractor(), FullGmm::Merge(), kaldi::MergeFullGmm(), test_flags_driven_update(), UnitTestEstimateFullGmm(), and UnitTestFullGmm().

{ return weights_; }

Write()

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

Definition at line 758 of file full-gmm.cc.

References FullGmm::gconsts_, rnnlm::i, FullGmm::inv_covars_, KALDI_ERR, FullGmm::means_invcovars_, FullGmm::NumGauss(), FullGmm::valid_gconsts_, FullGmm::weights_, MatrixBase< Real >::Write(), and kaldi::WriteToken().

Referenced by FullGmm::Dim(), main(), kaldi::operator<<(), and UnitTestFullGmm().

                                                             {
  if (!valid_gconsts_)
    KALDI_ERR << "Must call ComputeGconsts() before writing the model.";
  WriteToken(out_stream, binary, "<FullGMM>");
  if (!binary) out_stream << "\n";
  WriteToken(out_stream, binary, "<GCONSTS>");
  gconsts_.Write(out_stream, binary);
  WriteToken(out_stream, binary, "<WEIGHTS>");
  weights_.Write(out_stream, binary);
  WriteToken(out_stream, binary, "<MEANS_INVCOVARS>");
  means_invcovars_.Write(out_stream, binary);
  WriteToken(out_stream, binary, "<INV_COVARS>");
  for (int32 i = 0; i < NumGauss(); i++) {
    inv_covars_[i].Write(out_stream, binary);
  }
  WriteToken(out_stream, binary, "</FullGMM>");
  if (!binary) out_stream << "\n";
}

Friends And Related Function Documentation

FullGmmNormal

friend class FullGmmNormal

friend

this makes it a little easier to modify the internals

Definition at line 42 of file full-gmm.h.

Member Data Documentation

gconsts_

Vector<BaseFloat> gconsts_

private

Equals log(weight) - 0.5 * (log det(var) + mean'*inv(var)*mean)

Definition at line 199 of file full-gmm.h.

Referenced by FullGmm::ComponentLogLikelihood(), FullGmm::ComputeGconsts(), FullGmm::CopyFromDiagGmm(), FullGmm::CopyFromFullGmm(), FullGmm::gconsts(), FullGmm::LogLikelihoods(), FullGmm::LogLikelihoodsPreselect(), FullGmm::Merge(), FullGmm::MergePreselect(), FullGmm::Read(), FullGmm::RemoveComponent(), FullGmm::Resize(), FullGmm::Split(), and FullGmm::Write().

inv_covars_

std::vector<SpMatrix<BaseFloat> > inv_covars_

private

Inverse covariances.

Definition at line 202 of file full-gmm.h.

Referenced by FullGmm::ComponentLogLikelihood(), FullGmm::ComputeGconsts(), FullGmm::CopyFromDiagGmm(), FullGmmNormal::CopyFromFullGmm(), FullGmm::CopyFromFullGmm(), FullGmmNormal::CopyToFullGmm(), FullGmm::GetComponentMean(), FullGmm::GetCovars(), FullGmm::GetCovarsAndMeans(), FullGmm::GetMeans(), FullGmm::inv_covars(), FullGmm::LogLikelihoods(), FullGmm::LogLikelihoodsPreselect(), FullGmm::Merge(), FullGmm::MergePreselect(), FullGmm::Perturb(), FullGmm::Read(), FullGmm::RemoveComponent(), FullGmm::ResizeInvCovars(), FullGmm::SetInvCovars(), FullGmm::SetInvCovarsAndMeans(), FullGmm::SetInvCovarsAndMeansInvCovars(), FullGmm::SetMeans(), FullGmm::Split(), and FullGmm::Write().

means_invcovars_

Matrix<BaseFloat> means_invcovars_

private

Means times inverse covariances.

Definition at line 203 of file full-gmm.h.

Referenced by FullGmm::ComponentLogLikelihood(), FullGmm::ComputeGconsts(), FullGmm::CopyFromDiagGmm(), FullGmmNormal::CopyFromFullGmm(), FullGmm::CopyFromFullGmm(), FullGmmNormal::CopyToFullGmm(), FullGmm::Dim(), FullGmm::GetComponentMean(), FullGmm::GetCovarsAndMeans(), FullGmm::GetMeans(), FullGmm::LogLikelihoods(), FullGmm::LogLikelihoodsPreselect(), FullGmm::means_invcovars(), FullGmm::Merge(), FullGmm::MergePreselect(), FullGmm::Perturb(), FullGmm::Read(), FullGmm::RemoveComponent(), FullGmm::Resize(), FullGmm::SetInvCovars(), FullGmm::SetInvCovarsAndMeans(), FullGmm::SetInvCovarsAndMeansInvCovars(), FullGmm::SetMeans(), FullGmm::Split(), and FullGmm::Write().

valid_gconsts_

bool valid_gconsts_

private

Recompute gconsts_ if false.

Definition at line 200 of file full-gmm.h.

Referenced by FullGmm::ComponentLogLikelihood(), FullGmm::ComputeGconsts(), FullGmm::CopyFromFullGmm(), FullGmmNormal::CopyToFullGmm(), FullGmm::MergePreselect(), FullGmm::RemoveComponent(), FullGmm::SetInvCovars(), FullGmm::SetInvCovarsAndMeans(), FullGmm::SetInvCovarsAndMeansInvCovars(), FullGmm::SetMeans(), FullGmm::SetWeights(), and FullGmm::Write().

weights_

Vector<BaseFloat> weights_

private

weights (not log).

Definition at line 201 of file full-gmm.h.

Referenced by FullGmm::ComputeGconsts(), FullGmm::CopyFromDiagGmm(), FullGmmNormal::CopyFromFullGmm(), FullGmm::CopyFromFullGmm(), FullGmmNormal::CopyToFullGmm(), FullGmm::Merge(), FullGmm::MergePreselect(), FullGmm::NumGauss(), FullGmm::Read(), FullGmm::RemoveComponent(), FullGmm::Resize(), FullGmm::SetWeights(), FullGmm::Split(), FullGmm::weights(), and FullGmm::Write().

---

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

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