#include <estimate-am-sgmm2.h>

Collaboration diagram for MleAmSgmm2Updater:

Public Member Functions
	MleAmSgmm2Updater (const MleAmSgmm2Options &options)

void	Reconfigure (const MleAmSgmm2Options &options)

void	Update (const MleAmSgmm2Accs &accs, AmSgmm2 *model, SgmmUpdateFlagsType flags)

Private Member Functions
void	UpdatePhoneVectorsInternal (const MleAmSgmm2Accs &accs, const std::vector< SpMatrix< double > > &H, const std::vector< Matrix< double > > &log_a, AmSgmm2 model, double auxf_impr, int32 num_threads, int32 thread_id) const

double	UpdatePhoneVectors (const MleAmSgmm2Accs &accs, const std::vector< SpMatrix< double > > &H, const std::vector< Matrix< double > > &log_a, AmSgmm2 *model) const
	In this update, smoothing terms are not supported. More...

double	UpdateM (const MleAmSgmm2Accs &accs, const std::vector< SpMatrix< double > > &Q, const Vector< double > &gamma_i, AmSgmm2 *model)

void	RenormalizeV (const MleAmSgmm2Accs &accs, AmSgmm2 *model, const Vector< double > &gamma_i, const std::vector< SpMatrix< double > > &H)

double	UpdateN (const MleAmSgmm2Accs &accs, const Vector< double > &gamma_i, AmSgmm2 *model)

void	RenormalizeN (const MleAmSgmm2Accs &accs, const Vector< double > &gamma_i, AmSgmm2 *model)

double	UpdateVars (const MleAmSgmm2Accs &accs, const std::vector< SpMatrix< double > > &S_means, const Vector< double > &gamma_i, AmSgmm2 *model)

double	UpdateW (const MleAmSgmm2Accs &accs, const std::vector< Matrix< double > > &log_a, const Vector< double > &gamma_i, AmSgmm2 *model)

double	UpdateU (const MleAmSgmm2Accs &accs, const Vector< double > &gamma_i, AmSgmm2 *model)

double	UpdateSubstateWeights (const MleAmSgmm2Accs &accs, AmSgmm2 *model)

void	ComputeMPrior (AmSgmm2 *model)

double	MapUpdateM (const MleAmSgmm2Accs &accs, const std::vector< SpMatrix< double > > &Q, const Vector< double > &gamma_i, AmSgmm2 *model)

	KALDI_DISALLOW_COPY_AND_ASSIGN (MleAmSgmm2Updater)

	MleAmSgmm2Updater ()

Static Private Member Functions
static void	ComputeQ (const MleAmSgmm2Accs &accs, const AmSgmm2 &model, std::vector< SpMatrix< double > > *Q)
	Compute the Q_i quantities (Eq. 64). More...

static void	ComputeSMeans (const MleAmSgmm2Accs &accs, const AmSgmm2 &model, std::vector< SpMatrix< double > > *S_means)
	Compute the S_means quantities, minus sum: (Y_i M_i^T + M_i Y_I^T). More...

static void	UpdateWGetStats (const MleAmSgmm2Accs &accs, const AmSgmm2 &model, const Matrix< double > &w, const std::vector< Matrix< double > > &log_a, Matrix< double > F_i, Matrix< double > g_i, double *tot_like, int32 num_threads, int32 thread_id)
	Called, multithreaded, inside UpdateW. More...

static void	ComputeLogA (const MleAmSgmm2Accs &accs, std::vector< Matrix< double > > *log_a)

Private Attributes
MleAmSgmm2Options	options_

Friends
class	UpdateWClass

class	UpdatePhoneVectorsClass

class	EbwEstimateAmSgmm2

class	EbwAmSgmm2Updater

Detailed Description

Definition at line 246 of file estimate-am-sgmm2.h.

Constructor & Destructor Documentation

◆ MleAmSgmm2Updater() [1/2]

MleAmSgmm2Updater ( const MleAmSgmm2Options & options )

inlineexplicit

Definition at line 248 of file estimate-am-sgmm2.h.

249 : options_(options) {}

kaldi::MleAmSgmm2Updater::options_

MleAmSgmm2Options options_

Definition: estimate-am-sgmm2.h:274

◆ MleAmSgmm2Updater() [2/2]

MleAmSgmm2Updater ( )

inlineprivate

Definition at line 341 of file estimate-am-sgmm2.h.

341 {} // Prevent unconfigured updater.

Member Function Documentation

◆ ComputeLogA()

void ComputeLogA	(	const MleAmSgmm2Accs &	accs,
		std::vector< Matrix< double > > *	log_a
	)

staticprivate

Definition at line 806 of file estimate-am-sgmm2.cc.

References MleAmSgmm2Accs::a_, MleAmSgmm2Accs::gamma_, KALDI_ASSERT, KALDI_WARN, MleAmSgmm2Accs::num_gaussians_, and MleAmSgmm2Accs::num_groups_.

Referenced by EbwAmSgmm2Updater::UpdateW().

                                                                        {
   // This computes the logarithm of the statistics a_{jmi} defined
   // in Eq. 40 of the SSGMM techreport.  Although the log of a_{jmi} never
   // explicitly appears in the techreport, it happens to be more convenient
   // in the code to use the log of it.
   // Note: because of the way a is computed, for each (j,m) the
   // entries over i should always be all zero or all nonzero.
   int32 num_zeros = 0;
   KALDI_ASSERT(accs.a_.size() == accs.num_groups_);
   log_a->resize(accs.num_groups_);
   for (int32 j1 = 0; j1 < accs.num_groups_; j1++) {
     int32 num_substates = accs.a_[j1].NumRows();
     KALDI_ASSERT(num_substates > 0);
     (*log_a)[j1].Resize(num_substates, accs.num_gaussians_);
     for (int32 m = 0; m < num_substates; m++) {
       if (accs.a_[j1](m, 0) == 0.0) { // Zero accs.
         num_zeros++;
         if (accs.gamma_[j1].Row(m).Sum() != 0.0)
           KALDI_WARN << "Inconsistency between a and gamma stats. [BAD!]";
         // leave the row zero.  This means the sub-state saw no stats.
       } else {
         (*log_a)[j1].Row(m).CopyFromVec(accs.a_[j1].Row(m));
         (*log_a)[j1].Row(m).ApplyLog();
       }
     }
   }
   if (num_zeros != 0)
     KALDI_WARN << num_zeros
                << " sub-states with zero \"a\" (and presumably gamma) stats.";
 }

◆ ComputeMPrior()

void ComputeMPrior ( AmSgmm2 * model )

private

Definition at line 1086 of file estimate-am-sgmm2.cc.

References MatrixBase< Real >::AddMat(), SpMatrix< Real >::AddMat2Sp(), AmSgmm2::col_cov_inv_, MatrixBase< Real >::CopyFromMat(), AmSgmm2::FeatureDim(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, kaldi::kNoTrans, kaldi::kTrans, kaldi::Log(), AmSgmm2::M_, M_PI, AmSgmm2::M_prior_, AmSgmm2::NumGauss(), AmSgmm2::PhoneSpaceDim(), AmSgmm2::row_cov_inv_, MatrixBase< Real >::Scale(), and kaldi::TraceSpSp().

                                                     {
   KALDI_ASSERT(options_.map_M_prior_iters > 0);
   int32 Ddim = model->FeatureDim();
   int32 Sdim = model->PhoneSpaceDim();
   int32 nGaussians = model->NumGauss();
 
   // inverse variance of the columns of M: dim is # of rows
   model->col_cov_inv_.Resize(Ddim);
   // inverse covariance of the rows of M: dim is # of columns
   model->row_cov_inv_.Resize(Sdim);
 
   model->col_cov_inv_.SetUnit();
   model->row_cov_inv_.SetUnit();
 
   if (model->M_prior_.size() == 0) {
     model->M_prior_.resize(nGaussians);
     for (int32 i = 0; i < nGaussians; i++) {
       model->M_prior_[i].Resize(Ddim, Sdim);
       model->M_prior_[i].CopyFromMat(model->M_[i]); // We initialize Mpri as this
     }
   }
 
   if (options_.full_col_cov || options_.full_row_cov) {
     Matrix<double> avg_M(Ddim, Sdim);  // average of the Gaussian prior means
     for (int32 i = 0; i < nGaussians; i++)
       avg_M.AddMat(1.0, Matrix<double>(model->M_prior_[i]));
     avg_M.Scale(1.0 / nGaussians);
 
     Matrix<double> MDiff(Ddim, Sdim);
     for (int32 iter = 0; iter < options_.map_M_prior_iters; iter++) {
       { // diagnostic block.
         double prior_like = -0.5 * nGaussians * (Ddim * Sdim * Log(2 * M_PI)
                 + Sdim * (-model->row_cov_inv_.LogPosDefDet())
                 + Ddim * (-model->col_cov_inv_.LogPosDefDet()));
         for (int32 i = 0; i < nGaussians; i++) {
           MDiff.CopyFromMat(Matrix<double>(model->M_prior_[i]));
           MDiff.AddMat(-1.0, avg_M);  // MDiff = M_{i} - avg(M)
           SpMatrix<double> tmp(Ddim);
           // tmp = MDiff.Omega_r^{-1}*MDiff^T.
           tmp.AddMat2Sp(1.0, MDiff, kNoTrans,
                         SpMatrix<double>(model->row_cov_inv_), 0.0);
           prior_like -= 0.5 * TraceSpSp(tmp, SpMatrix<double>(model->col_cov_inv_));
         }
         KALDI_LOG << "Before iteration " << iter
             << " of updating prior over M, log like per dimension modeled is "
             << prior_like / (nGaussians * Ddim * Sdim);
       }
 
       // First estimate the column covariances (\Omega_r in paper)
       if (options_.full_col_cov) {
         size_t limited;
         model->col_cov_inv_.SetZero();
         for (int32 i = 0; i < nGaussians; i++) {
           MDiff.CopyFromMat(Matrix<double>(model->M_prior_[i]));
           MDiff.AddMat(-1.0, avg_M);  // MDiff = M_{i} - avg(M)
           // Omega_r += 1/(D*I) * Mdiff * Omega_c^{-1} * Mdiff^T
           model->col_cov_inv_.AddMat2Sp(1.0 / (Ddim * nGaussians),
                                         Matrix<BaseFloat>(MDiff), kNoTrans,
                                         model->row_cov_inv_, 1.0);
         }
         model->col_cov_inv_.PrintEigs("col_cov");
         limited = model->col_cov_inv_.LimitCond(options_.max_cond,
                                                 true /*invert the matrix*/);
         if (limited != 0) {
           KALDI_LOG << "Computing column covariances for M: limited " << limited
                     << " singular values, max condition is "
                     << options_.max_cond;
         }
       }
 
       // Now estimate the row covariances (\Omega_c in paper)
       if (options_.full_row_cov) {
         size_t limited;
         model->row_cov_inv_.SetZero();
         for (int32 i = 0; i < nGaussians; i++) {
           MDiff.CopyFromMat(Matrix<double>(model->M_prior_[i]));
           MDiff.AddMat(-1.0, avg_M);  // MDiff = M_{i} - avg(M)
           // Omega_c += 1/(S*I) * Mdiff^T * Omega_r^{-1} * Mdiff.
           model->row_cov_inv_.AddMat2Sp(1.0 / (Sdim * nGaussians),
                                         Matrix<BaseFloat>(MDiff), kTrans,
                                         model->col_cov_inv_, 1.0);
         }
         model->row_cov_inv_.PrintEigs("row_cov");
         limited = model->row_cov_inv_.LimitCond(options_.max_cond,
                                                 true /*invert the matrix*/);
         if (limited != 0) {
           KALDI_LOG << "Computing row covariances for M: limited " << limited
                     << " singular values, max condition is "
                     << options_.max_cond;
         }
       }
     }  // end iterations
   }
 }

◆ ComputeQ()

void ComputeQ	(	const MleAmSgmm2Accs &	accs,
		const AmSgmm2 &	model,
		std::vector< SpMatrix< double > > *	Q
	)

staticprivate

Compute the Q_i quantities (Eq. 64).

Definition at line 686 of file estimate-am-sgmm2.cc.

References MleAmSgmm2Accs::gamma_, rnnlm::i, MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::num_groups_, AmSgmm2::NumSubstatesForGroup(), MleAmSgmm2Accs::phn_space_dim_, and AmSgmm2::v_.

Referenced by EbwAmSgmm2Updater::Update().

                                                                   {
   Q->resize(accs.num_gaussians_);
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     (*Q)[i].Resize(accs.phn_space_dim_);
     for (int32 j1 = 0; j1 < accs.num_groups_; j1++) {
       for (int32 m = 0; m < model.NumSubstatesForGroup(j1); m++) {
         if (accs.gamma_[j1](m, i) > 0.0) {
           (*Q)[i].AddVec2(static_cast<BaseFloat>(accs.gamma_[j1](m, i)),
                           model.v_[j1].Row(m));
         }
       }
     }
   }
 }

◆ ComputeSMeans()

void ComputeSMeans	(	const MleAmSgmm2Accs &	accs,
		const AmSgmm2 &	model,
		std::vector< SpMatrix< double > > *	S_means
	)

staticprivate

Compute the S_means quantities, minus sum: (Y_i M_i^T + M_i Y_I^T).

Definition at line 706 of file estimate-am-sgmm2.cc.

References MatrixBase< Real >::AddMat(), MatrixBase< Real >::AddMatMat(), VectorBase< Real >::AddMatVec(), MleAmSgmm2Accs::feature_dim_, MleAmSgmm2Accs::gamma_, rnnlm::i, KALDI_ASSERT, kaldi::kNoTrans, kaldi::kTrans, kaldi::kUndefined, AmSgmm2::M_, MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::num_groups_, AmSgmm2::NumSubstatesForGroup(), AmSgmm2::v_, and MleAmSgmm2Accs::Y_.

Referenced by EbwAmSgmm2Updater::Update().

                                                                              {
   S_means->resize(accs.num_gaussians_);
   Matrix<double> YM_MY(accs.feature_dim_, accs.feature_dim_);
   Vector<BaseFloat> mu_jmi(accs.feature_dim_);
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     // YM_MY = - (Y_{i} M_{i}^T)
     YM_MY.AddMatMat(-1.0, accs.Y_[i], kNoTrans,
                     Matrix<double>(model.M_[i]), kTrans, 0.0);
     // Add its own transpose: YM_MY = - (Y_{i} M_{i}^T + M_{i} Y_{i}^T)
     {
       Matrix<double> M(YM_MY, kTrans);
       YM_MY.AddMat(1.0, M);
     }
     (*S_means)[i].Resize(accs.feature_dim_, kUndefined);
     (*S_means)[i].CopyFromMat(YM_MY);  // Sigma_{i} = -(YM' + MY')
 
     for (int32 j1 = 0; j1 < accs.num_groups_; j1++) {
       for (int32 m = 0; m < model.NumSubstatesForGroup(j1); m++) {
         if (accs.gamma_[j1](m, i) != 0.0) {
           // Sigma_{i} += gamma_{jmi} * mu_{jmi}*mu_{jmi}^T
           mu_jmi.AddMatVec(1.0, model.M_[i], kNoTrans, model.v_[j1].Row(m), 0.0);
           (*S_means)[i].AddVec2(static_cast<BaseFloat>(accs.gamma_[j1](m, i)), mu_jmi);
         }
       }
     }
     KALDI_ASSERT(1.0 / (*S_means)[i](0, 0) != 0.0);
   }
 }

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( MleAmSgmm2Updater )

private

◆ MapUpdateM()

double MapUpdateM	(	const MleAmSgmm2Accs &	accs,
		const std::vector< SpMatrix< double > > &	Q,
		const Vector< double > &	gamma_i,
		AmSgmm2 *	model
	)

private

Definition at line 1183 of file estimate-am-sgmm2.cc.

References MatrixBase< Real >::AddMat(), MatrixBase< Real >::AddMatSp(), MatrixBase< Real >::AddSpMat(), AmSgmm2::col_cov_inv_, MatrixBase< Real >::CopyFromMat(), SolverOptions::eps, MleAmSgmm2Accs::feature_dim_, AmSgmm2::FeatureDim(), rnnlm::i, SolverOptions::K, KALDI_LOG, KALDI_WARN, kaldi::kNoTrans, kaldi::kSetZero, AmSgmm2::M_, AmSgmm2::M_prior_, SolverOptions::name, AmSgmm2::NumGauss(), AmSgmm2::PhoneSpaceDim(), AmSgmm2::row_cov_inv_, PackedMatrix< Real >::Scale(), AmSgmm2::SigmaInv_, kaldi::SolveDoubleQuadraticMatrixProblem(), and MleAmSgmm2Accs::Y_.

                                                      {
   int32 Ddim = model->FeatureDim();
   int32 Sdim = model->PhoneSpaceDim();
   int32 nGaussians = model->NumGauss();
 
   KALDI_LOG << "Prior smoothing parameter: Tau = " << options_.tau_map_M;
   if (model->M_prior_.size() == 0 || model->col_cov_inv_.NumRows() == 0
       || model->row_cov_inv_.NumRows() == 0) {
     KALDI_LOG << "Computing the prior first";
     ComputeMPrior(model);
   }
 
   Matrix<double> G(Ddim, Sdim);
   // \tau \Omega_c^{-1} avg(M) \Omega_r^{-1}, depends on Gaussian index
   Matrix<double> prior_term_i(Ddim, Sdim);
   SpMatrix<double> P2(model->col_cov_inv_);
   SpMatrix<double> Q2(model->row_cov_inv_);
   Q2.Scale(options_.tau_map_M);
 
   double totcount = 0.0, tot_like_impr = 0.0;
   for (int32 i = 0; i < nGaussians; ++i) {
     if (gamma_i(i) < accs.feature_dim_) {
       KALDI_WARN << "For component " << i << ": not updating M due to very "
                  << "small count (=" << gamma_i(i) << ").";
       continue;
     }
 
     Matrix<double> tmp(Ddim, Sdim, kSetZero);
     tmp.AddSpMat(1.0, SpMatrix<double>(model->col_cov_inv_),
                  Matrix<double>(model->M_prior_[i]), kNoTrans, 0.0);
     prior_term_i.AddMatSp(options_.tau_map_M, tmp, kNoTrans,
                           SpMatrix<double>(model->row_cov_inv_), 0.0);
 
     Matrix<double> SigmaY(Ddim, Sdim, kSetZero);
     SigmaY.AddSpMat(1.0, SpMatrix<double>(model->SigmaInv_[i]), accs.Y_[i],
                     kNoTrans, 0.0);
     G.CopyFromMat(SigmaY);  // G = \Sigma_{i}^{-1} Y_{i}
     G.AddMat(1.0, prior_term_i); // G += \tau \Omega_c^{-1} avg(M) \Omega_r^{-1}
     SpMatrix<double> P1(model->SigmaInv_[i]);
     Matrix<double> Mi(model->M_[i]);
 
     SolverOptions opts;
     opts.name = "M";
     opts.K = options_.max_cond;
     opts.eps = options_.epsilon;
     double impr =
         SolveDoubleQuadraticMatrixProblem(G, P1, P2, Q[i], Q2, opts, &Mi);
     model->M_[i].CopyFromMat(Mi);
     if (i < 10) {
       KALDI_LOG << "Objf impr for projection M for i = " << i << ", is "
                 << (impr / (gamma_i(i) + 1.0e-20)) << " over " << gamma_i(i)
                 << " frames";
     }
     totcount += gamma_i(i);
     tot_like_impr += impr;
   }
   tot_like_impr /= (totcount + 1.0e-20);
   KALDI_LOG << "Overall objective function improvement for model projections "
             << "M is " << tot_like_impr << " over " << totcount << " frames";
   return tot_like_impr;
 }

◆ Reconfigure()

void Reconfigure ( const MleAmSgmm2Options & options )

inline

Definition at line 250 of file estimate-am-sgmm2.h.

                                                      {
     options_ = options;
   }

◆ RenormalizeN()

void RenormalizeN	(	const MleAmSgmm2Accs &	accs,
		const Vector< double > &	gamma_i,
		AmSgmm2 *	model
	)

private

Definition at line 1525 of file estimate-am-sgmm2.cc.

References MatrixBase< Real >::AddMatMat(), SpMatrix< Real >::AddSp(), MleAmSgmm2Accs::feature_dim_, rnnlm::i, KALDI_ASSERT, KALDI_LOG, KALDI_WARN, kaldi::kNoTrans, MatrixBase< Real >::MulColsVec(), AmSgmm2::N_, MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::R_, PackedMatrix< Real >::Scale(), MleAmSgmm2Accs::spk_space_dim_, VectorBase< Real >::Sum(), and SpMatrix< Real >::SymPosSemiDefEig().

                                                     {
   KALDI_ASSERT(accs.R_.size() != 0);
   double tot_count = gamma_i.Sum();
   if (tot_count == 0) {
     KALDI_WARN << "Not renormalizing N, since there are no counts.";
     return;
   }
 
   SpMatrix<double> RTot(accs.spk_space_dim_);
   //  for (int32 i = 0; i < accs.num_gaussians_; i++) {
   //    RTot.AddSp(1.0, accs.R_[i]);
   //  }
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     RTot.AddSp(gamma_i(i), accs.R_[i]);
   }
   RTot.Scale(1.0 / tot_count);
   Matrix<double> U(accs.spk_space_dim_, accs.spk_space_dim_);
   Vector<double> eigs(accs.spk_space_dim_);
   RTot.SymPosSemiDefEig(&eigs, &U);
   KALDI_LOG << "Renormalizing N, eigs are: " << (eigs);
   Vector<double> sqrteigs(accs.spk_space_dim_);
   for (int32 t = 0; t < accs.spk_space_dim_; t++) {
     sqrteigs(t) = sqrt(eigs(t));
   }
   // e.g.   diag(eigs)^{-0.5} * U' * RTot * U * diag(eigs)^{-0.5}  = 1
   // But inverse transpose of this transformation needs to take place on R,
   // i.e. not (on left: diag(eigs)^{-0.5} * U')
   // but: (inverse it: U . diag(eigs)^{0.5},
   // transpose it: diag(eigs)^{0.5} U^T. Need to do this on the right to N
   // (because N has the spk vecs on the right), so N := N U diag(eigs)^{0.5}
   U.MulColsVec(sqrteigs);
   Matrix<double> Ntmp(accs.feature_dim_, accs.spk_space_dim_);
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     Ntmp.AddMatMat(1.0, Matrix<double>(model->N_[i]), kNoTrans, U, kNoTrans, 0.0);
     model->N_[i].CopyFromMat(Ntmp);
   }
 }

◆ RenormalizeV()

void RenormalizeV	(	const MleAmSgmm2Accs &	accs,
		AmSgmm2 *	model,
		const Vector< double > &	gamma_i,
		const std::vector< SpMatrix< double > > &	H
	)

private

Definition at line 944 of file estimate-am-sgmm2.cc.

References SpMatrix< Real >::AddMat2Sp(), MatrixBase< Real >::AddMatMat(), VectorBase< Real >::AddMatVec(), SpMatrix< Real >::AddSp(), SpMatrix< Real >::AddVec2(), TpMatrix< Real >::Cholesky(), MatrixBase< Real >::CopyFromTp(), count, MleAmSgmm2Accs::feature_dim_, rnnlm::i, TpMatrix< Real >::Invert(), MatrixBase< Real >::Invert(), SpMatrix< Real >::IsDiagonal(), SpMatrix< Real >::IsPosDef(), SpMatrix< Real >::IsUnit(), KALDI_ASSERT, KALDI_LOG, kaldi::kNoTrans, kaldi::kTrans, AmSgmm2::M_, MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::num_groups_, AmSgmm2::NumSubstatesForGroup(), MleAmSgmm2Accs::phn_space_dim_, SpMatrix< Real >::PrintEigs(), MatrixBase< Real >::Row(), PackedMatrix< Real >::Scale(), VectorBase< Real >::Sum(), SpMatrix< Real >::SymPosSemiDefEig(), AmSgmm2::v_, and AmSgmm2::w_.

                                                                         {
   // Compute H^{(sm)}, the "smoothing" matrix-- average of H's.
   SpMatrix<double> H_sm(accs.phn_space_dim_);
   for (int32 i = 0; i < accs.num_gaussians_; i++)
     H_sm.AddSp(gamma_i(i), H[i]);
   KALDI_ASSERT(gamma_i.Sum() > 0.0);
   H_sm.Scale(1.0 / gamma_i.Sum());
 
   SpMatrix<double> Sigma(accs.phn_space_dim_);
   int32 count = 0;
   for (int32 j1 = 0; j1 < accs.num_groups_; j1++) {
     for (int32 m = 0; m < model->NumSubstatesForGroup(j1); m++) {
       count++;
       Sigma.AddVec2(static_cast<BaseFloat>(1.0), model->v_[j1].Row(m));
     }
   }
   if (!Sigma.IsPosDef()) {
     KALDI_LOG << "Not renormalizing v because scatter is not positive definite"
               << " -- maybe first iter?";
     return;
   }
   Sigma.Scale(1.0 / count);
   KALDI_LOG << "Scatter of vectors v is : ";
   Sigma.PrintEigs("Sigma");
 
   // Want to make variance of v unit and H_sm (like precision matrix) diagonal.
   TpMatrix<double> L(accs.phn_space_dim_);
   L.Cholesky(Sigma);
   TpMatrix<double> LInv(L);
   LInv.Invert();
 
   Matrix<double> tmpL(accs.phn_space_dim_, accs.phn_space_dim_);
   tmpL.CopyFromTp(L);
 
   SpMatrix<double> H_sm_proj(accs.phn_space_dim_);
   H_sm_proj.AddMat2Sp(1.0, tmpL, kTrans, H_sm, 0.0);
   // H_sm_proj := L^{T} * H_sm * L.
   // This is right because we would transform the vectors themselves
   // by L^{-1}, and H_sm is like the inverse of the vectors,
   // so it's {L^{-1}}^{-T} = L^T.
 
   Matrix<double> U(accs.phn_space_dim_, accs.phn_space_dim_);
   Vector<double> eigs(accs.phn_space_dim_);
   H_sm_proj.SymPosSemiDefEig(&eigs, &U, 1.0);  // 1.0 means no checking +ve def -> faster
   KALDI_LOG << "Note on the next diagnostic: the first number is generally not "
             << "that meaningful as it relates to the static offset";
   H_sm_proj.PrintEigs("H_sm_proj (Significance of dims in vector space.. note)");
 
   // Transform on vectors is U^T L^{-1}.
   // Why?  Because transform on H_sm is T =U^T L^T
   // and we want T^{-T} by normal rules of vector/covector and we
   // have (U^T L^T)^{-T} = (L U)^{-1} = U^T L^{-1}.
   Matrix<double> Trans(accs.phn_space_dim_, accs.phn_space_dim_);  // T^{-T}
   Matrix<double> tmpLInv(accs.phn_space_dim_, accs.phn_space_dim_);
   tmpLInv.CopyFromTp(LInv);
   Trans.AddMatMat(1.0, U, kTrans, tmpLInv, kNoTrans, 0.0);
   Matrix<double> TransInv(Trans);
   TransInv.Invert();  // T in above...
 
 #ifdef KALDI_PARANOID
   {
     SpMatrix<double> H_sm_tmp(accs.phn_space_dim_);
     H_sm_tmp.AddMat2Sp(1.0, TransInv, kTrans, H_sm, 0.0);
     KALDI_ASSERT(H_sm_tmp.IsDiagonal(0.1));
   }
   {
     SpMatrix<double> Sigma_tmp(accs.phn_space_dim_);
     Sigma_tmp.AddMat2Sp(1.0, Trans, kNoTrans, Sigma, 0.0);
     KALDI_ASSERT(Sigma_tmp.IsUnit(0.1));
   }
 #endif
 
   for (int32 j1 = 0; j1 < accs.num_groups_; j1++) {
     for (int32 m = 0; m < model->NumSubstatesForGroup(j1); m++) {
       Vector<double> tmp(accs.phn_space_dim_);
       tmp.AddMatVec(1.0, Trans, kNoTrans, Vector<double>(model->v_[j1].Row(m)), 0.0);
       model->v_[j1].Row(m).CopyFromVec(tmp);
     }
   }
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     Vector<double> tmp(accs.phn_space_dim_);
     tmp.AddMatVec(1.0, TransInv, kTrans, Vector<double>(model->w_.Row(i)), 0.0);
     model->w_.Row(i).CopyFromVec(tmp);
 
     Matrix<double> tmpM(accs.feature_dim_, accs.phn_space_dim_);
     // Multiplying on right not left so must not transpose TransInv.
     tmpM.AddMatMat(1.0, Matrix<double>(model->M_[i]), kNoTrans,
                    TransInv, kNoTrans, 0.0);
     model->M_[i].CopyFromMat(tmpM);
   }
   KALDI_LOG << "Renormalized subspace.";
 }

◆ Update()

void Update	(	const MleAmSgmm2Accs &	accs,
		AmSgmm2 *	model,
		SgmmUpdateFlagsType	flags
	)

Definition at line 612 of file estimate-am-sgmm2.cc.

References MleAmSgmm2Accs::a_, VectorBase< Real >::AddRowSumMat(), AmSgmm2::ComputeH(), MleAmSgmm2Accs::gamma_, KALDI_LOG, kaldi::kSgmmCovarianceMatrix, kaldi::kSgmmPhoneProjections, kaldi::kSgmmPhoneVectors, kaldi::kSgmmPhoneWeightProjections, kaldi::kSgmmSpeakerProjections, kaldi::kSgmmSpeakerWeightProjections, kaldi::kSgmmSubstateWeights, AmSgmm2::n_, MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::num_groups_, MleAmSgmm2Accs::total_frames_, MleAmSgmm2Accs::total_like_, and AmSgmm2::w_jmi_.

Referenced by main(), and TestSgmm2AccsIO().

                                                           {
   // Q_{i}, quadratic term for phonetic subspace estimation. Dim is [I][S][S]
   std::vector< SpMatrix<double> > Q;
 
   // Eq (74): S_{i}^{(means)}, scatter of substate mean vectors for estimating
   // the shared covariance matrices. [Actually this variable contains also the
   // term -(Y_i M_i^T + M_i Y_I^T).]  Dimension is [I][D][D].
   std::vector< SpMatrix<double> > S_means;
   std::vector<Matrix<double> > log_a;
 
   Vector<double> gamma_i(accs.num_gaussians_);
   for (int32 j1 = 0; j1 < accs.num_groups_; j1++)
     gamma_i.AddRowSumMat(1.0, accs.gamma_[j1]); // add sum of rows of
   // accs.gamma_[j1], to gamma_i.
 
   if (flags & kSgmmPhoneProjections)
     ComputeQ(accs, *model, &Q);
   if (flags & kSgmmCovarianceMatrix)
     ComputeSMeans(accs, *model, &S_means);
   if (!accs.a_.empty())
     ComputeLogA(accs, &log_a);
 
   // quantities used in both vector and weights updates...
   vector< SpMatrix<double> > H;
   // "smoothing" matrices, weighted sums of above.
   SpMatrix<double> H_sm; // weighted sum of H.  Used e.g. in renormalizing phonetic space.
   if ((flags & (kSgmmPhoneVectors | kSgmmPhoneWeightProjections))
       || options_.renormalize_V)
     model->ComputeH(&H);
 
   BaseFloat tot_impr = 0.0;
 
   if (flags & kSgmmPhoneVectors)
     tot_impr += UpdatePhoneVectors(accs, H, log_a, model);
   if (flags & kSgmmPhoneProjections) {
     if (options_.tau_map_M > 0.0)
       tot_impr += MapUpdateM(accs, Q, gamma_i, model);  // MAP adaptation of M
     else
       tot_impr += UpdateM(accs, Q, gamma_i, model);
   }
   if (flags & kSgmmPhoneWeightProjections)
     tot_impr += UpdateW(accs, log_a, gamma_i, model);
   if (flags & kSgmmCovarianceMatrix)
     tot_impr += UpdateVars(accs, S_means, gamma_i, model);
   if (flags & kSgmmSubstateWeights)
     tot_impr += UpdateSubstateWeights(accs, model);
   if (flags & kSgmmSpeakerProjections)
     tot_impr += UpdateN(accs, gamma_i, model);
   if (flags & kSgmmSpeakerWeightProjections)
     tot_impr += UpdateU(accs, gamma_i, model);
 
   if ((flags & kSgmmSpeakerProjections) && (options_.renormalize_N))
     RenormalizeN(accs, gamma_i, model); // if you renormalize N you have to
   // alter any speaker vectors you're keeping around, as well.
   // So be careful with this option.
 
   if (options_.renormalize_V)
     RenormalizeV(accs, model, gamma_i, H);
 
   KALDI_LOG << "*Overall auxf improvement, combining all parameters, is "
             << tot_impr;
 
   KALDI_LOG << "***Overall data likelihood is "
             << (accs.total_like_/accs.total_frames_)
             << " over " << accs.total_frames_ << " frames.";
 
   model->n_.clear(); // has become invalid.
   model->w_jmi_.clear(); // has become invalid.
   // we updated the v or w quantities.
 }

◆ UpdateM()

double UpdateM	(	const MleAmSgmm2Accs &	accs,
		const std::vector< SpMatrix< double > > &	Q,
		const Vector< double > &	gamma_i,
		AmSgmm2 *	model
	)

private

Definition at line 1040 of file estimate-am-sgmm2.cc.

References SolverOptions::eps, MleAmSgmm2Accs::feature_dim_, rnnlm::i, SolverOptions::K, KALDI_LOG, KALDI_VLOG, KALDI_WARN, AmSgmm2::M_, SolverOptions::name, MleAmSgmm2Accs::num_gaussians_, AmSgmm2::SigmaInv_, kaldi::SolveQuadraticMatrixProblem(), and MleAmSgmm2Accs::Y_.

                                                  {
   double tot_count = 0.0, tot_like_impr = 0.0;
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     if (gamma_i(i) < accs.feature_dim_) {
       KALDI_WARN << "For component " << i << ": not updating M due to very "
                  << "small count (=" << gamma_i(i) << ").";
       continue;
     }
 
     SolverOptions opts;
     opts.name = "M";
     opts.K = options_.max_cond;
     opts.eps = options_.epsilon;
 
     Matrix<double> Mi(model->M_[i]);
     double impr =
         SolveQuadraticMatrixProblem(Q[i], accs.Y_[i],
                                     SpMatrix<double>(model->SigmaInv_[i]),
                                     opts, &Mi);
 
     model->M_[i].CopyFromMat(Mi);
 
     if (i < 10) {
       KALDI_VLOG(2) << "Objf impr for projection M for i = " << i << ", is "
                     << (impr/(gamma_i(i) + 1.0e-20)) << " over " << gamma_i(i)
                     << " frames";
     }
     tot_count += gamma_i(i);
     tot_like_impr += impr;
   }
   tot_like_impr /= (tot_count + 1.0e-20);
   KALDI_LOG << "Overall objective function improvement for model projections "
             << "M is " << tot_like_impr << " over " << tot_count << " frames";
   return tot_like_impr;
 }

◆ UpdateN()

double UpdateN	(	const MleAmSgmm2Accs &	accs,
		const Vector< double > &	gamma_i,
		AmSgmm2 *	model
	)

private

Definition at line 1486 of file estimate-am-sgmm2.cc.

References SolverOptions::eps, rnnlm::i, SolverOptions::K, KALDI_ERR, KALDI_LOG, KALDI_WARN, AmSgmm2::N_, SolverOptions::name, MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::R_, AmSgmm2::SigmaInv_, kaldi::SolveQuadraticMatrixProblem(), MleAmSgmm2Accs::spk_space_dim_, and MleAmSgmm2Accs::Z_.

                                                  {
   double tot_count = 0.0, tot_like_impr = 0.0;
   if (accs.spk_space_dim_ == 0 || accs.R_.size() == 0 || accs.Z_.size() == 0) {
     KALDI_ERR << "Speaker subspace dim is zero or no stats accumulated";
   }
   SolverOptions opts;
   opts.name = "N";
   opts.K = options_.max_cond;
   opts.eps = options_.epsilon;
 
 
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     if (gamma_i(i) < 2 * accs.spk_space_dim_) {
       KALDI_WARN << "Not updating speaker basis for i = " << (i)
                  << " because count is too small " << (gamma_i(i));
       continue;
     }
     Matrix<double> Ni(model->N_[i]);
     double impr =
         SolveQuadraticMatrixProblem(accs.R_[i], accs.Z_[i],
                                     SpMatrix<double>(model->SigmaInv_[i]),
                                     opts, &Ni);
     model->N_[i].CopyFromMat(Ni);
     if (i < 10) {
       KALDI_LOG << "Objf impr for spk projection N for i = " << (i)
                 << ", is " << (impr / (gamma_i(i) + 1.0e-20)) << " over "
                 << gamma_i(i) << " frames";
     }
     tot_count += gamma_i(i);
     tot_like_impr += impr;
   }
 
   KALDI_LOG << "**Overall objf impr for N is " << (tot_like_impr/tot_count)
             << " over " << tot_count << " frames";
   return (tot_like_impr/tot_count);
 }

◆ UpdatePhoneVectors()

double UpdatePhoneVectors	(	const MleAmSgmm2Accs &	accs,
		const std::vector< SpMatrix< double > > &	H,
		const std::vector< Matrix< double > > &	log_a,
		AmSgmm2 *	model
	)		const

private

In this update, smoothing terms are not supported.

However, it does compute the auxiliary function after doing the update, and backtracks if it did not increase (due to the weight terms, increase is not mathematically guaranteed).

Definition at line 782 of file estimate-am-sgmm2.cc.

References count, MleAmSgmm2Accs::gamma_, KALDI_LOG, MleAmSgmm2Accs::num_groups_, and kaldi::RunMultiThreaded().

                           {
 
   KALDI_LOG << "Updating phone vectors";
 
   double count = 0.0, auxf_impr = 0.0;  // sum over all states
 
   for (int32 j1 = 0; j1 < accs.num_groups_; j1++)
     count += accs.gamma_[j1].Sum();
 
   UpdatePhoneVectorsClass c(*this, accs, H, log_a, model, &auxf_impr);
   RunMultiThreaded(c);
 
   double auxf_per_frame = auxf_impr / (count + 1.0e-20);
 
   KALDI_LOG << "**Overall auxf impr for v is " << auxf_per_frame << " over "
             << count << " frames";
   return auxf_per_frame;
 }

◆ UpdatePhoneVectorsInternal()

void UpdatePhoneVectorsInternal	(	const MleAmSgmm2Accs &	accs,
		const std::vector< SpMatrix< double > > &	H,
		const std::vector< Matrix< double > > &	log_a,
		AmSgmm2 *	model,
		double *	auxf_impr,
		int32	num_threads,
		int32	thread_id
	)		const

private

Definition at line 838 of file estimate-am-sgmm2.cc.

References VectorBase< Real >::Add(), VectorBase< Real >::AddMatVec(), SpMatrix< Real >::AddSp(), VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2(), VectorBase< Real >::ApplyExp(), SolverOptions::eps, MleAmSgmm2Accs::gamma_, rnnlm::i, SolverOptions::K, KALDI_LOG, KALDI_WARN, kaldi::kNoTrans, VectorBase< Real >::LogSumExp(), SolverOptions::name, MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::num_groups_, AmSgmm2::NumSubstatesForGroup(), MleAmSgmm2Accs::phn_space_dim_, MatrixBase< Real >::Row(), kaldi::SolveQuadraticProblem(), AmSgmm2::v_, kaldi::VecSpVec(), kaldi::VecVec(), AmSgmm2::w_, and MleAmSgmm2Accs::y_.

                            {
 
   int32 J1 = accs.num_groups_, block_size = (J1 + (num_threads-1)) / num_threads,
       j1_start = block_size * thread_id,
       j1_end = std::min(accs.num_groups_, j1_start + block_size);
 
   double tot_auxf_impr = 0.0;
 
   for (int32 j1 = j1_start; j1 < j1_end; j1++) {
     for (int32 m = 0; m < model->NumSubstatesForGroup(j1); m++) {
       double gamma_jm = accs.gamma_[j1].Row(m).Sum();
       SpMatrix<double> X_jm(accs.phn_space_dim_);  // = \sum_i \gamma_{jmi} H_i
 
       for (int32 i = 0; i < accs.num_gaussians_; i++) {
         double gamma_jmi = accs.gamma_[j1](m, i);
         if (gamma_jmi != 0.0)
           X_jm.AddSp(gamma_jmi, H[i]);
       }
 
       Vector<double> v_jm_orig(model->v_[j1].Row(m)),
           v_jm(v_jm_orig);
 
       double exact_auxf_start = 0.0, exact_auxf = 0.0, approx_auxf_impr = 0.0;
       int32 backtrack_iter, max_backtrack = 10;
       for (backtrack_iter = 0; backtrack_iter < max_backtrack; backtrack_iter++) {
         // Note: the 1st time we go through this loop we have not yet updated
         // v_jm and it has the old value; the 2nd time, it has the updated value
         // and we will typically break at this point, after verifying that
         // the auxf has improved.
 
         // w_jm = softmax([w_{k1}^T ... w_{kD}^T] * v_{jkm})  eq.(7)
         Vector<double> w_jm(accs.num_gaussians_);
         w_jm.AddMatVec(1.0, Matrix<double>(model->w_), kNoTrans,
                        v_jm, 0.0);
         if (!log_a.empty()) w_jm.AddVec(1.0, log_a[j1].Row(m)); // SSGMM techreport eq. 42
         w_jm.Add(-w_jm.LogSumExp());  // it is now log w_jm
 
 
         exact_auxf = VecVec(w_jm, accs.gamma_[j1].Row(m))
             + VecVec(v_jm, accs.y_[j1].Row(m))
             -0.5 * VecSpVec(v_jm, X_jm, v_jm);
 
         if (backtrack_iter == 0) {
           exact_auxf_start = exact_auxf;
         } else {
           if (exact_auxf >= exact_auxf_start) {
             break;  // terminate backtracking.
           } else {
             KALDI_LOG << "Backtracking computation of v_jm for j = " << j1
                       << " and m = " << m << " because auxf changed by "
                       << (exact_auxf-exact_auxf_start) << " [vs. predicted:] "
                       << approx_auxf_impr;
             v_jm.AddVec(1.0, v_jm_orig);
             v_jm.Scale(0.5);
           }
         }
 
         if (backtrack_iter == 0) {  // computing updated value.
           w_jm.ApplyExp();  // it is now w_jm
           SpMatrix<double> H_jm(X_jm);
           Vector<double> g_jm(accs.y_[j1].Row(m));
           for (int32 i = 0; i < accs.num_gaussians_; i++) {
             double gamma_jmi = accs.gamma_[j1](m, i);
             double quadratic_term = std::max(gamma_jmi, gamma_jm * w_jm(i));
             double scalar = gamma_jmi - gamma_jm * w_jm(i) + quadratic_term
                 * VecVec(model->w_.Row(i), model->v_[j1].Row(m));
             g_jm.AddVec(scalar, model->w_.Row(i));
             if (quadratic_term > 1.0e-10) {
               H_jm.AddVec2(static_cast<BaseFloat>(quadratic_term), model->w_.Row(i));
             }
           }
 
           SolverOptions opts;
           opts.name = "v";
           opts.K = options_.max_cond;
           opts.eps = options_.epsilon;
 
           approx_auxf_impr = SolveQuadraticProblem(H_jm, g_jm, opts, &v_jm);
         }
       }
       double exact_auxf_impr = exact_auxf - exact_auxf_start;
       tot_auxf_impr += exact_auxf_impr;
       if (backtrack_iter == max_backtrack) {
         KALDI_WARN << "Backtracked " << max_backtrack << " times [not updating]";
       } else {
         model->v_[j1].Row(m).CopyFromVec(v_jm);
       }
 
       if (j1 < 3 && m < 3) {
         KALDI_LOG << "Auxf impr for j = " << j1 << " m = " << m << " is "
                   << (exact_auxf_impr/gamma_jm+1.0e-20) << " per frame over "
                   << gamma_jm << " frames.";
       }
     }
   }
   *auxf_impr_ptr = tot_auxf_impr;
 }

◆ UpdateSubstateWeights()

double UpdateSubstateWeights	(	const MleAmSgmm2Accs &	accs,
		AmSgmm2 *	model
	)

private

Definition at line 1682 of file estimate-am-sgmm2.cc.

References VectorBase< Real >::Add(), AmSgmm2::c_, MleAmSgmm2Accs::gamma_c_, KALDI_LOG, KALDI_WARN, kaldi::Log(), MleAmSgmm2Accs::num_pdfs_, AmSgmm2::NumSubstatesForPdf(), and VectorBase< Real >::Sum().

                                                 {
   KALDI_LOG << "Updating substate mixture weights";
   // Also set the vector gamma_j which is a cache of the state occupancies.
 
   double tot_gamma = 0.0, objf_impr = 0.0;
   for (int32 j2 = 0; j2 < accs.num_pdfs_; j2++) {
     double gamma_j_sm = 0.0;
     int32 num_substates = model->NumSubstatesForPdf(j2);
     const Vector<double> &occs(accs.gamma_c_[j2]);
     Vector<double> smoothed_occs(occs);
     smoothed_occs.Add(options_.tau_c);
     gamma_j_sm += smoothed_occs.Sum();
     tot_gamma += occs.Sum();
 
     for (int32 m = 0; m < num_substates; m++) {
       double cur_weight = model->c_[j2](m);
       if (cur_weight <= 0) {
         KALDI_WARN << "Zero or negative weight, flooring";
         cur_weight = 1.0e-10;  // future work(arnab): remove magic numbers
       }
       model->c_[j2](m) = smoothed_occs(m) / gamma_j_sm;
       objf_impr += Log(model->c_[j2](m) / cur_weight) * occs(m);
     }
   }
   KALDI_LOG << "**Overall objf impr for c is " << (objf_impr/tot_gamma)
             << ", over " << tot_gamma << " frames.";
   return (objf_impr/tot_gamma);
 }

◆ UpdateU()

double UpdateU	(	const MleAmSgmm2Accs &	accs,
		const Vector< double > &	gamma_i,
		AmSgmm2 *	model
	)

private

Definition at line 1439 of file estimate-am-sgmm2.cc.

References VectorBase< Real >::AddVec(), SolverOptions::eps, rnnlm::i, SolverOptions::K, KALDI_LOG, KALDI_WARN, SolverOptions::name, MleAmSgmm2Accs::num_gaussians_, MatrixBase< Real >::Row(), VectorBase< Real >::Scale(), kaldi::SolveQuadraticProblem(), MleAmSgmm2Accs::spk_space_dim_, VectorBase< Real >::Sum(), MleAmSgmm2Accs::t_, MleAmSgmm2Accs::U_, and AmSgmm2::u_.

                                                  {
   double tot_impr = 0.0;
   SolverOptions opts;
   opts.name = "u";
   opts.K = options_.max_cond;
   opts.eps = options_.epsilon;
 
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     if (gamma_i(i) < 200.0) {
       KALDI_LOG << "Count is small " << gamma_i(i) << " for gaussian "
                 << i << ", not updating u_i.";
       continue;
     }
     Vector<double> u_i(model->u_.Row(i));
     Vector<double> delta_u(accs.spk_space_dim_);
     double impr =
         SolveQuadraticProblem(accs.U_[i], accs.t_.Row(i), opts, &delta_u);
     double impr_per_frame = impr / gamma_i(i);
     if (impr_per_frame > options_.max_impr_u) {
       KALDI_WARN << "Updating speaker weight projections u, for Gaussian index "
                  << i << ", impr/frame is " << impr_per_frame << " over "
                  << gamma_i(i) << " frames, scaling back to not exceed "
                  << options_.max_impr_u;
       double scale = options_.max_impr_u / impr_per_frame;
       impr *= scale;
       delta_u.Scale(scale);
       // Note: a linear scaling of "impr" with "scale" is not quite accurate
       // in depicting how the quadratic auxiliary function varies as we change
       // the scale on "delta", but this does not really matter-- the goal is
       // to limit the auxiliary-function change to not be too large.
     }
     if (i < 10) {
       KALDI_LOG << "Objf impr for spk weight-projection u for i = " << (i)
                 << ", is " << (impr / (gamma_i(i) + 1.0e-20)) << " over "
                 << gamma_i(i) << " frames";
     }
     u_i.AddVec(1.0, delta_u);
     model->u_.Row(i).CopyFromVec(u_i);
     tot_impr += impr;
   }
   KALDI_LOG << "**Overall objf impr for u is " << (tot_impr/gamma_i.Sum())
             << ", over " << gamma_i.Sum() << " frames";
   return tot_impr / gamma_i.Sum();
 }

◆ UpdateVars()

double UpdateVars	(	const MleAmSgmm2Accs &	accs,
		const std::vector< SpMatrix< double > > &	S_means,
		const Vector< double > &	gamma_i,
		AmSgmm2 *	model
	)

private

Definition at line 1566 of file estimate-am-sgmm2.cc.

References SpMatrix< Real >::AddSp(), VectorBase< Real >::ApplyFloor(), SpMatrix< Real >::CopyFromSp(), rnnlm::d, MleAmSgmm2Accs::feature_dim_, rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, KALDI_VLOG, KALDI_WARN, SpMatrix< Real >::LimitCondDouble(), MleAmSgmm2Accs::num_gaussians_, PackedMatrix< Real >::NumRows(), MleAmSgmm2Accs::S_, PackedMatrix< Real >::Scale(), PackedMatrix< Real >::SetUnit(), AmSgmm2::SigmaInv_, VectorBase< Real >::Sum(), and kaldi::TraceSpSp().

                                                     {
   KALDI_ASSERT(S_means.size() == static_cast<size_t>(accs.num_gaussians_));
 
   SpMatrix<double> Sigma_i(accs.feature_dim_), Sigma_i_ml(accs.feature_dim_);
   double tot_objf_impr = 0.0, tot_t = 0.0;
   SpMatrix<double> covfloor(accs.feature_dim_);
   Vector<double> objf_improv(accs.num_gaussians_);
 
   // First pass over all (shared) Gaussian components to calculate the
   // ML estimate of the covariances, and the total covariance for flooring.
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     // Eq. (75): Sigma_{i}^{ml} = 1/gamma_{i} [S_{i} + S_{i}^{(means)} - ...
     //                                          Y_{i} M_{i}^T - M_{i} Y_{i}^T]
     // Note the S_means already contains the Y_{i} M_{i}^T terms.
     Sigma_i_ml.CopyFromSp(S_means[i]);
     Sigma_i_ml.AddSp(1.0, accs.S_[i]);
 
     covfloor.AddSp(1.0, Sigma_i_ml);
     // inverting  small values e.g. 4.41745328e-40 seems to generate inf,
     // although would be fixed up later.
     if (gamma_i(i) > 1.0e-20) {
       Sigma_i_ml.Scale(1 / (gamma_i(i) + 1.0e-20));
     } else {
       Sigma_i_ml.SetUnit();
     }
     KALDI_ASSERT(1.0 / Sigma_i_ml(0, 0) != 0.0);
     // Eq. (76): Compute the objective function with the old parameter values
     objf_improv(i) = model->SigmaInv_[i].LogPosDefDet() -
         TraceSpSp(SpMatrix<double>(model->SigmaInv_[i]), Sigma_i_ml);
 
     model->SigmaInv_[i].CopyFromSp(Sigma_i_ml);  // inverted in the next loop.
   }
 
   // Compute the covariance floor.
   if (gamma_i.Sum() == 0) {  // If no count, use identity.
     KALDI_WARN << "Updating variances: zero counts. Setting floor to unit.";
     covfloor.SetUnit();
   } else {  // else, use the global average covariance.
     covfloor.Scale(options_.cov_floor / gamma_i.Sum());
     int32 tmp;
     if ((tmp = covfloor.LimitCondDouble(options_.max_cond)) != 0) {
       KALDI_WARN << "Covariance flooring matrix is poorly conditioned. Fixed "
                  << "up " << tmp << " eigenvalues.";
     }
   }
 
   if (options_.cov_diag_ratio > 1000) {
     KALDI_LOG << "Assuming you want to build a diagonal system since "
               << "cov_diag_ratio is large: making diagonal covFloor.";
     for (int32 i = 0; i < covfloor.NumRows(); i++)
       for (int32 j = 0; j < i; j++)
         covfloor(i, j) = 0.0;
   }
 
   // Second pass over all (shared) Gaussian components to calculate the
   // floored estimate of the covariances, and update the model.
   for (int32 i = 0; i < accs.num_gaussians_; i++) {
     Sigma_i.CopyFromSp(model->SigmaInv_[i]);
     Sigma_i_ml.CopyFromSp(Sigma_i);
     // In case of insufficient counts, make the covariance matrix diagonal.
     // cov_diag_ratio is 2 by default, set to very large to always get diag-cov
     if (gamma_i(i) < options_.cov_diag_ratio * accs.feature_dim_) {
       KALDI_WARN << "For Gaussian component " << i << ": Too low count "
                  << gamma_i(i) << " for covariance matrix estimation. Setting to "
                  << "diagonal";
       for (int32 d = 0; d < accs.feature_dim_; d++)
         for (int32 e = 0; e < d; e++)
           Sigma_i(d, e) = 0.0;  // SpMatrix, can only set lower triangular part
 
       int floored = Sigma_i.ApplyFloor(covfloor);
       if (floored > 0) {
         KALDI_WARN << "For Gaussian component " << i << ": Floored " << floored
                    << " covariance eigenvalues.";
       }
       model->SigmaInv_[i].CopyFromSp(Sigma_i);
       model->SigmaInv_[i].InvertDouble();
     } else {  // Updating the full covariance matrix.
       try {
         int floored = Sigma_i.ApplyFloor(covfloor);
         if (floored > 0) {
           KALDI_WARN << "For Gaussian component " << i << ": Floored "
                      << floored << " covariance eigenvalues.";
         }
         model->SigmaInv_[i].CopyFromSp(Sigma_i);
         model->SigmaInv_[i].InvertDouble();
 
         objf_improv(i) += Sigma_i.LogPosDefDet() +
             TraceSpSp(SpMatrix<double>(model->SigmaInv_[i]), Sigma_i_ml);
         objf_improv(i) *= (-0.5 * gamma_i(i));  // Eq. (76)
 
         tot_objf_impr += objf_improv(i);
         tot_t += gamma_i(i);
         if (i < 5) {
           KALDI_VLOG(2) << "objf impr from variance update =" << objf_improv(i)
               / (gamma_i(i) + 1.0e-20) << " over " << (gamma_i(i))
                         << " frames for i = " << (i);
         }
       } catch(...) {
         KALDI_WARN << "Updating within-class covariance matrix i = " << (i)
                    << ", numerical problem";
         // This is a catch-all thing in case of unanticipated errors, but
         // flooring should prevent this occurring for the most part.
         model->SigmaInv_[i].SetUnit();  // Set to unit.
       }
     }
   }
   KALDI_LOG << "**Overall objf impr for variance update = "
             << (tot_objf_impr / (tot_t+ 1.0e-20))
             << " over " << tot_t << " frames";
   return tot_objf_impr / (tot_t + 1.0e-20);
 }

◆ UpdateW()

double UpdateW	(	const MleAmSgmm2Accs &	accs,
		const std::vector< Matrix< double > > &	log_a,
		const Vector< double > &	gamma_i,
		AmSgmm2 *	model
	)

private

Definition at line 1321 of file estimate-am-sgmm2.cc.

References VectorBase< Real >::Add(), MatrixBase< Real >::AddMat(), MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::CopyFromMat(), PackedMatrix< Real >::CopyFromVec(), SolverOptions::eps, MleAmSgmm2Accs::gamma_, rnnlm::i, SolverOptions::K, KALDI_ASSERT, KALDI_LOG, KALDI_VLOG, KALDI_WARN, kaldi::kNoTrans, kaldi::kTrans, VectorBase< Real >::LogSumExp(), SolverOptions::name, MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::num_groups_, AmSgmm2::NumSubstatesForGroup(), MleAmSgmm2Accs::phn_space_dim_, MatrixBase< Real >::Row(), kaldi::RunMultiThreaded(), VectorBase< Real >::Scale(), MatrixBase< Real >::SetZero(), kaldi::SolveQuadraticProblem(), VectorBase< Real >::Sum(), kaldi::TraceMatMat(), AmSgmm2::v_, kaldi::VecSpVec(), kaldi::VecVec(), AmSgmm2::w_, and AmSgmm2::w_jmi_.

                                                   {
   KALDI_LOG << "Updating weight projections";
 
   // tot_like_{after, before} are totals over multiple iterations,
   // not valid likelihoods. but difference is valid (when divided by tot_count).
   double tot_predicted_like_impr = 0.0, tot_like_before = 0.0,
       tot_like_after = 0.0;
 
   Matrix<double> g_i(accs.num_gaussians_, accs.phn_space_dim_);
   // View F_i as a vector of SpMatrix.
   Matrix<double> F_i(accs.num_gaussians_,
                      (accs.phn_space_dim_*(accs.phn_space_dim_+1))/2);
 
   Matrix<double> w(model->w_);
   double tot_count = gamma_i.Sum();
 
   for (int iter = 0; iter < options_.weight_projections_iters; iter++) {
     F_i.SetZero();
     g_i.SetZero();
     double k_like_before = 0.0;
 
     UpdateWClass c(accs, *model, w, log_a, &F_i, &g_i, &k_like_before);
     RunMultiThreaded(c);
 
     Matrix<double> w_orig(w);
     double k_predicted_like_impr = 0.0, k_like_after = 0.0;
     double min_step = 0.001, step_size;
 
     SolverOptions opts;
     opts.name = "w";
     opts.K = options_.max_cond;
     opts.eps = options_.epsilon;
 
     for (step_size = 1.0; step_size >= min_step; step_size /= 2) {
       k_predicted_like_impr = 0.0;
       k_like_after = 0.0;
 
       for (int32 i = 0; i < accs.num_gaussians_; i++) {
         // auxf is formulated in terms of change in w.
         Vector<double> delta_w(accs.phn_space_dim_);
         // returns objf impr with step_size = 1,
         // but it may not be 1 so we recalculate it.
         SpMatrix<double> this_F_i(accs.phn_space_dim_);
         this_F_i.CopyFromVec(F_i.Row(i));
         SolveQuadraticProblem(this_F_i, g_i.Row(i), opts, &delta_w);
 
         delta_w.Scale(step_size);
         double predicted_impr = VecVec(delta_w, g_i.Row(i)) -
             0.5 * VecSpVec(delta_w,  this_F_i, delta_w);
 
         // should never be negative because
         // we checked inside SolveQuadraticProblem.
         KALDI_ASSERT(predicted_impr >= -1.0e-05);
 
         if (i < 10)
           KALDI_LOG << "Predicted objf impr for w, iter = " << iter
                     << ", i = " << i << " is "
                     << (predicted_impr/gamma_i(i)+1.0e-20)
                     << " per frame over " << gamma_i(i) << " frames.";
         k_predicted_like_impr += predicted_impr;
         w.Row(i).AddVec(1.0, delta_w);
       }
       for (int32 j1 = 0; j1 < accs.num_groups_; j1++) {
         int32 M = model->NumSubstatesForGroup(j1);
         Matrix<double> w_j(M, accs.num_gaussians_);
         w_j.AddMatMat(1.0, Matrix<double>(model->v_[j1]), kNoTrans,
                        w, kTrans, 0.0);
         if (!log_a.empty()) w_j.AddMat(1.0, log_a[j1]); // SSGMM techreport eq. 42
         for (int32 m = 0; m < M; m++) {
           SubVector<double> w_jm(w_j, m);
           w_jm.Add(-1.0 * w_jm.LogSumExp());
         }
         k_like_after += TraceMatMat(w_j, accs.gamma_[j1], kTrans);
       }
       KALDI_VLOG(2) << "For iteration " << iter << ", updating w gives "
                     << "predicted per-frame like impr "
                     << (k_predicted_like_impr / tot_count) << ", actual "
                     << ((k_like_after - k_like_before) / tot_count) << ", over "
                     << tot_count << " frames";
       if (k_like_after < k_like_before) {
         w.CopyFromMat(w_orig);  // Undo what we computed.
         if (fabs(k_like_after - k_like_before) / tot_count < 1.0e-05) {
           k_like_after = k_like_before;
           KALDI_WARN << "Not updating weights as not increasing auxf and "
                      << "probably due to numerical issues (since small change).";
           break;
         } else {
           KALDI_WARN << "Halving step size for weights as likelihood did "
                      << "not increase";
         }
       } else {
         break;
       }
     }
     if (step_size < min_step) {
       // Undo any step as we have no confidence that this is right.
       w.CopyFromMat(w_orig);
     } else {
       tot_predicted_like_impr += k_predicted_like_impr;
       tot_like_after += k_like_after;
       tot_like_before += k_like_before;
     }
   }
 
   model->w_.CopyFromMat(w);
   model->w_jmi_.clear(); // invalidated.
 
   tot_predicted_like_impr /= tot_count;
   tot_like_after = (tot_like_after - tot_like_before) / tot_count;
   KALDI_LOG << "**Overall objf impr for w is " << tot_predicted_like_impr
             << ", actual " << tot_like_after << ", over "
             << tot_count << " frames";
   return tot_like_after;
 }

◆ UpdateWGetStats()

void UpdateWGetStats	(	const MleAmSgmm2Accs &	accs,
		const AmSgmm2 &	model,
		const Matrix< double > &	w,
		const std::vector< Matrix< double > > &	log_a,
		Matrix< double > *	F_i,
		Matrix< double > *	g_i,
		double *	tot_like,
		int32	num_threads,
		int32	thread_id
	)

staticprivate

Called, multithreaded, inside UpdateW.

This function gets stats used inside UpdateW, where it accumulates the F_i and g_i quantities.

Note: F_i is viewed as a vector of SpMatrix (one for each i); each row of F_i is viewed as an SpMatrix even though it's stored as a vector.... Note: on the first iteration w is just a double-precision copy of the matrix model->w_; thereafter it may differ. log_a relates to the SSGMM.

Definition at line 1258 of file estimate-am-sgmm2.cc.

References VectorBase< Real >::Add(), MatrixBase< Real >::AddMat(), MatrixBase< Real >::AddMatMat(), SpMatrix< Real >::AddVec2(), VectorBase< Real >::ApplyExp(), MleAmSgmm2Accs::gamma_, rnnlm::i, kaldi::kNoTrans, kaldi::kTrans, VectorBase< Real >::LogSumExp(), MleAmSgmm2Accs::num_gaussians_, MleAmSgmm2Accs::num_groups_, AmSgmm2::NumSubstatesForGroup(), MleAmSgmm2Accs::phn_space_dim_, MatrixBase< Real >::Row(), PackedMatrix< Real >::SetZero(), AmSgmm2::v_, and kaldi::VecVec().

Referenced by UpdateWClass::operator()().

                                                          {
 
   // Accumulate stats from a block of states (this gets called in parallel).
   int32 block_size = (accs.num_groups_ + (num_threads-1)) / num_threads,
       j1_start = block_size * thread_id,
       j1_end = std::min(accs.num_groups_, j1_start + block_size);
 
   // Unlike in the report the inner most loop is over Gaussians, where
   // per-gaussian statistics are accumulated. This is more memory demanding
   // but more computationally efficient, as outer product v_{jvm} v_{jvm}^T
   // is computed only once for all gaussians.
 
   SpMatrix<double> v_vT(accs.phn_space_dim_);
 
   for (int32 j1 = j1_start; j1 < j1_end; j1++) {
     int32 num_substates = model.NumSubstatesForGroup(j1);
     Matrix<double> w_j(num_substates, accs.num_gaussians_);
     // The linear term and quadratic term for each Gaussian-- two scalars
     // for each Gaussian, they appear in the accumulation formulas.
     Matrix<double> linear_term(num_substates, accs.num_gaussians_);
     Matrix<double> quadratic_term(num_substates, accs.num_gaussians_);
     Matrix<double> v_vT_m(num_substates,
                           (accs.phn_space_dim_*(accs.phn_space_dim_+1))/2);
 
     // w_jm = softmax([w_{k1}^T ... w_{kD}^T] * v_{jkm})  eq.(7)
     Matrix<double> v_j_double(model.v_[j1]);
     w_j.AddMatMat(1.0, v_j_double, kNoTrans, w, kTrans, 0.0);
     if (!log_a.empty()) w_j.AddMat(1.0, log_a[j1]); // SSGMM techreport eq. 42
 
     for (int32 m = 0; m < model.NumSubstatesForGroup(j1); m++) {
       SubVector<double> w_jm(w_j, m);
       double gamma_jm = accs.gamma_[j1].Row(m).Sum();
       w_jm.Add(-1.0 * w_jm.LogSumExp());
       *tot_like += VecVec(w_jm, accs.gamma_[j1].Row(m));
       w_jm.ApplyExp();
       v_vT.SetZero();
       // v_vT := v_{jkm} v_{jkm}^T
       v_vT.AddVec2(static_cast<BaseFloat>(1.0), v_j_double.Row(m));
       v_vT_m.Row(m).CopyFromPacked(v_vT); // a bit wasteful, but does not dominate.
 
       for (int32 i = 0; i < accs.num_gaussians_; i++) {
         // Suggestion: g_jkm can be computed more efficiently
         // using the Vector/Matrix routines for all i at once
         // linear term around cur value.
         linear_term(m, i) = accs.gamma_[j1](m, i) - gamma_jm * w_jm(i);
         quadratic_term(m, i) = std::max(accs.gamma_[j1](m, i),
                                         gamma_jm * w_jm(i));
       }
     } // loop over substates
     g_i->AddMatMat(1.0, linear_term, kTrans, v_j_double, kNoTrans, 1.0);
     F_i->AddMatMat(1.0, quadratic_term, kTrans, v_vT_m, kNoTrans, 1.0);
   } // loop over states
 }

Friends And Related Function Documentation

◆ EbwAmSgmm2Updater

friend class EbwAmSgmm2Updater

friend

Definition at line 272 of file estimate-am-sgmm2.h.

◆ EbwEstimateAmSgmm2

friend class EbwEstimateAmSgmm2

friend

Definition at line 261 of file estimate-am-sgmm2.h.

◆ UpdatePhoneVectorsClass

friend class UpdatePhoneVectorsClass

friend

Definition at line 260 of file estimate-am-sgmm2.h.

◆ UpdateWClass

friend class UpdateWClass

friend

Definition at line 259 of file estimate-am-sgmm2.h.

Member Data Documentation

◆ options_

MleAmSgmm2Options options_

private

Definition at line 274 of file estimate-am-sgmm2.h.

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

sgmm2/estimate-am-sgmm2.h
sgmm2/estimate-am-sgmm2.cc

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ MleAmSgmm2Updater() [1/2]

◆ MleAmSgmm2Updater() [2/2]

Member Function Documentation

◆ ComputeLogA()

◆ ComputeMPrior()

◆ ComputeQ()

◆ ComputeSMeans()

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

◆ MapUpdateM()

◆ Reconfigure()

◆ RenormalizeN()

◆ RenormalizeV()

◆ Update()

◆ UpdateM()

◆ UpdateN()

◆ UpdatePhoneVectors()

◆ UpdatePhoneVectorsInternal()

◆ UpdateSubstateWeights()

◆ UpdateU()

◆ UpdateVars()

◆ UpdateW()

◆ UpdateWGetStats()

Friends And Related Function Documentation

◆ EbwAmSgmm2Updater

◆ EbwEstimateAmSgmm2

◆ UpdatePhoneVectorsClass

◆ UpdateWClass

Member Data Documentation

◆ options_