OnlineIvectorEstimationStats Class Reference

This class helps us to efficiently estimate iVectors in situations where the data is coming in frame by frame. More...

#include <ivector-extractor.h>

Collaboration diagram for OnlineIvectorEstimationStats:

Public Member Functions
	OnlineIvectorEstimationStats (int32 ivector_dim, BaseFloat prior_offset, BaseFloat max_count)
	OnlineIvectorEstimationStats (const OnlineIvectorEstimationStats &other)
void	AccStats (const IvectorExtractor &extractor, const VectorBase< BaseFloat > &feature, const std::vector< std::pair< int32, BaseFloat > > &gauss_post)
void	AccStats (const IvectorExtractor &extractor, const MatrixBase< BaseFloat > &features, const std::vector< std::vector< std::pair< int32, BaseFloat > > > &gauss_post)
int32	IvectorDim () const
void	GetIvector (int32 num_cg_iters, VectorBase< double > *ivector) const
	This function gets the current estimate of the iVector. More...
double	NumFrames () const
double	PriorOffset () const
double	ObjfChange (const VectorBase< double > &ivector) const
	ObjfChange returns the change in objective function *per frame* from using the default value [ prior_offset_, 0, 0, ... More...
double	Count () const
void	Scale (double scale)
	Scales the number of frames of stats by 0 <= scale <= 1, to make it as if we had fewer frames of adaptation data. More...
void	Write (std::ostream &os, bool binary) const
void	Read (std::istream &is, bool binary)
OnlineIvectorEstimationStats &	operator= (const OnlineIvectorEstimationStats &other)

Protected Member Functions
double	Objf (const VectorBase< double > &ivector) const
	Returns objective function per frame, at this iVector value. More...
double	DefaultObjf () const
	Returns objective function evaluated at the point [ prior_offset_, 0, 0, 0, ... More...

Protected Attributes
double	prior_offset_
double	max_count_
double	num_frames_
SpMatrix< double >	quadratic_term_
Vector< double >	linear_term_

Friends
class	IvectorExtractor

Detailed Description

This class helps us to efficiently estimate iVectors in situations where the data is coming in frame by frame.

Definition at line 314 of file ivector-extractor.h.

Constructor & Destructor Documentation

OnlineIvectorEstimationStats() [1/2]

OnlineIvectorEstimationStats	(	int32	ivector_dim,
		BaseFloat	prior_offset,
		BaseFloat	max_count
	)

Definition at line 786 of file ivector-extractor.cc.

References PackedMatrix< Real >::AddToDiag(), OnlineIvectorEstimationStats::linear_term_, and OnlineIvectorEstimationStats::quadratic_term_.

                                                                               :
    prior_offset_(prior_offset), max_count_(max_count), num_frames_(0.0),
    quadratic_term_(ivector_dim), linear_term_(ivector_dim) {
  if (ivector_dim != 0) {
    linear_term_(0) += prior_offset;
    quadratic_term_.AddToDiag(1.0);
  }
}

OnlineIvectorEstimationStats() [2/2]

OnlineIvectorEstimationStats

(

const OnlineIvectorEstimationStats &

other

)

Definition at line 797 of file ivector-extractor.cc.

                                              :
    prior_offset_(other.prior_offset_),
    max_count_(other.max_count_),
    num_frames_(other.num_frames_),
    quadratic_term_(other.quadratic_term_),
    linear_term_(other.linear_term_) { }

Member Function Documentation

AccStats() [1/2]

void AccStats	(	const IvectorExtractor &	extractor,
		const VectorBase< BaseFloat > &	feature,
		const std::vector< std::pair< int32, BaseFloat > > &	gauss_post
	)

Definition at line 537 of file ivector-extractor.cc.

References VectorBase< Real >::AddMatVec(), IvectorExtractor::IvectorDependentWeights(), IvectorExtractor::IvectorDim(), KALDI_ASSERT, kaldi::kTrans, IvectorExtractor::prior_offset_, IvectorExtractor::Sigma_inv_M_, and IvectorExtractor::U_.

Referenced by kaldi::TestIvectorExtraction().

                                                             {
  KALDI_ASSERT(extractor.IvectorDim() == this->IvectorDim());
  KALDI_ASSERT(!extractor.IvectorDependentWeights());

  Vector<double> feature_dbl(feature);
  double tot_weight = 0.0;
  int32 ivector_dim = this->IvectorDim(),
      quadratic_term_dim = (ivector_dim * (ivector_dim + 1)) / 2;
  SubVector<double> quadratic_term_vec(quadratic_term_.Data(),
                                       quadratic_term_dim);

  for (size_t idx = 0; idx < gauss_post.size(); idx++) {
    int32 g = gauss_post[idx].first;
    double weight = gauss_post[idx].second;
    // allow negative weights; it's needed in the online iVector extraction
    // with speech-silence detection based on decoder traceback (we subtract
    // stuff we previously added if the traceback changes).
    if (weight == 0.0)
      continue;
    linear_term_.AddMatVec(weight, extractor.Sigma_inv_M_[g], kTrans,
                           feature_dbl, 1.0);
    SubVector<double> U_g(extractor.U_, g);
    quadratic_term_vec.AddVec(weight, U_g);
    tot_weight += weight;
  }
  if (max_count_ > 0.0) {
    // see comments in header RE max_count for explanation.  It relates to
    // prior scaling when the count exceeds max_count_
    double old_num_frames = num_frames_,
        new_num_frames = num_frames_ + tot_weight;
    double old_prior_scale = std::max(old_num_frames, max_count_) / max_count_,
        new_prior_scale = std::max(new_num_frames, max_count_) / max_count_;
    // The prior_scales are the inverses of the scales we would put on the stats
    // if we were implementing this by scaling the stats.  Instead we
    // scale the prior term.
    double prior_scale_change = new_prior_scale - old_prior_scale;
    if (prior_scale_change != 0.0) {
      linear_term_(0) += prior_offset_ * prior_scale_change;
      quadratic_term_.AddToDiag(prior_scale_change);
    }
  }
  num_frames_ += tot_weight;
}

AccStats() [2/2]

void AccStats	(	const IvectorExtractor &	extractor,
		const MatrixBase< BaseFloat > &	features,
		const std::vector< std::vector< std::pair< int32, BaseFloat > > > &	gauss_post
	)

Definition at line 611 of file ivector-extractor.cc.

References VectorBase< Real >::AddVec(), kaldi::ConvertPostToGaussInfo(), GaussInfo::frame_weights, IvectorExtractor::IvectorDependentWeights(), IvectorExtractor::IvectorDim(), KALDI_ASSERT, kaldi::kTrans, kaldi::kUndefined, MatrixBase< Real >::NumCols(), IvectorExtractor::prior_offset_, MatrixBase< Real >::Row(), VectorBase< Real >::SetZero(), IvectorExtractor::Sigma_inv_M_, GaussInfo::tot_weight, and IvectorExtractor::U_.

                                                                         {
  KALDI_ASSERT(extractor.IvectorDim() == this->IvectorDim());
  KALDI_ASSERT(!extractor.IvectorDependentWeights());

  int32 feat_dim = features.NumCols();
  std::unordered_map<int32, GaussInfo> gauss_info;
  ConvertPostToGaussInfo(gauss_post, &gauss_info);

  Vector<double> weighted_feats(feat_dim, kUndefined);
  double tot_weight = 0.0;
  int32 ivector_dim = this->IvectorDim(),
      quadratic_term_dim = (ivector_dim * (ivector_dim + 1)) / 2;
  SubVector<double> quadratic_term_vec(quadratic_term_.Data(),
                                       quadratic_term_dim);

  std::unordered_map<int32, GaussInfo>::const_iterator
      iter = gauss_info.begin(), end = gauss_info.end();
  for (; iter != end; ++iter) {
    int32 gauss_idx = iter->first;
    const GaussInfo &info = iter->second;

    weighted_feats.SetZero();
    std::vector<std::pair<int32, BaseFloat> >::const_iterator
        f_iter = info.frame_weights.begin(), f_end = info.frame_weights.end();
    for (; f_iter != f_end; ++f_iter) {
      int32 t = f_iter->first;
      BaseFloat weight = f_iter->second;
      weighted_feats.AddVec(weight, features.Row(t));
    }
    BaseFloat this_tot_weight = info.tot_weight;

    linear_term_.AddMatVec(1.0, extractor.Sigma_inv_M_[gauss_idx], kTrans,
                           weighted_feats, 1.0);
    SubVector<double> U_g(extractor.U_, gauss_idx);
    quadratic_term_vec.AddVec(this_tot_weight, U_g);
    tot_weight += this_tot_weight;
  }
  if (max_count_ > 0.0) {
    // see comments in header RE max_count for explanation.  It relates to
    // prior scaling when the count exceeds max_count_
    double old_num_frames = num_frames_,
        new_num_frames = num_frames_ + tot_weight;
    double old_prior_scale = std::max(old_num_frames, max_count_) / max_count_,
        new_prior_scale = std::max(new_num_frames, max_count_) / max_count_;
    // The prior_scales are the inverses of the scales we would put on the stats
    // if we were implementing this by scaling the stats.  Instead we
    // scale the prior term.
    double prior_scale_change = new_prior_scale - old_prior_scale;
    if (prior_scale_change != 0.0) {
      linear_term_(0) += prior_offset_ * prior_scale_change;
      quadratic_term_.AddToDiag(prior_scale_change);
    }
  }
  num_frames_ += tot_weight;
}

Count()

double Count ( ) const

inline

Definition at line 365 of file ivector-extractor.h.

Referenced by OnlineIvectorExtractorAdaptationState::LimitFrames().

{ return num_frames_; }

DefaultObjf()

double DefaultObjf ( ) const

protected

Returns objective function evaluated at the point [ prior_offset_, 0, 0, 0, ...

]... this is used in diagnostics.

Definition at line 776 of file ivector-extractor.cc.

References IvectorExtractor::prior_offset_.

                                                       {
  if (num_frames_ == 0.0) {
    return 0.0;
  } else {
    double x = prior_offset_;
    return (1.0 / num_frames_) * (-0.5 * quadratic_term_(0, 0) * x * x
                                  + x * linear_term_(0));
  }
}

GetIvector()

void GetIvector	(	int32	num_cg_iters,
		VectorBase< double > *	ivector
	)		const

This function gets the current estimate of the iVector.

Internally it does some work to compute it (currently matrix inversion, but we are doing to use Conjugate Gradient which will increase the speed). At entry, "ivector" must be a pointer to a vector dimension IvectorDim(), and free of NaN's. For faster estimation, you can set "num_cg_iters" to some value > 0, which will limit how many iterations of conjugate gradient we use to re-estimate the iVector; in this case, you should make sure *ivector is set at entry to a recently estimated iVector from the same utterance, which will give the CG a better starting point. If num_cg_iters is set to -1, it will compute the iVector exactly; if it's set to a positive number, the number of conjugate gradient iterations will be limited to that number. Note: the iVectors output still have a nonzero mean (first dim offset by PriorOffset()).

Definition at line 732 of file ivector-extractor.cc.

References VectorBase< Real >::Dim(), IvectorExtractor::IvectorDim(), KALDI_ASSERT, KALDI_VLOG, kaldi::LinearCgd(), LinearCgdOptions::max_iters, IvectorExtractor::prior_offset_, and VectorBase< Real >::SetZero().

Referenced by kaldi::TestIvectorExtraction().

                                       {
  KALDI_ASSERT(ivector != NULL && ivector->Dim() ==
               this->IvectorDim());

  if (num_frames_ > 0.0) {
    // could be done exactly as follows:
    // SpMatrix<double> quadratic_inv(quadratic_term_);
    // quadratic_inv.Invert();
    // ivector->AddSpVec(1.0, quadratic_inv, linear_term_, 0.0);
    if ((*ivector)(0) == 0.0)
      (*ivector)(0) = prior_offset_;  // better initial guess.
    LinearCgdOptions opts;
    opts.max_iters = num_cg_iters;
    LinearCgd(opts, quadratic_term_, linear_term_, ivector);
  } else {
    // Use 'default' value.
    ivector->SetZero();
    (*ivector)(0) = prior_offset_;
  }
  KALDI_VLOG(4) << "Objective function improvement from estimating the "
                << "iVector (vs. default value) is "
                << ObjfChange(*ivector);
}

IvectorDim()

int32 IvectorDim ( ) const

inline

Definition at line 337 of file ivector-extractor.h.

Referenced by OnlineIvectorFeature::SetAdaptationState().

{ return linear_term_.Dim(); }

NumFrames()

double NumFrames ( ) const

inline

Definition at line 355 of file ivector-extractor.h.

{ return num_frames_; }

Objf()

double Objf ( const VectorBase< double > &  ivector ) const

protected

Returns objective function per frame, at this iVector value.

Definition at line 765 of file ivector-extractor.cc.

References kaldi::VecSpVec(), and kaldi::VecVec().

                                             {
  if (num_frames_ == 0.0) {
    return 0.0;
  } else {
    return (1.0 / num_frames_) * (-0.5 * VecSpVec(ivector, quadratic_term_,
                                                  ivector)
                                  + VecVec(ivector, linear_term_));
  }
}

ObjfChange()

double ObjfChange

(

const VectorBase< double > &

ivector

)

const

ObjfChange returns the change in objective function *per frame* from using the default value [ prior_offset_, 0, 0, ...

] to using the provided value; should be >= 0, if "ivector" is a value we estimated. This is for diagnostics.

Definition at line 758 of file ivector-extractor.cc.

References KALDI_ASSERT, and KALDI_ISNAN.

Referenced by OnlineIvectorFeature::ObjfImprPerFrame(), and kaldi::TestIvectorExtraction().

                                             {
  double ans = Objf(ivector) - DefaultObjf();
  KALDI_ASSERT(!KALDI_ISNAN(ans));
  return ans;
}

operator=()

OnlineIvectorEstimationStats& operator= ( const OnlineIvectorEstimationStats &  other )

inline

Definition at line 376 of file ivector-extractor.h.

References OnlineIvectorEstimationStats::linear_term_, OnlineIvectorEstimationStats::max_count_, OnlineIvectorEstimationStats::num_frames_, OnlineIvectorEstimationStats::prior_offset_, and OnlineIvectorEstimationStats::quadratic_term_.

                                                                                            {
    this->prior_offset_ = other.prior_offset_;
    this->max_count_ = other.max_count_;
    this->num_frames_ = other.num_frames_;
    this->quadratic_term_=other.quadratic_term_;
    this->linear_term_=other.linear_term_;
    return *this;
  }

PriorOffset()

double PriorOffset ( ) const

inline

Definition at line 357 of file ivector-extractor.h.

{ return prior_offset_; }

Read()

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

Definition at line 710 of file ivector-extractor.cc.

References kaldi::ExpectToken(), KALDI_ASSERT, IvectorExtractor::prior_offset_, kaldi::ReadBasicType(), and kaldi::ReadToken().

Referenced by OnlineIvectorExtractorAdaptationState::Read(), and IvectorExtractor::Read().

                                                                   {
  ExpectToken(is, binary, "<OnlineIvectorEstimationStats>");
  ExpectToken(is, binary, "<PriorOffset>");
  ReadBasicType(is, binary, &prior_offset_);
  std::string tok;
  ReadToken(is, binary, &tok);
  if (tok == "<MaxCount>") {
    ReadBasicType(is, binary, &max_count_);
    ExpectToken(is, binary, "<NumFrames>");
    ReadBasicType(is, binary, &num_frames_);
  } else {
    KALDI_ASSERT(tok == "<NumFrames>");
    max_count_ = 0.0;
    ReadBasicType(is, binary, &num_frames_);
  }
  ExpectToken(is, binary, "<QuadraticTerm>");
  quadratic_term_.Read(is, binary);
  ExpectToken(is, binary, "<LinearTerm>");
  linear_term_.Read(is, binary);
  ExpectToken(is, binary, "</OnlineIvectorEstimationStats>");
}

Scale()

void Scale

(

double

scale

)

Scales the number of frames of stats by 0 <= scale <= 1, to make it as if we had fewer frames of adaptation data.

Note: it does not apply the scaling to the prior term.

Definition at line 671 of file ivector-extractor.cc.

References KALDI_ASSERT, and IvectorExtractor::prior_offset_.

Referenced by OnlineIvectorExtractorAdaptationState::LimitFrames(), and IvectorExtractorUtteranceStats::Scale().

                                                     {
  KALDI_ASSERT(scale >= 0.0 && scale <= 1.0);
  double old_num_frames = num_frames_;
  num_frames_ *= scale;
  quadratic_term_.Scale(scale);
  linear_term_.Scale(scale);

  // Scale back up the prior term, by adding in whatever we scaled down.
  if (max_count_ == 0.0) {
    linear_term_(0) += prior_offset_ * (1.0 - scale);
    quadratic_term_.AddToDiag(1.0 - scale);
  } else {
    double new_num_frames = num_frames_;
    double old_prior_scale =
        scale * std::max(old_num_frames, max_count_) / max_count_,
        new_prior_scale = std::max(new_num_frames, max_count_) / max_count_;
    // old_prior_scale is the scale the prior term currently has in the stats,
    // i.e. the previous scale times "scale" as we just scaled the stats.
    // new_prior_scale is the scale we want the prior term to have.
    linear_term_(0) += prior_offset_ * (new_prior_scale - old_prior_scale);
    quadratic_term_.AddToDiag(new_prior_scale - old_prior_scale);
  }
}

Write()

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

Definition at line 695 of file ivector-extractor.cc.

References IvectorExtractor::prior_offset_, kaldi::WriteBasicType(), and kaldi::WriteToken().

Referenced by OnlineIvectorExtractorAdaptationState::Write(), and IvectorExtractor::Write().

                                                                          {
  WriteToken(os, binary, "<OnlineIvectorEstimationStats>");
  WriteToken(os, binary, "<PriorOffset>");
  WriteBasicType(os, binary, prior_offset_);
  WriteToken(os, binary, "<MaxCount>");
  WriteBasicType(os, binary, max_count_);
  WriteToken(os, binary, "<NumFrames>");
  WriteBasicType(os, binary, num_frames_);
  WriteToken(os, binary, "<QuadraticTerm>");
  quadratic_term_.Write(os, binary);
  WriteToken(os, binary, "<LinearTerm>");
  linear_term_.Write(os, binary);
  WriteToken(os, binary, "</OnlineIvectorEstimationStats>");
}

Friends And Related Function Documentation

IvectorExtractor

friend class IvectorExtractor

friend

Definition at line 393 of file ivector-extractor.h.

Member Data Documentation

linear_term_

Vector<double> linear_term_

protected

Definition at line 398 of file ivector-extractor.h.

Referenced by OnlineIvectorEstimationStats::OnlineIvectorEstimationStats(), and OnlineIvectorEstimationStats::operator=().

max_count_

double max_count_

protected

Definition at line 395 of file ivector-extractor.h.

Referenced by OnlineIvectorEstimationStats::operator=().

num_frames_

double num_frames_

protected

Definition at line 396 of file ivector-extractor.h.

Referenced by OnlineIvectorEstimationStats::operator=().

prior_offset_

double prior_offset_

protected

Definition at line 394 of file ivector-extractor.h.

Referenced by OnlineIvectorEstimationStats::operator=(), IvectorExtractor::Read(), and IvectorExtractor::Write().

quadratic_term_

SpMatrix<double> quadratic_term_

protected

Definition at line 397 of file ivector-extractor.h.

Referenced by OnlineIvectorEstimationStats::OnlineIvectorEstimationStats(), and OnlineIvectorEstimationStats::operator=().

---

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

• ivector/ivector-extractor.h
• ivector/ivector-extractor.cc