#include <fmpe.h>

Collaboration diagram for Fmpe:

[legend]

Public Member Functions
	Fmpe ()

	Fmpe (const DiagGmm &gmm, const FmpeOptions &config)

int32	FeatDim () const

int32	NumGauss () const

int32	NumContexts () const

int32	ProjectionTNumRows () const

int32	ProjectionTNumCols () const

void	ComputeFeatures (const MatrixBase< BaseFloat > &feat_in, const std::vector< std::vector< int32 > > &gselect, Matrix< BaseFloat > *feat_out) const

void	AccStats (const MatrixBase< BaseFloat > &feat_in, const std::vector< std::vector< int32 > > &gselect, const MatrixBase< BaseFloat > &direct_feat_deriv, const MatrixBase< BaseFloat > indirect_feat_deriv, FmpeStats stats) const

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

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

BaseFloat	Update (const FmpeUpdateOptions &config, const FmpeStats &stats)

Private Member Functions
void	SetContexts (std::string context_str)

void	ComputeC ()

void	ComputeStddevs ()

void	ApplyProjection (const MatrixBase< BaseFloat > &feat_in, const std::vector< std::vector< int32 > > &gselect, MatrixBase< BaseFloat > *intermed_feat) const

void	ApplyProjectionReverse (const MatrixBase< BaseFloat > &feat_in, const std::vector< std::vector< int32 > > &gselect, const MatrixBase< BaseFloat > &intermed_feat_deriv, MatrixBase< BaseFloat > proj_deriv_plus, MatrixBase< BaseFloat > proj_deriv_minus) const

void	ApplyContext (const MatrixBase< BaseFloat > &intermed_feat, MatrixBase< BaseFloat > *feat_out) const

void	ApplyContextReverse (const MatrixBase< BaseFloat > &feat_deriv, MatrixBase< BaseFloat > *intermed_feat_deriv) const

void	ApplyC (MatrixBase< BaseFloat > *feat_out, bool reverse=false) const

void	ApplyCReverse (MatrixBase< BaseFloat > *deriv) const

Private Attributes
DiagGmm	gmm_

FmpeOptions	config_

Matrix< BaseFloat >	stddevs_

Matrix< BaseFloat >	projT_

TpMatrix< BaseFloat >	C_

std::vector< std::vector< std::pair< int32, BaseFloat > > >	contexts_

Detailed Description

Definition at line 138 of file fmpe.h.

Constructor & Destructor Documentation

◆ Fmpe() [1/2]

Fmpe ( )

inline

Definition at line 140 of file fmpe.h.

140 {}

◆ Fmpe() [2/2]

Fmpe	(	const DiagGmm &	gmm,
		const FmpeOptions &	config
	)

Definition at line 435 of file fmpe.cc.

References Fmpe::ComputeC(), Fmpe::ComputeStddevs(), FmpeOptions::context_expansion, Fmpe::FeatDim(), Fmpe::NumContexts(), Fmpe::NumGauss(), Fmpe::projT_, Matrix< Real >::Resize(), and Fmpe::SetContexts().

                                                        : gmm_(gmm),
                                                           config_(config) {
   SetContexts(config.context_expansion);
   ComputeC();
   ComputeStddevs();
   projT_.Resize(NumGauss() * (FeatDim()+1), FeatDim() * NumContexts());
 }

Member Function Documentation

◆ AccStats()

void AccStats	(	const MatrixBase< BaseFloat > &	feat_in,
		const std::vector< std::vector< int32 > > &	gselect,
		const MatrixBase< BaseFloat > &	direct_feat_deriv,
		const MatrixBase< BaseFloat > *	indirect_feat_deriv,
		FmpeStats *	stats
	)		const

Definition at line 395 of file fmpe.cc.

References FmpeStats::AccumulateChecks(), MatrixBase< Real >::AddMat(), Fmpe::ApplyContextReverse(), Fmpe::ApplyCReverse(), Fmpe::ApplyProjectionReverse(), FmpeStats::DerivMinus(), FmpeStats::DerivPlus(), Fmpe::FeatDim(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), Fmpe::NumContexts(), MatrixBase< Real >::NumRows(), Fmpe::projT_, and kaldi::SameDim().

Referenced by main(), and kaldi::TestFmpe().

                                                  {
   SubMatrix<BaseFloat> stats_plus(fmpe_stats->DerivPlus());
   SubMatrix<BaseFloat> stats_minus(fmpe_stats->DerivMinus());
   int32 dim = FeatDim(), ncontexts = NumContexts();
   KALDI_ASSERT(feat_in.NumRows() != 0 && feat_in.NumCols() == dim);
   KALDI_ASSERT(feat_in.NumRows() == static_cast<int32>(gselect.size()));
   KALDI_ASSERT(SameDim(stats_plus, projT_) && SameDim(stats_minus, projT_) &&
                SameDim(feat_in, direct_feat_deriv));
 
   if (indirect_feat_deriv != NULL)
     fmpe_stats->AccumulateChecks(feat_in, direct_feat_deriv, *indirect_feat_deriv);
   
   Matrix<BaseFloat> feat_deriv(direct_feat_deriv); // "feat_deriv" is initially direct+indirect.
   if (indirect_feat_deriv != NULL)
     feat_deriv.AddMat(1.0, *indirect_feat_deriv);
   
   // We do the "*Reverse" version of each stage now, in reverse order.
   ApplyCReverse(&feat_deriv);
   
   Matrix<BaseFloat> intermed_feat_deriv(feat_in.NumRows(), dim*ncontexts);
   ApplyContextReverse(feat_deriv, &intermed_feat_deriv);
   
   ApplyProjectionReverse(feat_in, gselect, intermed_feat_deriv,
                          &stats_plus, &stats_minus);
 }

◆ ApplyC()

void ApplyC	(	MatrixBase< BaseFloat > *	feat_out,
		bool	reverse = `false`
	)		const

private

Definition at line 161 of file fmpe.cc.

References Fmpe::C_, VectorBase< Real >::CopyFromVec(), kaldi::kNoTrans, kaldi::kTrans, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

Referenced by Fmpe::ComputeFeatures().

                                                                      {
   int32 T = feat_out->NumRows();
   Vector<BaseFloat> tmp(feat_out->NumCols());
   for (int32 t = 0; t < T; t++) {
     SubVector<BaseFloat> row(*feat_out, t);
     // Next line does: tmp = C_ * row
     tmp.AddTpVec(1.0, C_, (reverse ? kTrans : kNoTrans), row, 0.0);
     row.CopyFromVec(tmp);
   }
 }

◆ ApplyContext()

void ApplyContext	(	const MatrixBase< BaseFloat > &	intermed_feat,
		MatrixBase< BaseFloat > *	feat_out
	)		const

private

Definition at line 97 of file fmpe.cc.

References Fmpe::contexts_, Fmpe::FeatDim(), rnnlm::i, rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::NumCols(), Fmpe::NumContexts(), MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

Referenced by Fmpe::ComputeFeatures().

                                                                {
   // Applies the temporal-context part of the transformation.
   int32 dim = FeatDim(), ncontexts = NumContexts(),
       T = intermed_feat.NumRows();
   KALDI_ASSERT(intermed_feat.NumCols() == dim * ncontexts &&
                intermed_feat.NumRows() == feat_out->NumRows()
                && feat_out->NumCols() == dim);
   // note: ncontexts == contexts_.size().
   for (int32 i = 0; i < ncontexts; i++) {
     // this_intermed_feat is the chunk of the "intermediate features"
     // that corresponds to this "context"
     SubMatrix<BaseFloat> this_intermed_feat(intermed_feat, 0, T,
                                             dim*i, dim);
     for (int32 j = 0; j < static_cast<int32>(contexts_[i].size()); j++) {
       int32 t_offset = contexts_[i][j].first;
       BaseFloat weight = contexts_[i][j].second;
       // Note: we could do this more efficiently using matrix operations,
       // but this doesn't dominate the computation and I think this is
       // clearer.
       for (int32 t_out = 0; t_out < T; t_out++) { // t_out indexes the output
         int32 t_in = t_out + t_offset; // t_in indexes the input.
         if (t_in >= 0 && t_in < T) // Discard frames outside range.
           feat_out->Row(t_out).AddVec(weight, this_intermed_feat.Row(t_in));
       }
     }
   }
 }

◆ ApplyContextReverse()

void ApplyContextReverse	(	const MatrixBase< BaseFloat > &	feat_deriv,
		MatrixBase< BaseFloat > *	intermed_feat_deriv
	)		const

private

Definition at line 126 of file fmpe.cc.

References Fmpe::contexts_, Fmpe::FeatDim(), rnnlm::i, rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::NumCols(), Fmpe::NumContexts(), MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

Referenced by Fmpe::AccStats().

           {
   // Applies the temporal-context part of the transformation,
   // in reverse, for getting derivatives for training.
   int32 dim = FeatDim(), ncontexts = NumContexts(),
       T = feat_deriv.NumRows();
   KALDI_ASSERT(intermed_feat_deriv->NumCols() == dim * ncontexts &&
                intermed_feat_deriv->NumRows() == feat_deriv.NumRows()
                && feat_deriv.NumCols() == dim);
   // note: ncontexts == contexts_.size().
   for (int32 i = 0; i < ncontexts; i++) {
     // this_intermed_feat is the chunk of the derivative of
     // "intermediate features" that corresponds to this "context"
     // (this is output, in this routine).
     SubMatrix<BaseFloat> this_intermed_feat_deriv(*intermed_feat_deriv, 0, T,
                                                   dim*i, dim);
     for (int32 j = 0; j < static_cast<int32>(contexts_[i].size()); j++) {
       int32 t_offset = contexts_[i][j].first;
       BaseFloat weight = contexts_[i][j].second;
       // Note: we could do this more efficiently using matrix operations,
       // but this doesn't dominate the computation and I think this is
       // clearer.
       for (int32 t_out = 0; t_out < T; t_out++) { // t_out indexes the output
         int32 t_in = t_out + t_offset; // t_in indexes the input.
         if (t_in >= 0 && t_in < T) // Discard frames outside range.
           this_intermed_feat_deriv.Row(t_in).AddVec(weight,
                                                     feat_deriv.Row(t_out));
         // Note: the line above is where the work happens; it's the same
         // as in ApplyContext except reversing the input and output.
       }
     }
   }
 }

◆ ApplyCReverse()

void ApplyCReverse ( MatrixBase< BaseFloat > * deriv ) const

inlineprivate

Definition at line 218 of file fmpe.h.

Referenced by Fmpe::AccStats().

218 { ApplyC(deriv, true); }

kaldi::Fmpe::ApplyC

void ApplyC(MatrixBase< BaseFloat > *feat_out, bool reverse=false) const

Definition: fmpe.cc:161

◆ ApplyProjection()

void ApplyProjection	(	const MatrixBase< BaseFloat > &	feat_in,
		const std::vector< std::vector< int32 > > &	gselect,
		MatrixBase< BaseFloat > *	intermed_feat
	)		const

private

Definition at line 182 of file fmpe.cc.

References MatrixBase< Real >::AddMatMat(), VectorBase< Real >::AddMatVec(), VectorBase< Real >::AddVec(), VectorBase< Real >::ApplySoftMax(), Fmpe::config_, VectorBase< Real >::Dim(), Fmpe::FeatDim(), Fmpe::gmm_, rnnlm::i, rnnlm::j, kaldi::kNoTrans, kaldi::kTrans, DiagGmm::LogLikelihoodsPreselect(), DiagGmm::means_invvars(), Fmpe::NumContexts(), MatrixBase< Real >::NumRows(), FmpeOptions::post_scale, Fmpe::projT_, VectorBase< Real >::Range(), MatrixBase< Real >::Range(), MatrixBase< Real >::Row(), and Fmpe::stddevs_.

Referenced by Fmpe::ComputeFeatures().

                                                                        {
   int32 dim = FeatDim(), ncontexts = NumContexts();  
   
   Vector<BaseFloat> post; // will be posteriors of selected Gaussians.
   Vector<BaseFloat> input_chunk(dim+1); // will be a segment of
   // the high-dimensional features.
 
   // "all_posts" is a vector of ((gauss-index, time-index), gaussian
   // posterior).
   // We'll compute the posterior information, sort it, and then
   // go through it in sorted order, which maintains memory locality
   // when accessing the projection matrix.
   // Note: if we really cared we could make this use level-3 BLAS
   // (matrix-matrix multiply), but we'd need to have a temporary
   // matrix for the output and input.
   std::vector<std::pair<std::pair<int32, int32>, BaseFloat> > all_posts;
   
   for (int32 t = 0; t < feat_in.NumRows(); t++) {
     SubVector<BaseFloat> this_feat(feat_in, t);
     gmm_.LogLikelihoodsPreselect(this_feat, gselect[t], &post);
     // At this point, post will contain log-likes of the selected
     // Gaussians.
     post.ApplySoftMax(); // Now they are posteriors (which sum to one).
     for (int32 i = 0; i < post.Dim(); i++) {
       int32 gauss = gselect[t][i];
       all_posts.push_back(std::make_pair(std::make_pair(gauss, t), post(i)));
     }
   }
   std::sort(all_posts.begin(), all_posts.end());
   
   bool optimize = true;
 
   if (!optimize) { // Why do we keep this un-optimized code around?
     // For clarity, so you can see what's going on, and for easier
     // comparision with ApplyProjectionReverse which is similar to this
     // un-optimized segment.  Both un-optimized and optimized versions
     // should give identical transforms (up to tiny roundoff differences).
     for (size_t i = 0; i < all_posts.size(); i++) {
       int32 gauss = all_posts[i].first.first, t = all_posts[i].first.second;
       SubVector<BaseFloat> this_feat(feat_in, t);
       SubVector<BaseFloat> this_intermed_feat(*intermed_feat, t);
       BaseFloat this_post = all_posts[i].second;
       SubVector<BaseFloat> this_stddev(stddevs_, gauss);
 
       // The next line is equivalent to setting input_chunk to
       // -this_post * the gaussian mean / (gaussian stddev).  Note: we use
       // the fact that mean * inv_var *  stddev == mean / stddev.
       input_chunk.Range(0, dim).AddVecVec(-this_post, gmm_.means_invvars().Row(gauss),
                                           this_stddev, 0.0);
       // The next line is equivalent to adding (feat / gaussian stddev) to
       // input_chunk, so now it contains (feat - mean) / stddev, which is
       // our "normalized" feature offset.
       input_chunk.Range(0, dim).AddVecDivVec(this_post, this_feat, this_stddev,
                                              1.0);
       // The last element of this input_chunk is the posterior itself
       // (between 0 and 1).
       input_chunk(dim) = this_post * config_.post_scale;
 
       // this_intermed_feat += [appropriate chjunk of projT_] * input_chunk.
       this_intermed_feat.AddMatVec(1.0, projT_.Range(gauss*(dim+1), dim+1,
                                                      0, dim*ncontexts),
                                    kTrans, input_chunk, 1.0);
     }
   } else {
     size_t i = 0;
     // We process the "posts" vector in chunks, where each chunk corresponds to
     // the same Gaussian index (but different times).
     while (i < all_posts.size()) {
       int32 gauss = all_posts[i].first.first;
       SubVector<BaseFloat> this_stddev(stddevs_, gauss),
           this_mean_invvar(gmm_.means_invvars(), gauss);
       SubMatrix<BaseFloat> this_projT_chunk(projT_, gauss*(dim+1), dim+1,
                                             0, dim*ncontexts);
       int32 batch_size; // number of posteriors with same Gaussian..
       for (batch_size = 0;
            batch_size+i < static_cast<int32>(all_posts.size()) &&
                all_posts[batch_size+i].first.first == gauss;
            batch_size++); // empty loop body.
       Matrix<BaseFloat> input_chunks(batch_size, dim+1);
       Matrix<BaseFloat> intermed_temp(batch_size, dim*ncontexts);
       for (int32 j = 0; j < batch_size; j++) { // set up "input_chunks".
         // To understand this code, first examine code and comments in "non-optimized"
         // code chunk above (the other branch of the if/else statement).
         int32 t = all_posts[i+j].first.second;
         SubVector<BaseFloat> this_feat(feat_in, t);
         SubVector<BaseFloat> this_input_chunk(input_chunks, j);
         BaseFloat this_post = all_posts[i+j].second;
         this_input_chunk.Range(0, dim).AddVecVec(-this_post,
                                                  this_mean_invvar,
                                                  this_stddev, 0.0);
         this_input_chunk.Range(0, dim).AddVecDivVec(this_post, this_feat,
                                                     this_stddev, 1.0);
         this_input_chunk(dim) = this_post * config_.post_scale;
       }
       // The next line is where most of the computation will happen,
       // during the feature computation phase.  We have rearranged
       // stuff so it's a matrix-matrix operation, for greater
       // efficiency (when using optimized libraries like ATLAS).
       intermed_temp.AddMatMat(1.0, input_chunks, kNoTrans,
                               this_projT_chunk, kNoTrans, 0.0);
       for (int32 j = 0; j < batch_size; j++) { // add data from
         // intermed_temp to the output "intermed_feat"
         int32 t = all_posts[i+j].first.second;
         SubVector<BaseFloat> this_intermed_feat(*intermed_feat, t);
         SubVector<BaseFloat> this_intermed_temp(intermed_temp, j);
         // this_intermed_feat += this_intermed_temp.
         this_intermed_feat.AddVec(1.0, this_intermed_temp);
       }
       i += batch_size;
     }
   }
 }      

◆ ApplyProjectionReverse()

void ApplyProjectionReverse	(	const MatrixBase< BaseFloat > &	feat_in,
		const std::vector< std::vector< int32 > > &	gselect,
		const MatrixBase< BaseFloat > &	intermed_feat_deriv,
		MatrixBase< BaseFloat > *	proj_deriv_plus,
		MatrixBase< BaseFloat > *	proj_deriv_minus
	)		const

private

Definition at line 302 of file fmpe.cc.

References kaldi::AddOuterProductPlusMinus(), VectorBase< Real >::ApplySoftMax(), Fmpe::config_, VectorBase< Real >::Dim(), Fmpe::FeatDim(), Fmpe::gmm_, rnnlm::i, DiagGmm::LogLikelihoodsPreselect(), DiagGmm::means_invvars(), Fmpe::NumContexts(), MatrixBase< Real >::NumRows(), FmpeOptions::post_scale, VectorBase< Real >::Range(), MatrixBase< Real >::Row(), and Fmpe::stddevs_.

Referenced by Fmpe::AccStats().

                                                                                  {
   int32 dim = FeatDim(), ncontexts = NumContexts();  
   
   Vector<BaseFloat> post; // will be posteriors of selected Gaussians.
   Vector<BaseFloat> input_chunk(dim+1); // will be a segment of
   // the high-dimensional features.
 
   // "all_posts" is a vector of ((gauss-index, time-index), gaussian
   // posterior).
   // We'll compute the posterior information, sort it, and then
   // go through it in sorted order, which maintains memory locality
   // when accessing the projection matrix.
   std::vector<std::pair<std::pair<int32, int32>, BaseFloat> > all_posts;
   
   for (int32 t = 0; t < feat_in.NumRows(); t++) {
     SubVector<BaseFloat> this_feat(feat_in, t);
     gmm_.LogLikelihoodsPreselect(this_feat, gselect[t], &post);
     // At this point, post will contain log-likes of the selected
     // Gaussians.
     post.ApplySoftMax(); // Now they are posteriors (which sum to one).
     for (int32 i = 0; i < post.Dim(); i++) {
       // The next few lines (where we set up "input_chunk") are identical
       // to ApplyProjection.
       int32 gauss = gselect[t][i];
       all_posts.push_back(std::make_pair(std::make_pair(gauss, t), post(i)));
     }
   }
   std::sort(all_posts.begin(), all_posts.end());
   for (size_t i = 0; i < all_posts.size(); i++) {
     int32 gauss = all_posts[i].first.first, t = all_posts[i].first.second;
     BaseFloat this_post = all_posts[i].second;
     SubVector<BaseFloat> this_feat(feat_in, t);    
     SubVector<BaseFloat> this_intermed_feat_deriv(intermed_feat_deriv, t);
     SubVector<BaseFloat> this_stddev(stddevs_, gauss);
     input_chunk.Range(0, dim).AddVecVec(-this_post, gmm_.means_invvars().Row(gauss),
                                         this_stddev, 0.0);
     input_chunk.Range(0, dim).AddVecDivVec(this_post, this_feat, this_stddev,
                                            1.0);
     input_chunk(dim) = this_post * config_.post_scale;
 
     // If not for accumulating the + and - parts separately, we would be
     // doing something like:
     // proj_deriv_.Range(0, dim*ncontexts, gauss*(dim+1), dim+1).AddVecVec(
     //                    1.0, this_intermed_feat_deriv, input_chunk);
 
 
     SubMatrix<BaseFloat> plus_chunk(*proj_deriv_plus, 
                                     gauss*(dim+1), dim+1,
                                     0, dim*ncontexts),
         minus_chunk(*proj_deriv_minus, 
                     gauss*(dim+1), dim+1,
                     0, dim*ncontexts);
           
     // This next function takes the rank-one matrix
     //  (input_chunk * this_intermed_deriv'), and adds the positive
     // part to proj_deriv_plus, and minus the negative part to
     // proj_deriv_minus.
     AddOuterProductPlusMinus(static_cast<BaseFloat>(1.0),
                              input_chunk,
                              this_intermed_feat_deriv,
                              &plus_chunk, &minus_chunk);
   }
 }      

◆ ComputeC()

void ComputeC ( )

private

Definition at line 57 of file fmpe.cc.

References SpMatrix< Real >::AddDiagVec(), VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2(), Fmpe::C_, TpMatrix< Real >::Cholesky(), DiagGmm::Dim(), Fmpe::gmm_, KALDI_ASSERT, KALDI_ERR, DiagGmmNormal::means_, DiagGmmNormal::NumGauss(), DiagGmm::NumGauss(), MatrixBase< Real >::Row(), PackedMatrix< Real >::Scale(), VectorBase< Real >::Scale(), DiagGmmNormal::vars_, and DiagGmmNormal::weights_.

Referenced by Fmpe::Fmpe().

                     {
   KALDI_ASSERT(gmm_.NumGauss() != 0.0);
   int32 dim = gmm_.Dim();
 
   // Getting stats from the GMM... assume the model is
   // correct.
   SpMatrix<double> x2_stats(dim);
   Vector<double> x_stats(dim);
   double tot_count = 0.0;
   DiagGmmNormal ngmm(gmm_);
   for (int32 pdf = 0; pdf < ngmm.NumGauss(); pdf++) {
     x2_stats.AddVec2(ngmm.weights_(pdf), ngmm.means_.Row(pdf));
     x2_stats.AddDiagVec(ngmm.weights_(pdf), ngmm.vars_.Row(pdf)); // add diagonal
     // covar to diagonal elements of x2_stats.
     x_stats.AddVec(ngmm.weights_(pdf), ngmm.means_.Row(pdf));
     tot_count += ngmm.weights_(pdf);
   }
   KALDI_ASSERT(tot_count != 0.0);
   x2_stats.Scale(1.0 / tot_count);
   x_stats.Scale(1.0 / tot_count);
   x2_stats.AddVec2(-1.0, x_stats); // subtract outer product of mean,
   // to get centered covariance.
   C_.Resize(dim);
   try {
     TpMatrix<double> Ctmp(dim); Ctmp.Cholesky(x2_stats);
     C_.CopyFromTp(Ctmp);
   } catch (...) {
     KALDI_ERR << "Error initializing fMPE object: cholesky of "
         "feature variance failed.  Probably code error, or NaN/inf in model";
   }
 }

◆ ComputeFeatures()

void ComputeFeatures	(	const MatrixBase< BaseFloat > &	feat_in,
		const std::vector< std::vector< int32 > > &	gselect,
		Matrix< BaseFloat > *	feat_out
	)		const

Definition at line 370 of file fmpe.cc.

References Fmpe::ApplyC(), Fmpe::ApplyContext(), Fmpe::ApplyProjection(), Fmpe::FeatDim(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), Fmpe::NumContexts(), MatrixBase< Real >::NumRows(), and Matrix< Real >::Resize().

Referenced by main(), and kaldi::TestFmpe().

                                                               {
   int32 dim = FeatDim();
   KALDI_ASSERT(feat_in.NumRows() != 0 && feat_in.NumCols() == dim);
   KALDI_ASSERT(feat_in.NumRows() == static_cast<int32>(gselect.size()));
   feat_out->Resize(feat_in.NumRows(), feat_in.NumCols()); // will zero it.
   
   // Intermediate-dimension features
   Matrix<BaseFloat> intermed_feat(feat_in.NumRows(),
                                   dim * NumContexts());
 
   // Apply the main projection, from high-dim to intermediate
   // dimension (dim * NumContexts()).
   ApplyProjection(feat_in, gselect, &intermed_feat);
 
   // Apply the temporal context and reduces from
   // dimension dim*ncontexts to dim.
   ApplyContext(intermed_feat, feat_out);
 
   // Lastly, apply the the "C" matrix-- linear transform on the offsets.
   ApplyC(feat_out);
 }

◆ ComputeStddevs()

void ComputeStddevs ( )

private

Definition at line 89 of file fmpe.cc.

References MatrixBase< Real >::ApplyPow(), MatrixBase< Real >::CopyFromMat(), Fmpe::gmm_, DiagGmm::inv_vars(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Matrix< Real >::Resize(), and Fmpe::stddevs_.

Referenced by Fmpe::Fmpe(), and Fmpe::Read().

                           {
   const Matrix<BaseFloat> &inv_vars = gmm_.inv_vars();
   stddevs_.Resize(inv_vars.NumRows(), inv_vars.NumCols());
   stddevs_.CopyFromMat(inv_vars);
   stddevs_.ApplyPow(-0.5);
 }

◆ FeatDim()

int32 FeatDim ( ) const

inline

Definition at line 143 of file fmpe.h.

Referenced by Fmpe::AccStats(), Fmpe::ApplyContext(), Fmpe::ApplyContextReverse(), Fmpe::ApplyProjection(), Fmpe::ApplyProjectionReverse(), Fmpe::ComputeFeatures(), Fmpe::Fmpe(), and FmpeStats::Init().

143 { return gmm_.Dim(); }

kaldi::DiagGmm::Dim

int32 Dim() const

Returns the dimensionality of the Gaussian mean vectors.

Definition: diag-gmm.h:74

kaldi::Fmpe::gmm_

DiagGmm gmm_

Definition: fmpe.h:222

◆ NumContexts()

int32 NumContexts ( ) const

inline

Definition at line 145 of file fmpe.h.

Referenced by Fmpe::AccStats(), Fmpe::ApplyContext(), Fmpe::ApplyContextReverse(), Fmpe::ApplyProjection(), Fmpe::ApplyProjectionReverse(), Fmpe::ComputeFeatures(), and Fmpe::Fmpe().

145 { return static_cast<int32>(contexts_.size()); }

kaldi::int32

kaldi::int32 int32

Definition: online-tcp-source.cc:27

kaldi::Fmpe::contexts_

std::vector< std::vector< std::pair< int32, BaseFloat > > > contexts_

Definition: fmpe.h:242

◆ NumGauss()

int32 NumGauss ( ) const

inline

Definition at line 144 of file fmpe.h.

Referenced by Fmpe::Fmpe().

144 { return gmm_.NumGauss(); }

kaldi::DiagGmm::NumGauss

int32 NumGauss() const

Returns the number of mixture components in the GMM.

Definition: diag-gmm.h:72

kaldi::Fmpe::gmm_

DiagGmm gmm_

Definition: fmpe.h:222

◆ ProjectionTNumCols()

int32 ProjectionTNumCols ( ) const

inline

Definition at line 152 of file fmpe.h.

References FmpeOptions::Read(), and FmpeOptions::Write().

Referenced by FmpeStats::Init().

152 { return FeatDim() * NumContexts(); }

kaldi::Fmpe::FeatDim

int32 FeatDim() const

Definition: fmpe.h:143

kaldi::Fmpe::NumContexts

int32 NumContexts() const

Definition: fmpe.h:145

◆ ProjectionTNumRows()

int32 ProjectionTNumRows ( ) const

inline

Definition at line 151 of file fmpe.h.

Referenced by FmpeStats::Init().

151 { return (FeatDim()+1) * NumGauss(); }

kaldi::Fmpe::NumGauss

int32 NumGauss() const

Definition: fmpe.h:144

kaldi::Fmpe::FeatDim

int32 FeatDim() const

Definition: fmpe.h:143

◆ Read()

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

Definition at line 512 of file fmpe.cc.

References Fmpe::C_, Fmpe::ComputeStddevs(), Fmpe::config_, FmpeOptions::context_expansion, Fmpe::gmm_, Fmpe::projT_, FmpeOptions::Read(), DiagGmm::Read(), Matrix< Real >::Read(), and Fmpe::SetContexts().

Referenced by kaldi::TestFmpe().

                                            {
   gmm_.Read(is, binary);
   config_.Read(is, binary);
   ComputeStddevs(); // computed from gmm.
   projT_.Read(is, binary);
   C_.Read(is, binary);
   SetContexts(config_.context_expansion);
 }

◆ SetContexts()

void SetContexts ( std::string context_str )

private

Definition at line 29 of file fmpe.cc.

References Fmpe::contexts_, kaldi::ConvertStringToInteger(), kaldi::ConvertStringToReal(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_ERR, and kaldi::SplitStringToVector().

Referenced by Fmpe::Fmpe(), and Fmpe::Read().

                                             {
   // sets the contexts_ variable.
   using std::vector;
   using std::string;
   contexts_.clear();
   vector<string> ctx_vec; // splitting context_str on ":"
   SplitStringToVector(context_str, ":", false, &ctx_vec);
   contexts_.resize(ctx_vec.size());
   for (size_t i = 0; i < ctx_vec.size(); i++) {
     vector<string> pair_vec; // splitting ctx_vec[i] on ";"
     SplitStringToVector(ctx_vec[i], ";", false, &pair_vec);
     KALDI_ASSERT(pair_vec.size() != 0 && "empty context!");
     for (size_t j = 0; j < pair_vec.size(); j++) {
       vector<string> one_pair;
       SplitStringToVector(pair_vec[j], ",", false, &one_pair);
       KALDI_ASSERT(one_pair.size() == 2 &&
                    "Mal-formed context string: bad --context-expansion option?");
       int32 pos = 0;
       BaseFloat weight = BaseFloat(0);
       bool ok = ConvertStringToInteger(one_pair[0], &pos);
       ok = ConvertStringToReal(one_pair[1], &weight) && ok;
       if (!ok)
         KALDI_ERR << "Mal-formed context string: bad --context-expansion option?";
       contexts_[i].push_back(std::make_pair(pos, weight));
     }
   }
 }

◆ Update()

BaseFloat Update	(	const FmpeUpdateOptions &	config,
		const FmpeStats &	stats
	)

Definition at line 443 of file fmpe.cc.

References FmpeStats::DerivMinus(), FmpeStats::DerivPlus(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, FmpeUpdateOptions::l2_weight, FmpeUpdateOptions::learning_rate, MatrixBase< Real >::Min(), rnnlm::n, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Fmpe::projT_, and kaldi::SameDim().

Referenced by main(), and kaldi::TestFmpe().

                                                {
   SubMatrix<BaseFloat> proj_deriv_plus = stats.DerivPlus(),
       proj_deriv_minus = stats.DerivMinus();
   // tot_linear_objf_impr is the change in the actual
   // objective function if it were linear, i.e.
   //   objf-gradient . parameter-change
   // Note: none of this is normalized by the #frames (we don't have
   // this info here), so that is done at the script level.
   BaseFloat tot_linear_objf_impr = 0.0;
   int32 changed = 0; // Keep track of how many elements change sign.
   KALDI_ASSERT(SameDim(proj_deriv_plus, projT_) && SameDim(proj_deriv_minus, projT_));
   KALDI_ASSERT(proj_deriv_plus.Min() >= 0);
   KALDI_ASSERT(proj_deriv_minus.Min() >= 0);
   BaseFloat learning_rate = config.learning_rate,
       l2_weight = config.l2_weight;
   
   for (int32 i = 0; i < projT_.NumRows(); i++) {
     for (int32 j = 0; j < projT_.NumCols(); j++) {
       BaseFloat p = proj_deriv_plus(i, j), n = proj_deriv_minus(i, j),
           x = projT_(i, j);
       // Suppose the basic update (before regularization) is:
       // z <-- x  +   learning_rate * (p - n) / (p + n),
       // where z is the new parameter and x is the old one.
       // Here, we view (learning_rate / (p + n)) as a parameter-specific
       // learning rate.  In fact we view this update as the maximization
       // of an auxiliary function of the form:
       //  (z-x).(p-n)    - 0.5 (z - x)^2 (p+n)/learning_rate
       // and taking the derivative w.r.t z, we get:
       // Q'(z) =  (p-n) - (z - x) (p+n) / learning_rate
       // which we set to zero and solve for z, to get z = x + learning_rate.(p-n)/(p+n)
       // At this point we add regularization, a term of the form -l2_weight * z^2.
       // Our new auxiliary function derivative is:
       // Q(z) = -2.l2_weight.z + (p-n) - (z - x) (p+n) / learning_rate
       // We can write this as:
       // Q(z) = z . (-2.l2_weight - (p+n)/learning_rate)
       //        + (p-n) + x(p+n)/learning_rate
       // solving for z, we get:
       //      z = ((p-n) + x (p+n)/learning_rate) / (2.l2_weight + (p+n)/learning_rate)
 
       BaseFloat z = ((p-n) + x*(p+n)/learning_rate) / (2*l2_weight + (p+n)/learning_rate);
       // z is the new parameter value.
 
       tot_linear_objf_impr += (z-x) * (p-n); // objf impr based on linear assumption.
       projT_(i, j) = z;
       if (z*x < 0) changed++;
     }
   }
   KALDI_LOG << "Objf impr (assuming linear) is " << tot_linear_objf_impr;
   KALDI_LOG << ((100.0*changed)/(projT_.NumRows()*projT_.NumCols()))
             << "% of matrix elements changed sign.";
   return tot_linear_objf_impr;
 }

◆ Write()

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

Definition at line 500 of file fmpe.cc.

References Fmpe::C_, Fmpe::config_, Fmpe::gmm_, KALDI_ERR, DiagGmm::NumGauss(), Fmpe::projT_, FmpeOptions::Write(), DiagGmm::Write(), and MatrixBase< Real >::Write().

Referenced by main(), and kaldi::TestFmpe().

                                                   {
   if (gmm_.NumGauss() == 0)
     KALDI_ERR << "Fmpe::Write, object not initialized.";
   gmm_.Write(os, binary);
   config_.Write(os, binary);
   // stddevs_ are derived, don't write them.
   projT_.Write(os, binary);
   C_.Write(os, binary);
   // contexts_ are derived from config, don't write them.
 }