RegtreeFmllrDiagGmmAccs Class Reference

Class for computing the accumulators needed for the maximum-likelihood estimate of FMLLR transforms for an acoustic model that uses diagonal Gaussian mixture models as emission densities. More...

#include <regtree-fmllr-diag-gmm.h>

Collaboration diagram for RegtreeFmllrDiagGmmAccs:

Public Member Functions
	RegtreeFmllrDiagGmmAccs ()
	~RegtreeFmllrDiagGmmAccs ()
void	Init (size_t num_bclass, size_t dim)
void	SetZero ()
BaseFloat	AccumulateForGmm (const RegressionTree &regtree, const AmDiagGmm &am, const VectorBase< BaseFloat > &data, size_t pdf_index, BaseFloat weight)
	Accumulate stats for a single GMM in the model; returns log likelihood. More...
void	AccumulateForGaussian (const RegressionTree &regtree, const AmDiagGmm &am, const VectorBase< BaseFloat > &data, size_t pdf_index, size_t gauss_index, BaseFloat weight)
	Accumulate stats for a single Gaussian component in the model. More...
void	Update (const RegressionTree &regtree, const RegtreeFmllrOptions &opts, RegtreeFmllrDiagGmm *out_fmllr, BaseFloat *auxf_impr, BaseFloat *tot_t) const
void	Write (std::ostream &out_stream, bool binary) const
void	Read (std::istream &in_stream, bool binary, bool add)
int32	Dim () const
	Accessors. More...
int32	NumBaseClasses () const
const std::vector< AffineXformStats * > &	baseclass_stats () const

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (RegtreeFmllrDiagGmmAccs)

Private Attributes
std::vector< AffineXformStats * >	baseclass_stats_
	Per-baseclass stats; used for accumulation. More...
int32	num_baseclasses_
	Number of baseclasses. More...
int32	dim_
	Dimension of feature vectors. More...

Detailed Description

Class for computing the accumulators needed for the maximum-likelihood estimate of FMLLR transforms for an acoustic model that uses diagonal Gaussian mixture models as emission densities.

Definition at line 148 of file regtree-fmllr-diag-gmm.h.

Constructor & Destructor Documentation

RegtreeFmllrDiagGmmAccs()

RegtreeFmllrDiagGmmAccs ( )

inline

Definition at line 150 of file regtree-fmllr-diag-gmm.h.

: num_baseclasses_(-1), dim_(-1) {}

~RegtreeFmllrDiagGmmAccs()

~RegtreeFmllrDiagGmmAccs ( )

inline

Definition at line 151 of file regtree-fmllr-diag-gmm.h.

References kaldi::DeletePointers().

{ DeletePointers(&baseclass_stats_); }

Member Function Documentation

AccumulateForGaussian()

void AccumulateForGaussian	(	const RegressionTree &	regtree,
		const AmDiagGmm &	am,
		const VectorBase< BaseFloat > &	data,
		size_t	pdf_index,
		size_t	gauss_index,
		BaseFloat	weight
	)

Accumulate stats for a single Gaussian component in the model.

Definition at line 261 of file regtree-fmllr-diag-gmm.cc.

References SpMatrix< Real >::AddVec2(), VectorBase< Real >::CopyRowFromMat(), rnnlm::d, RegtreeFmllrDiagGmm::dim_, RegressionTree::Gauss2BaseclassId(), AmDiagGmm::GetPdf(), DiagGmm::inv_vars(), DiagGmm::means_invvars(), and VectorBase< Real >::Range().

                      {
  const DiagGmm &pdf = am.GetPdf(pdf_index);
  size_t dim = static_cast<size_t>(dim_);
  Vector<double> extended_data(dim+1);
  extended_data.Range(0, dim).CopyFromVec(data);
  extended_data(dim) = 1.0;
  SpMatrix<double> scatter(dim+1);
  scatter.AddVec2(1.0, extended_data);
  double weight_d = static_cast<double>(weight);

  unsigned bclass = regtree.Gauss2BaseclassId(pdf_index, gauss_index);
  Vector<double> inv_var_mean(dim_);
  inv_var_mean.CopyRowFromMat(pdf.means_invvars(), gauss_index);

  baseclass_stats_[bclass]->beta_ += weight_d;
  baseclass_stats_[bclass]->K_.AddVecVec(weight_d, inv_var_mean, extended_data);
  vector< SpMatrix<double> > &G = baseclass_stats_[bclass]->G_;
  for (size_t d = 0; d < dim; d++)
    G[d].AddSp((weight_d * pdf.inv_vars()(gauss_index, d)), scatter);
}

AccumulateForGmm()

BaseFloat AccumulateForGmm	(	const RegressionTree &	regtree,
		const AmDiagGmm &	am,
		const VectorBase< BaseFloat > &	data,
		size_t	pdf_index,
		BaseFloat	weight
	)

Accumulate stats for a single GMM in the model; returns log likelihood.

This does not work if the features have already been transformed with multiple feature transforms (so you can't use use this to do a 2nd pass of regression-tree fMLLR estimation, which as I write (Dan, 2016) I'm not sure that this framework even supports.

Definition at line 224 of file regtree-fmllr-diag-gmm.cc.

References MatrixBase< Real >::AddSp(), SpMatrix< Real >::AddVec2(), DiagGmm::ComponentPosteriors(), VectorBase< Real >::CopyRowFromMat(), rnnlm::d, RegtreeFmllrDiagGmm::dim_, RegressionTree::Gauss2BaseclassId(), AmDiagGmm::GetPdf(), DiagGmm::inv_vars(), DiagGmm::means_invvars(), DiagGmm::NumGauss(), VectorBase< Real >::Range(), and VectorBase< Real >::Scale().

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

                                                                           {
  const DiagGmm &pdf = am.GetPdf(pdf_index);
  int32 num_comp = pdf.NumGauss();
  Vector<BaseFloat> posterior(num_comp);
  BaseFloat loglike = pdf.ComponentPosteriors(data, &posterior);
  posterior.Scale(weight);
  Vector<double> posterior_d(posterior);

  Vector<double> extended_data(dim_+1);
  extended_data.Range(0, dim_).CopyFromVec(data);
  extended_data(dim_) = 1.0;
  SpMatrix<double> scatter(dim_+1);
  scatter.AddVec2(1.0, extended_data);

  Vector<double> inv_var_mean(dim_);
  Matrix<double> g_scale(baseclass_stats_.size(), dim_);  // scale on "scatter" for each dim.
  for (int32 m = 0; m < num_comp; m++) {
    inv_var_mean.CopyRowFromMat(pdf.means_invvars(), m);
    int32 bclass = regtree.Gauss2BaseclassId(pdf_index, m);

    baseclass_stats_[bclass]->beta_ += posterior_d(m);
    baseclass_stats_[bclass]->K_.AddVecVec(posterior_d(m), inv_var_mean,
                                           extended_data);
    for (int32 d = 0; d < dim_; d++)
      g_scale(bclass, d) +=  posterior(m) * pdf.inv_vars()(m, d);
  }
  for (size_t bclass = 0; bclass < baseclass_stats_.size(); bclass++) {
    vector< SpMatrix<double> > &G = baseclass_stats_[bclass]->G_;
    for (int32 d = 0; d < dim_; d++)
      if (g_scale(bclass, d) != 0.0)
        G[d].AddSp(g_scale(bclass, d), scatter);
  }
  return loglike;
}

baseclass_stats()

const std::vector<AffineXformStats*>& baseclass_stats ( ) const

inline

Definition at line 183 of file regtree-fmllr-diag-gmm.h.

                                                              {
    return baseclass_stats_;
  }

Dim()

int32 Dim ( ) const

inline

Accessors.

Definition at line 181 of file regtree-fmllr-diag-gmm.h.

{ return dim_; }

Init()

void Init	(	size_t	num_bclass,
		size_t	dim
	)

Definition at line 197 of file regtree-fmllr-diag-gmm.cc.

References kaldi::DeletePointers(), RegtreeFmllrDiagGmm::dim_, and KALDI_ASSERT.

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

                                                                {
  if (num_bclass == 0) {  // empty stats
    DeletePointers(&baseclass_stats_);
    baseclass_stats_.clear();
    num_baseclasses_ = 0;
    dim_ = 0;  // non-zero dimension is meaningless in empty stats
  } else {
    KALDI_ASSERT(dim != 0);  // if not empty, dim = 0 is meaningless
    num_baseclasses_ = num_bclass;
    dim_ = dim;
    DeletePointers(&baseclass_stats_);
    baseclass_stats_.resize(num_bclass);
    for (vector<AffineXformStats*>::iterator it = baseclass_stats_.begin(),
             end = baseclass_stats_.end(); it != end; ++it) {
      *it = new AffineXformStats();
      (*it)->Init(dim, dim);
    }
  }
}

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( RegtreeFmllrDiagGmmAccs  )

private

NumBaseClasses()

int32 NumBaseClasses ( ) const

inline

Definition at line 182 of file regtree-fmllr-diag-gmm.h.

{ return num_baseclasses_; }

Read()

void Read	(	std::istream &	in_stream,
		bool	binary,
		bool	add
	)

Definition at line 299 of file regtree-fmllr-diag-gmm.cc.

References RegtreeFmllrDiagGmm::dim_, kaldi::ExpectToken(), KALDI_ASSERT, and kaldi::ReadBasicType().

                                                                        {
  ExpectToken(in, binary, "<FMLLRACCS>");
  ExpectToken(in, binary, "<NUMBASECLASSES>");
  ReadBasicType(in, binary, &num_baseclasses_);
  ExpectToken(in, binary, "<DIMENSION>");
  ReadBasicType(in, binary, &dim_);
  KALDI_ASSERT(num_baseclasses_ > 0 && dim_ > 0);
  baseclass_stats_.resize(num_baseclasses_);
  ExpectToken(in, binary, "<STATS>");
  vector<AffineXformStats*>::iterator itr = baseclass_stats_.begin(),
      end = baseclass_stats_.end();
  for ( ; itr != end; ++itr) {
    *itr = new AffineXformStats();
    (*itr)->Init(dim_, dim_);
    (*itr)->Read(in, binary, add);
  }
  ExpectToken(in, binary, "</FMLLRACCS>");
}

SetZero()

void SetZero

(

)

Definition at line 217 of file regtree-fmllr-diag-gmm.cc.

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

                                      {
  for (vector<AffineXformStats*>::iterator it = baseclass_stats_.begin(),
           end = baseclass_stats_.end(); it != end; ++it) {
    (*it)->SetZero();
  }
}

Update()

void Update	(	const RegressionTree &	regtree,
		const RegtreeFmllrOptions &	opts,
		RegtreeFmllrDiagGmm *	out_fmllr,
		BaseFloat *	auxf_impr,
		BaseFloat *	tot_t
	)		const

Definition at line 319 of file regtree-fmllr-diag-gmm.cc.

References kaldi::ComputeFmllrMatrixDiagGmmDiagonal(), kaldi::ComputeFmllrMatrixDiagGmmFull(), kaldi::ComputeFmllrMatrixDiagGmmOffset(), kaldi::DeletePointers(), RegtreeFmllrDiagGmm::dim_, RegressionTree::GatherStats(), RegtreeFmllrDiagGmm::Init(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, KALDI_WARN, RegtreeFmllrOptions::min_count, RegtreeFmllrOptions::num_iters, RegtreeFmllrDiagGmm::set_bclass2xforms(), RegtreeFmllrDiagGmm::SetParameters(), MatrixBase< Real >::SetUnit(), RegtreeFmllrOptions::update_type, and RegtreeFmllrOptions::use_regtree.

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

                                                          {
  BaseFloat tot_auxf_impr = 0.0, tot_t = 0.0;
  Matrix<BaseFloat> xform_mat(dim_, dim_+1);
  if (opts.use_regtree) {  // estimate transforms using a regression tree
    vector<AffineXformStats*> regclass_stats;
    vector<int32> base2regclass;
    bool update_xforms = regtree.GatherStats(baseclass_stats_, opts.min_count,
                                             &base2regclass, &regclass_stats);
    out_fmllr->set_bclass2xforms(base2regclass);
    // If update_xforms == true, none should be negative, else all should be -1
    if (update_xforms) {
      out_fmllr->Init(regclass_stats.size(), dim_);
      size_t num_rclass = regclass_stats.size();
      for (size_t rclass_index = 0;
           rclass_index < num_rclass; ++rclass_index) {
        KALDI_ASSERT(regclass_stats[rclass_index]->beta_ >= opts.min_count);
        xform_mat.SetUnit();
        tot_t += regclass_stats[rclass_index]->beta_;

        tot_auxf_impr +=
            ComputeFmllrMatrixDiagGmmFull(xform_mat, *(regclass_stats[rclass_index]),
                                          opts.num_iters, &xform_mat);
        
        out_fmllr->SetParameters(xform_mat, rclass_index);
      }
      KALDI_LOG << "Estimated " << num_rclass << " regression classes.";
    } else {
      out_fmllr->Init(1, dim_);  // Use a unit transform at the root.
    }
    DeletePointers(&regclass_stats);
    // end of estimation using regression tree
  } else {  // No regtree: estimate 1 transform per baseclass (if enough count)
    for (int32 bclass_index = 0; bclass_index < num_baseclasses_;
         ++bclass_index) {
      tot_t += baseclass_stats_[bclass_index]->beta_;
    }

    out_fmllr->Init(num_baseclasses_, dim_);
    vector<int32> base2regclass(num_baseclasses_);
    for (int32 bclass_index = 0; bclass_index < num_baseclasses_;
         ++bclass_index) {
      if (baseclass_stats_[bclass_index]->beta_ >= opts.min_count) {
        xform_mat.SetUnit();

        if (opts.update_type == "full") {
          tot_auxf_impr +=
              ComputeFmllrMatrixDiagGmmFull(xform_mat,
                                            *(baseclass_stats_[bclass_index]),
                                            opts.num_iters, &xform_mat);
        } else if (opts.update_type == "diag")
          tot_auxf_impr +=
              ComputeFmllrMatrixDiagGmmDiagonal(xform_mat,
                                                *(baseclass_stats_[bclass_index]),
                                                &xform_mat);
        else if (opts.update_type == "offset")
          tot_auxf_impr +=
              ComputeFmllrMatrixDiagGmmOffset(xform_mat,
                                              *(baseclass_stats_[bclass_index]),
                                              &xform_mat);
        else if (opts.update_type == "none")
          tot_auxf_impr = 0.0;
        else
          KALDI_ERR << "Unknown fMLLR update type " << opts.update_type
                    << ", fmllr-update-type must be one of \"full\"|\"diag\"|\"offset\"|\"none\"";

        out_fmllr->SetParameters(xform_mat, bclass_index);
        base2regclass[bclass_index] = bclass_index;
      } else {
        KALDI_WARN << "For baseclass " << (bclass_index) << " count = "
                   << (baseclass_stats_[bclass_index]->beta_) << " < "
                   << opts.min_count << ": not updating FMLLR";
        base2regclass[bclass_index] = -1;
      }
      out_fmllr->set_bclass2xforms(base2regclass);
    }  // end looping over all baseclasses
  }  // end of estimating one transform per baseclass without regtree
  if (auxf_impr_out) *auxf_impr_out = tot_auxf_impr;
  if (tot_t_out) *tot_t_out = tot_t;
}

Write()

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

Definition at line 285 of file regtree-fmllr-diag-gmm.cc.

References RegtreeFmllrDiagGmm::dim_, kaldi::WriteBasicType(), and kaldi::WriteToken().

                                                                      {
  WriteToken(out, binary, "<FMLLRACCS>");
  WriteToken(out, binary, "<NUMBASECLASSES>");
  WriteBasicType(out, binary, num_baseclasses_);
  WriteToken(out, binary, "<DIMENSION>");
  WriteBasicType(out, binary, dim_);
  WriteToken(out, binary, "<STATS>");
  vector<AffineXformStats*>::const_iterator itr = baseclass_stats_.begin(),
      end = baseclass_stats_.end();
  for ( ; itr != end; ++itr)
    (*itr)->Write(out, binary);
  WriteToken(out, binary, "</FMLLRACCS>");
}

Member Data Documentation

baseclass_stats_

std::vector<AffineXformStats*> baseclass_stats_

private

Per-baseclass stats; used for accumulation.

Definition at line 189 of file regtree-fmllr-diag-gmm.h.

dim_

int32 dim_

private

Dimension of feature vectors.

Definition at line 193 of file regtree-fmllr-diag-gmm.h.

num_baseclasses_

int32 num_baseclasses_

private

Number of baseclasses.

Definition at line 191 of file regtree-fmllr-diag-gmm.h.

---

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

• transform/regtree-fmllr-diag-gmm.h
• transform/regtree-fmllr-diag-gmm.cc