#include <decodable-am-diag-gmm-regtree.h>

Inheritance diagram for DecodableAmDiagGmmRegtreeMllr:

Collaboration diagram for DecodableAmDiagGmmRegtreeMllr:

[legend]

Public Member Functions
	DecodableAmDiagGmmRegtreeMllr (const AmDiagGmm &am, const TransitionModel &tm, const Matrix< BaseFloat > &feats, const RegtreeMllrDiagGmm &mllr_xform, const RegressionTree &regtree, BaseFloat scale, BaseFloat log_sum_exp_prune=-1.0)

	~DecodableAmDiagGmmRegtreeMllr ()

virtual BaseFloat	LogLikelihood (int32 frame, int32 tid)
	Returns the log likelihood, which will be negated in the decoder. More...

virtual int32	NumFramesReady () const
	The call NumFramesReady() will return the number of frames currently available for this decodable object. More...

virtual int32	NumIndices () const
	Returns the number of states in the acoustic model (they will be indexed one-based, i.e. More...

const TransitionModel *	TransModel ()

Public Member Functions inherited from DecodableAmDiagGmmUnmapped
	DecodableAmDiagGmmUnmapped (const AmDiagGmm &am, const Matrix< BaseFloat > &feats, BaseFloat log_sum_exp_prune=-1.0)
	If you set log_sum_exp_prune to a value greater than 0 it will prune in the LogSumExp operation (larger = more exact); I suggest 5. More...

virtual bool	IsLastFrame (int32 frame) const
	Returns true if this is the last frame. More...

Public Member Functions inherited from DecodableInterface
virtual	~DecodableInterface ()

Protected Member Functions
virtual BaseFloat	LogLikelihoodZeroBased (int32 frame, int32 state_index)

Protected Member Functions inherited from DecodableAmDiagGmmUnmapped
void	ResetLogLikeCache ()

Private Member Functions
void	InitCache ()
	Initializes the mean & gconst caches. More...

const Matrix< BaseFloat > &	GetXformedMeanInvVars (int32 state_index)
	Get the transformed means times inverse variances for a given pdf, and cache them. More...

const Vector< BaseFloat > &	GetXformedGconsts (int32 state_index)
	Get the cached (while computing transformed means) gconsts for likelihood calculation. More...

	KALDI_DISALLOW_COPY_AND_ASSIGN (DecodableAmDiagGmmRegtreeMllr)

Private Attributes
const TransitionModel &	trans_model_

BaseFloat	scale_

const RegtreeMllrDiagGmm &	mllr_xform_

const RegressionTree &	regtree_

std::vector< Matrix< BaseFloat > *>	xformed_mean_invvars_
	Cache of transformed means time inverse variances for each state. More...

std::vector< Vector< BaseFloat > *>	xformed_gconsts_
	Cache of transformed gconsts for each state. More...

std::vector< bool >	is_cached_
	Boolean variable per state to indicate whether the transformed means for that state are cached. More...

Vector< BaseFloat >	data_squared_
	Cached for fast likelihood calculation. More...

Additional Inherited Members
Protected Attributes inherited from DecodableAmDiagGmmUnmapped
const AmDiagGmm &	acoustic_model_

const Matrix< BaseFloat > &	feature_matrix_

int32	previous_frame_

BaseFloat	log_sum_exp_prune_

std::vector< LikelihoodCacheRecord >	log_like_cache_

Detailed Description

Definition at line 80 of file decodable-am-diag-gmm-regtree.h.

Constructor & Destructor Documentation

◆ DecodableAmDiagGmmRegtreeMllr()

DecodableAmDiagGmmRegtreeMllr	(	const AmDiagGmm &	am,
		const TransitionModel &	tm,
		const Matrix< BaseFloat > &	feats,
		const RegtreeMllrDiagGmm &	mllr_xform,
		const RegressionTree &	regtree,
		BaseFloat	scale,
		BaseFloat	log_sum_exp_prune = `-1.0`
	)

inline

Definition at line 82 of file decodable-am-diag-gmm-regtree.h.

                                                                    :
       DecodableAmDiagGmmUnmapped(am, feats, log_sum_exp_prune),
       trans_model_(tm), scale_(scale), mllr_xform_(mllr_xform),
       regtree_(regtree), data_squared_(feats.NumCols()) { InitCache(); }

◆ ~DecodableAmDiagGmmRegtreeMllr()

~DecodableAmDiagGmmRegtreeMllr ( )

Definition at line 91 of file decodable-am-diag-gmm-regtree.cc.

References kaldi::DeletePointers().

                                                               {
   DeletePointers(&xformed_mean_invvars_);
   DeletePointers(&xformed_gconsts_);
 }

Member Function Documentation

◆ GetXformedGconsts()

const Vector< BaseFloat > & GetXformedGconsts ( int32 state_index )

private

Get the cached (while computing transformed means) gconsts for likelihood calculation.

The 'state_index' is 0-based.

Definition at line 180 of file decodable-am-diag-gmm-regtree.cc.

References KALDI_ASSERT, and KALDI_ERR.

                  {
   if (!is_cached_[state]) {
     KALDI_ERR << "GConsts not cached for state: " << state << ". Must call "
               << "GetXformedMeanInvVars() first.";
   }
   KALDI_ASSERT(xformed_gconsts_[state] != NULL);
   return *xformed_gconsts_[state];
 }

◆ GetXformedMeanInvVars()

const Matrix< BaseFloat > & GetXformedMeanInvVars ( int32 state_index )

private

Get the transformed means times inverse variances for a given pdf, and cache them.

The 'state_index' is 0-based.

Definition at line 151 of file decodable-am-diag-gmm-regtree.cc.

References DecodableAmDiagGmmUnmapped::acoustic_model_, kaldi::ComputeGconsts(), AmDiagGmm::Dim(), AmDiagGmm::GetPdf(), DiagGmm::inv_vars(), KALDI_ASSERT, KALDI_VLOG, DiagGmm::NumGauss(), DecodableAmDiagGmmRegtreeFmllr::regtree_, and DiagGmm::weights().

                  {
   if (is_cached_[state]) {  // found in cache
     KALDI_ASSERT(xformed_mean_invvars_[state] != NULL);
     KALDI_VLOG(3) << "For PDF index " << state << ": transformed means "
                   << "found in cache.";
     return *xformed_mean_invvars_[state];
   } else {  // transform the means and cache them
     KALDI_ASSERT(xformed_mean_invvars_[state] == NULL);
     KALDI_VLOG(3) << "For PDF index " << state << ": transforming means.";
     int32 num_gauss = acoustic_model_.GetPdf(state).NumGauss(),
         dim = acoustic_model_.Dim();
     const Vector<BaseFloat> &weights = acoustic_model_.GetPdf(state).weights();
     const Matrix<BaseFloat> &invvars = acoustic_model_.GetPdf(state).inv_vars();
     xformed_mean_invvars_[state] = new Matrix<BaseFloat>(num_gauss, dim);
     mllr_xform_.GetTransformedMeans(regtree_, acoustic_model_, state,
                                     xformed_mean_invvars_[state]);
     xformed_gconsts_[state] = new Vector<BaseFloat>(num_gauss);
     // At this point, the transformed means haven't been multiplied with
     // the inv vars, and they are used to compute gconsts first.
     ComputeGconsts(weights, *xformed_mean_invvars_[state], invvars,
                    xformed_gconsts_[state]);
     // Finally, multiply the transformed means with the inv vars.
     xformed_mean_invvars_[state]->MulElements(invvars);
     is_cached_[state] = true;
     return *xformed_mean_invvars_[state];
   }
 }

◆ InitCache()

void InitCache ( )

private

Initializes the mean & gconst caches.

Definition at line 97 of file decodable-am-diag-gmm-regtree.cc.

References DecodableAmDiagGmmUnmapped::acoustic_model_, kaldi::DeletePointers(), AmDiagGmm::NumPdfs(), and DecodableAmDiagGmmUnmapped::ResetLogLikeCache().

                                               {
   if (xformed_mean_invvars_.size() != 0)
     DeletePointers(&xformed_mean_invvars_);
   if (xformed_gconsts_.size() != 0)
     DeletePointers(&xformed_gconsts_);
   int32 num_pdfs = acoustic_model_.NumPdfs();
   xformed_mean_invvars_.resize(num_pdfs);
   xformed_gconsts_.resize(num_pdfs);
   is_cached_.resize(num_pdfs, false);
   ResetLogLikeCache();
 }

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( DecodableAmDiagGmmRegtreeMllr )

private

◆ LogLikelihood()

virtual BaseFloat LogLikelihood	(	int32	frame,
		int32	index
	)

inlinevirtual

Returns the log likelihood, which will be negated in the decoder.

The "frame" starts from zero. You should verify that NumFramesReady() > frame before calling this.

Reimplemented from DecodableAmDiagGmmUnmapped.

Definition at line 95 of file decodable-am-diag-gmm-regtree.h.

References DecodableAmDiagGmmRegtreeFmllr::LogLikelihoodZeroBased(), DecodableAmDiagGmmRegtreeFmllr::scale_, DecodableAmDiagGmmRegtreeFmllr::trans_model_, and TransitionModel::TransitionIdToPdfFast().

                                                           {
     return scale_*LogLikelihoodZeroBased(frame,
                                          trans_model_.TransitionIdToPdfFast(tid));
   }

◆ LogLikelihoodZeroBased()

BaseFloat LogLikelihoodZeroBased	(	int32	frame,
		int32	state_index
	)

protectedvirtual

Reimplemented from DecodableAmDiagGmmUnmapped.

Definition at line 190 of file decodable-am-diag-gmm-regtree.cc.

References DecodableAmDiagGmmUnmapped::acoustic_model_, VectorBase< Real >::AddMatVec(), DecodableAmDiagGmmUnmapped::data_squared_, VectorBase< Real >::Dim(), DiagGmm::Dim(), DecodableAmDiagGmmUnmapped::feature_matrix_, AmDiagGmm::GetPdf(), DiagGmm::inv_vars(), KALDI_ASSERT, KALDI_ERR, KALDI_ISINF, KALDI_ISNAN, kaldi::kNoTrans, DecodableAmDiagGmmUnmapped::log_like_cache_, DecodableAmDiagGmmUnmapped::log_sum_exp_prune_, VectorBase< Real >::LogSumExp(), DecodableAmDiagGmmRegtreeFmllr::NumFramesReady(), DecodableAmDiagGmmRegtreeFmllr::NumIndices(), DecodableAmDiagGmmUnmapped::previous_frame_, and MatrixBase< Real >::Row().

                                                                              {
 //  KALDI_ERR << "Function not completely implemented yet.";
   KALDI_ASSERT(frame < NumFramesReady() && frame >= 0);
   KALDI_ASSERT(state < NumIndices() && state >= 0);
 
   if (log_like_cache_[state].hit_time == frame) {
     return log_like_cache_[state].log_like;  // return cached value, if found
   }
 
   const DiagGmm &pdf = acoustic_model_.GetPdf(state);
   const VectorBase<BaseFloat> &data = feature_matrix_.Row(frame);
 
   // check if everything is in order
   if (pdf.Dim() != data.Dim()) {
     KALDI_ERR << "Dim mismatch: data dim = "  << data.Dim()
         << " vs. model dim = " << pdf.Dim();
   }
 
   if (frame != previous_frame_) {  // cache the squared stats.
     data_squared_.CopyFromVec(feature_matrix_.Row(frame));
     data_squared_.ApplyPow(2.0);
     previous_frame_ = frame;
   }
 
   const Matrix<BaseFloat> &means_invvars = GetXformedMeanInvVars(state);
   const Vector<BaseFloat> &gconsts = GetXformedGconsts(state);
 
   Vector<BaseFloat> loglikes(gconsts);  // need to recreate for each pdf
   // loglikes +=  means * inv(vars) * data.
   loglikes.AddMatVec(1.0, means_invvars, kNoTrans, data, 1.0);
   // loglikes += -0.5 * inv(vars) * data_sq.
   loglikes.AddMatVec(-0.5, pdf.inv_vars(), kNoTrans, data_squared_, 1.0);
 
   BaseFloat log_sum = loglikes.LogSumExp(log_sum_exp_prune_);
   if (KALDI_ISNAN(log_sum) || KALDI_ISINF(log_sum))
     KALDI_ERR << "Invalid answer (overflow or invalid variances/features?)";
 
   log_like_cache_[state].log_like = log_sum;
   log_like_cache_[state].hit_time = frame;
 
   return log_sum;
 }

◆ NumFramesReady()

virtual int32 NumFramesReady ( ) const

inlinevirtual

The call NumFramesReady() will return the number of frames currently available for this decodable object.

This is for use in setups where you don't want the decoder to block while waiting for input. This is newly added as of Jan 2014, and I hope, going forward, to rely on this mechanism more than IsLastFrame to know when to stop decoding.

Reimplemented from DecodableAmDiagGmmUnmapped.

Definition at line 100 of file decodable-am-diag-gmm-regtree.h.

References DecodableAmDiagGmmUnmapped::feature_matrix_, and MatrixBase< Real >::NumRows().

Referenced by main().

100 { return feature_matrix_.NumRows(); }

kaldi::DecodableAmDiagGmmUnmapped::feature_matrix_

const Matrix< BaseFloat > & feature_matrix_

Definition: decodable-am-diag-gmm.h:80

kaldi::MatrixBase::NumRows

MatrixIndexT NumRows() const

Returns number of rows (or zero for empty matrix).

Definition: kaldi-matrix.h:64