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

Inheritance diagram for DecodableAmDiagGmmRegtreeFmllr:

Collaboration diagram for DecodableAmDiagGmmRegtreeFmllr:

[legend]

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

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...

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)

const TransitionModel *	TransModel ()

Protected Member Functions inherited from DecodableAmDiagGmmUnmapped
void	ResetLogLikeCache ()

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (DecodableAmDiagGmmRegtreeFmllr)

Private Attributes
const TransitionModel &	trans_model_

BaseFloat	scale_

const RegtreeFmllrDiagGmm &	fmllr_xform_

const RegressionTree &	regtree_

std::vector< Vector< BaseFloat > >	xformed_data_

std::vector< Vector< BaseFloat > >	xformed_data_squared_

Vector< BaseFloat >	logdets_

bool	valid_logdets_

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 38 of file decodable-am-diag-gmm-regtree.h.

Constructor & Destructor Documentation

◆ DecodableAmDiagGmmRegtreeFmllr()

DecodableAmDiagGmmRegtreeFmllr	(	const AmDiagGmm &	am,
		const TransitionModel &	tm,
		const Matrix< BaseFloat > &	feats,
		const RegtreeFmllrDiagGmm &	fmllr_xform,
		const RegressionTree &	regtree,
		BaseFloat	scale,
		BaseFloat	log_sum_exp_prune = `-1.0`
	)

inline

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

     : DecodableAmDiagGmmUnmapped(am, feats, log_sum_exp_prune), trans_model_(tm),
       scale_(scale), fmllr_xform_(fmllr_xform), regtree_(regtree),
       valid_logdets_(false) {}

Member Function Documentation

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( DecodableAmDiagGmmRegtreeFmllr )

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 52 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 29 of file decodable-am-diag-gmm-regtree.cc.

Referenced by DecodableAmDiagGmmRegtreeFmllr::LogLikelihood(), DecodableAmDiagGmmRegtreeMllr::LogLikelihood(), DecodableAmDiagGmmRegtreeFmllr::NumIndices(), and DecodableAmDiagGmmRegtreeMllr::TransModel().

                                                                        {
   KALDI_ASSERT(frame < NumFramesReady() && frame >= 0);
   KALDI_ASSERT(state < NumIndices() && state >= 0);
 
   if (!valid_logdets_) {
     logdets_.Resize(fmllr_xform_.NumRegClasses());
     fmllr_xform_.GetLogDets(&logdets_);
     valid_logdets_ = true;
   }
 
   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 (!pdf.valid_gconsts()) {
     KALDI_ERR << "State "  << (state)  << ": Must call ComputeGconsts() "
         "before computing likelihood.";
   }
 
   if (frame != previous_frame_) {  // cache the transformed & squared stats.
     fmllr_xform_.TransformFeature(data, &xformed_data_);
     xformed_data_squared_ = xformed_data_;
     vector< Vector <BaseFloat> >::iterator it = xformed_data_squared_.begin(),
         end = xformed_data_squared_.end();
     for (; it != end; ++it) { it->ApplyPow(2.0); }
     previous_frame_ = frame;
   }
 
   Vector<BaseFloat> loglikes(pdf.gconsts());  // need to recreate for each pdf
   int32 baseclass, regclass;
   for (int32 comp_id = 0, num_comp = pdf.NumGauss(); comp_id < num_comp;
       ++comp_id) {
     baseclass = regtree_.Gauss2BaseclassId(state, comp_id);
     regclass = fmllr_xform_.Base2RegClass(baseclass);
     // loglikes +=  means * inv(vars) * data.
     loglikes(comp_id) += VecVec(pdf.means_invvars().Row(comp_id),
                                 xformed_data_[regclass]);
     // loglikes += -0.5 * inv(vars) * data_sq.
     loglikes(comp_id) -= 0.5 * VecVec(pdf.inv_vars().Row(comp_id),
                                       xformed_data_squared_[regclass]);
     loglikes(comp_id) += logdets_(regclass);
   }
 
   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 57 of file decodable-am-diag-gmm-regtree.h.

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

Referenced by DecodableAmDiagGmmRegtreeFmllr::LogLikelihoodZeroBased(), DecodableAmDiagGmmRegtreeMllr::LogLikelihoodZeroBased(), and main().

57 { 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