PldaEstimator Class Reference

#include <plda.h>

Collaboration diagram for PldaEstimator:

Public Member Functions
	PldaEstimator (const PldaStats &stats)
void	Estimate (const PldaEstimationConfig &config, Plda *output)

Private Types
typedef PldaStats::ClassInfo	ClassInfo

Private Member Functions
double	ComputeObjfPart1 () const
	Returns the part of the objf relating to offsets from the class means. More...
double	ComputeObjfPart2 () const
	Returns the part of the obj relating to the class means (total_not normalized) More...
double	ComputeObjf () const
	Returns the objective-function per sample. More...
int32	Dim () const
void	EstimateOneIter ()
void	InitParameters ()
void	ResetPerIterStats ()
void	GetStatsFromIntraClass ()
void	GetStatsFromClassMeans ()
	GetStatsFromClassMeans() is the more complicated part of PLDA estimation. More...
void	EstimateFromStats ()
void	GetOutput (Plda *plda)
	KALDI_DISALLOW_COPY_AND_ASSIGN (PldaEstimator)

Private Attributes
const PldaStats &	stats_
SpMatrix< double >	within_var_
SpMatrix< double >	between_var_
SpMatrix< double >	within_var_stats_
double	within_var_count_
SpMatrix< double >	between_var_stats_
double	between_var_count_

Detailed Description

Definition at line 235 of file plda.h.

Member Typedef Documentation

ClassInfo

typedef PldaStats::ClassInfo ClassInfo

private

Definition at line 242 of file plda.h.

Constructor & Destructor Documentation

PldaEstimator()

PldaEstimator

(

const PldaStats &

stats

)

Definition at line 338 of file plda.cc.

References PldaEstimator::InitParameters(), PldaStats::IsSorted(), and KALDI_ASSERT.

                                                  :
    stats_(stats) {
  KALDI_ASSERT(stats.IsSorted());
  InitParameters();
}

Member Function Documentation

ComputeObjf()

double ComputeObjf ( ) const

private

Returns the objective-function per sample.

Definition at line 390 of file plda.cc.

References PldaEstimator::ComputeObjfPart1(), PldaEstimator::ComputeObjfPart2(), PldaStats::example_weight_, KALDI_LOG, and PldaEstimator::stats_.

Referenced by PldaEstimator::EstimateOneIter().

                                        {
  double ans1 = ComputeObjfPart1(),
      ans2 = ComputeObjfPart2(),
      ans = ans1 + ans2,
      example_weights = stats_.example_weight_,
      normalized_ans = ans / example_weights;
  KALDI_LOG << "Within-class objf per sample is " << (ans1 / example_weights)
            << ", between-class is " << (ans2 / example_weights)
            << ", total is " << normalized_ans;
  return normalized_ans;
}

ComputeObjfPart1()

double ComputeObjfPart1 ( ) const

private

Returns the part of the objf relating to offsets from the class means.

(total, not normalized)

Definition at line 345 of file plda.cc.

References PldaStats::class_weight_, PldaEstimator::Dim(), PldaStats::example_weight_, SpMatrix< Real >::Invert(), KALDI_ASSERT, M_LOG_2PI, PldaStats::offset_scatter_, PldaEstimator::stats_, kaldi::TraceSpSp(), and PldaEstimator::within_var_.

Referenced by PldaEstimator::ComputeObjf().

                                             {
  // Returns the part of the objf relating to offsets from the class means.
  // within_class_count equals the sum over the classes, of the weight of that
  // class (normally 1) times (1 - #examples) of that class, which equals the
  // rank of the covariance we're modeling.  We imagine that we're modeling (1 -
  // #examples) separate samples, each with the within-class covariance.. the
  // argument is a little complicated and involves an orthogonal complement of a
  // matrix whose first row computes the mean.

  double within_class_count = stats_.example_weight_ - stats_.class_weight_,
      within_logdet, det_sign;
  SpMatrix<double> inv_within_var(within_var_);
  inv_within_var.Invert(&within_logdet, &det_sign);
  KALDI_ASSERT(det_sign == 1 && "Within-class covariance is singular");

  double objf = -0.5 * (within_class_count * (within_logdet + M_LOG_2PI * Dim())
                        + TraceSpSp(inv_within_var, stats_.offset_scatter_));
  return objf;
}

ComputeObjfPart2()

double ComputeObjfPart2 ( ) const

private

Returns the part of the obj relating to the class means (total_not normalized)

Definition at line 365 of file plda.cc.

References SpMatrix< Real >::AddSp(), VectorBase< Real >::AddVec(), PldaEstimator::between_var_, PldaStats::class_info_, PldaStats::class_weight_, SpMatrix< Real >::CopyFromSp(), PldaEstimator::Dim(), rnnlm::i, SpMatrix< Real >::Invert(), M_LOG_2PI, PldaStats::ClassInfo::mean, rnnlm::n, PldaStats::ClassInfo::num_examples, PldaEstimator::stats_, PldaStats::sum_, kaldi::VecSpVec(), PldaStats::ClassInfo::weight, and PldaEstimator::within_var_.

Referenced by PldaEstimator::ComputeObjf().

                                             {
  double tot_objf = 0.0;

  int32 n = -1; // the number of examples for the current class
  SpMatrix<double> combined_inv_var(Dim());
  // combined_inv_var = (between_var_ + within_var_ / n)^{-1}
  double combined_var_logdet;

  for (size_t i = 0; i < stats_.class_info_.size(); i++) {
    const ClassInfo &info = stats_.class_info_[i];
    if (info.num_examples != n) {
      n = info.num_examples;
      // variance of mean of n examples is between-class + 1/n * within-class
      combined_inv_var.CopyFromSp(between_var_);
      combined_inv_var.AddSp(1.0 / n, within_var_);
      combined_inv_var.Invert(&combined_var_logdet);
    }
    Vector<double> mean (*(info.mean));
    mean.AddVec(-1.0 / stats_.class_weight_, stats_.sum_);
    tot_objf += info.weight * -0.5 * (combined_var_logdet + M_LOG_2PI * Dim()
                                      + VecSpVec(mean, combined_inv_var, mean));
  }
  return tot_objf;
}

Dim()

int32 Dim ( ) const

inlineprivate

Definition at line 255 of file plda.h.

References kaldi::GetOutput().

Referenced by PldaEstimator::ComputeObjfPart1(), PldaEstimator::ComputeObjfPart2(), PldaEstimator::GetOutput(), PldaEstimator::GetStatsFromClassMeans(), PldaEstimator::InitParameters(), and PldaEstimator::ResetPerIterStats().

{ return stats_.Dim(); }

Estimate()

void Estimate	(	const PldaEstimationConfig &	config,
		Plda *	output
	)

Definition at line 525 of file plda.cc.

References PldaEstimator::EstimateOneIter(), PldaStats::example_weight_, PldaEstimator::GetOutput(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, PldaEstimationConfig::num_em_iters, and PldaEstimator::stats_.

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

                                         {
  KALDI_ASSERT(stats_.example_weight_ > 0 && "Cannot estimate with no stats");
  for (int32 i = 0; i < config.num_em_iters; i++) {
    KALDI_LOG << "Plda estimation iteration " << i
              << " of " << config.num_em_iters;
    EstimateOneIter();
  }
  GetOutput(plda);
}

EstimateFromStats()

void EstimateFromStats ( )

private

Definition at line 505 of file plda.cc.

References PldaEstimator::between_var_, PldaEstimator::between_var_count_, PldaEstimator::between_var_stats_, SpMatrix< Real >::CopyFromSp(), KALDI_LOG, PackedMatrix< Real >::Scale(), SpMatrix< Real >::Trace(), PldaEstimator::within_var_, PldaEstimator::within_var_count_, and PldaEstimator::within_var_stats_.

Referenced by PldaEstimator::EstimateOneIter().

                                      {
  within_var_.CopyFromSp(within_var_stats_);
  within_var_.Scale(1.0 / within_var_count_);
  between_var_.CopyFromSp(between_var_stats_);
  between_var_.Scale(1.0 / between_var_count_);

  KALDI_LOG << "Trace of within-class variance is " << within_var_.Trace();
  KALDI_LOG << "Trace of between-class variance is " << between_var_.Trace();
}

EstimateOneIter()

void EstimateOneIter ( )

private

Definition at line 516 of file plda.cc.

References PldaEstimator::ComputeObjf(), PldaEstimator::EstimateFromStats(), PldaEstimator::GetStatsFromClassMeans(), PldaEstimator::GetStatsFromIntraClass(), KALDI_VLOG, and PldaEstimator::ResetPerIterStats().

Referenced by PldaEstimator::Estimate().

                                    {
  ResetPerIterStats();
  GetStatsFromIntraClass();
  GetStatsFromClassMeans();
  EstimateFromStats();
  KALDI_VLOG(2) << "Objective function is " << ComputeObjf();
}

GetOutput()

void GetOutput ( Plda *  plda )

private

Definition at line 537 of file plda.cc.

References SpMatrix< Real >::AddMat2Sp(), MatrixBase< Real >::AddMatMat(), VectorBase< Real >::ApplyFloor(), kaldi::AssertEqual(), PldaEstimator::between_var_, PldaStats::class_weight_, Plda::ComputeDerivedVars(), kaldi::ComputeNormalizingTransform(), PldaEstimator::Dim(), SpMatrix< Real >::Eig(), kaldi::GetVerboseLevel(), SpMatrix< Real >::IsUnit(), KALDI_ASSERT, KALDI_LOG, KALDI_WARN, kaldi::kNoTrans, kaldi::kTrans, Plda::mean_, VectorBase< Real >::Min(), rnnlm::n, VectorBase< Real >::Norm(), Plda::psi_, Matrix< Real >::Resize(), VectorBase< Real >::Scale(), kaldi::SortSvd(), PldaEstimator::stats_, PldaStats::sum_, Plda::transform_, and PldaEstimator::within_var_.

Referenced by PldaEstimator::Estimate().

                                        {
  plda->mean_ = stats_.sum_;
  plda->mean_.Scale(1.0 / stats_.class_weight_);
  KALDI_LOG << "Norm of mean of iVector distribution is "
            << plda->mean_.Norm(2.0);

  Matrix<double> transform1(Dim(), Dim());
  ComputeNormalizingTransform(within_var_, &transform1);
  // now transform is a matrix that if we project with it,
  // within_var_ becomes unit.

  // between_var_proj is between_var after projecting with transform1.
  SpMatrix<double> between_var_proj(Dim());
  between_var_proj.AddMat2Sp(1.0, transform1, kNoTrans, between_var_, 0.0);

  Matrix<double> U(Dim(), Dim());
  Vector<double> s(Dim());
  // Do symmetric eigenvalue decomposition between_var_proj = U diag(s) U^T,
  // where U is orthogonal.
  between_var_proj.Eig(&s, &U);

  KALDI_ASSERT(s.Min() >= 0.0);
  int32 n;
  s.ApplyFloor(0.0, &n);
  if (n > 0) {
    KALDI_WARN << "Floored " << n << " eigenvalues of between-class "
               << "variance to zero.";
  }
  // Sort from greatest to smallest eigenvalue.
  SortSvd(&s, &U);

  // The transform U^T will make between_var_proj diagonal with value s
  // (i.e. U^T U diag(s) U U^T = diag(s)).  The final transform that
  // makes within_var_ unit and between_var_ diagonal is U^T transform1,
  // i.e. first transform1 and then U^T.

  plda->transform_.Resize(Dim(), Dim());
  plda->transform_.AddMatMat(1.0, U, kTrans, transform1, kNoTrans, 0.0);
  plda->psi_ = s;

  KALDI_LOG << "Diagonal of between-class variance in normalized space is " << s;

  if (GetVerboseLevel() >= 2) { // at higher verbose levels, do a self-test
                                // (just tests that this function does what it
                                // should).
    SpMatrix<double> tmp_within(Dim());
    tmp_within.AddMat2Sp(1.0, plda->transform_, kNoTrans, within_var_, 0.0);
    KALDI_ASSERT(tmp_within.IsUnit(0.0001));
    SpMatrix<double> tmp_between(Dim());
    tmp_between.AddMat2Sp(1.0, plda->transform_, kNoTrans, between_var_, 0.0);
    KALDI_ASSERT(tmp_between.IsDiagonal(0.0001));
    Vector<double> psi(Dim());
    psi.CopyDiagFromSp(tmp_between);
    AssertEqual(psi, plda->psi_);
  }
  plda->ComputeDerivedVars();
}

GetStatsFromClassMeans()

void GetStatsFromClassMeans ( )

private

GetStatsFromClassMeans() is the more complicated part of PLDA estimation.

Let's suppose the mean of a particular class is m, and suppose that that class had n examples. We suppose that m ~ N(0, between_var_ + 1/n within_var_) i.e. m is Gaussian-distributed with zero mean and variance equal to the between-class variance plus 1/n times the within-class variance. Now, m is observed (as stats_.class_info_[something].mean). We're doing an E-M procedure where we treat m as the sum of two variables: m = x + y where x ~ N(0, between_var_) y ~ N(0, 1/n * within_var_) The distribution of x will contribute to the stats of between_var_, and y to within_var_. Now, y = m - x, so we can focus on working out the distribution of x and then we can very simply get the distribution of y. The following expression also includes the likelihood of y as a function of x. Note: the C is different from line to line.

log p(x) = C - 0.5 ( x^T between_var^{-1} x + (m-x)^T (1/n within_var)^{-1) (m-x) ) = C - 0.5 x^T (between_var^{-1} + n within_var^{-1}) x + x^T z

where z = n within_var^{-1} m, and we can write this as:

log p(x) = C - 0.5 (x-w)^T (between_var^{-1} + n within_var^{-1}) (x-w)

where x^T (between_var^{-1} + n within_var^{-1}) w = x^T z, i.e. (between_var^{-1} + n within_var^{-1}) w = z = n within_var^{-1} m, so

w = (between_var^{-1} + n within_var^{-1})^{-1} * n within_var^{-1} m

We can see that the distribution over x is Gaussian, with mean w and variance (between_var^{-1} + n within_var^{-1})^{-1}. The distribution over y is Gaussian with the same variance, and mean m - w. So the update to the between-var stats will be: between-var-stats += w w^T + (between_var^{-1} + n within_var^{-1})^{-1}. and the update to the within-var stats will be: within-var-stats += n ( (m-w) (m-w)^T (between_var^{-1} + n within_var^{-1})^{-1} ).

The drawback of this formulation is that each time we encounter a different value of n (number of examples) we will have to do a different matrix inversion. We'll try to improve on this later using a suitable transform.

Definition at line 470 of file plda.cc.

References SpMatrix< Real >::AddSp(), VectorBase< Real >::AddSpVec(), VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2(), PldaEstimator::between_var_, PldaEstimator::between_var_count_, PldaEstimator::between_var_stats_, PldaStats::class_info_, PldaStats::class_weight_, SpMatrix< Real >::CopyFromSp(), PldaEstimator::Dim(), rnnlm::i, SpMatrix< Real >::Invert(), PldaStats::ClassInfo::mean, rnnlm::n, PldaStats::ClassInfo::num_examples, PldaEstimator::stats_, PldaStats::sum_, PldaStats::ClassInfo::weight, PldaEstimator::within_var_, PldaEstimator::within_var_count_, and PldaEstimator::within_var_stats_.

Referenced by PldaEstimator::EstimateOneIter().

                                           {
  SpMatrix<double> between_var_inv(between_var_);
  between_var_inv.Invert();
  SpMatrix<double> within_var_inv(within_var_);
  within_var_inv.Invert();
  // mixed_var will equal (between_var^{-1} + n within_var^{-1})^{-1}.
  SpMatrix<double> mixed_var(Dim());
  int32 n = -1; // the current number of examples for the class.

  for (size_t i = 0; i < stats_.class_info_.size(); i++) {
    const ClassInfo &info = stats_.class_info_[i];
    double weight = info.weight;
    if (info.num_examples != n) {
      n = info.num_examples;
      mixed_var.CopyFromSp(between_var_inv);
      mixed_var.AddSp(n, within_var_inv);
      mixed_var.Invert();
    }
    Vector<double> m = *(info.mean); // the mean for this class.
    m.AddVec(-1.0 / stats_.class_weight_, stats_.sum_); // remove global mean
    Vector<double> temp(Dim()); // n within_var^{-1} m
    temp.AddSpVec(n, within_var_inv, m, 0.0);
    Vector<double> w(Dim()); // w, as defined in the comment.
    w.AddSpVec(1.0, mixed_var, temp, 0.0);
    Vector<double> m_w(m); // m - w
    m_w.AddVec(-1.0, w);
    between_var_stats_.AddSp(weight, mixed_var);
    between_var_stats_.AddVec2(weight, w);
    between_var_count_ += weight;
    within_var_stats_.AddSp(weight * n, mixed_var);
    within_var_stats_.AddVec2(weight * n, m_w);
    within_var_count_ += weight;
  }
}

GetStatsFromIntraClass()

void GetStatsFromIntraClass ( )

private

Definition at line 416 of file plda.cc.

References SpMatrix< Real >::AddSp(), PldaStats::class_weight_, PldaStats::example_weight_, PldaStats::offset_scatter_, PldaEstimator::stats_, PldaEstimator::within_var_count_, and PldaEstimator::within_var_stats_.

Referenced by PldaEstimator::EstimateOneIter().

                                           {
  within_var_stats_.AddSp(1.0, stats_.offset_scatter_);
  // Note: in the normal case, the expression below will be equal to the sum
  // over the classes, of (1-n), where n is the #examples for that class.  That
  // is the rank of the scatter matrix that "offset_scatter_" has for that
  // class. [if weights other than 1.0 are used, it will be different.]
  within_var_count_ += (stats_.example_weight_ - stats_.class_weight_);
}

InitParameters()

void InitParameters ( )

private

Definition at line 402 of file plda.cc.

References PldaEstimator::between_var_, PldaEstimator::Dim(), SpMatrix< Real >::Resize(), PackedMatrix< Real >::SetUnit(), and PldaEstimator::within_var_.

Referenced by PldaEstimator::PldaEstimator().

                                   {
  within_var_.Resize(Dim());
  within_var_.SetUnit();
  between_var_.Resize(Dim());
  between_var_.SetUnit();
}

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( PldaEstimator  )

private

ResetPerIterStats()

void ResetPerIterStats ( )

private

Definition at line 409 of file plda.cc.

References PldaEstimator::between_var_count_, PldaEstimator::between_var_stats_, PldaEstimator::Dim(), SpMatrix< Real >::Resize(), PldaEstimator::within_var_count_, and PldaEstimator::within_var_stats_.

Referenced by PldaEstimator::EstimateOneIter().

                                      {
  within_var_stats_.Resize(Dim());
  within_var_count_ = 0.0;
  between_var_stats_.Resize(Dim());
  between_var_count_ = 0.0;
}

Member Data Documentation

between_var_

SpMatrix<double> between_var_

private

Definition at line 278 of file plda.h.

Referenced by PldaEstimator::ComputeObjfPart2(), PldaEstimator::EstimateFromStats(), PldaEstimator::GetOutput(), PldaEstimator::GetStatsFromClassMeans(), and PldaEstimator::InitParameters().

between_var_count_

double between_var_count_

private

Definition at line 284 of file plda.h.

Referenced by PldaEstimator::EstimateFromStats(), PldaEstimator::GetStatsFromClassMeans(), and PldaEstimator::ResetPerIterStats().

between_var_stats_

SpMatrix<double> between_var_stats_

private

Definition at line 283 of file plda.h.

Referenced by PldaEstimator::EstimateFromStats(), PldaEstimator::GetStatsFromClassMeans(), and PldaEstimator::ResetPerIterStats().

stats_

const PldaStats& stats_

private

Definition at line 275 of file plda.h.

Referenced by PldaEstimator::ComputeObjf(), PldaEstimator::ComputeObjfPart1(), PldaEstimator::ComputeObjfPart2(), PldaEstimator::Estimate(), PldaEstimator::GetOutput(), PldaEstimator::GetStatsFromClassMeans(), and PldaEstimator::GetStatsFromIntraClass().

within_var_

SpMatrix<double> within_var_

private

Definition at line 277 of file plda.h.

Referenced by PldaEstimator::ComputeObjfPart1(), PldaEstimator::ComputeObjfPart2(), PldaEstimator::EstimateFromStats(), PldaEstimator::GetOutput(), PldaEstimator::GetStatsFromClassMeans(), and PldaEstimator::InitParameters().

within_var_count_

double within_var_count_

private

Definition at line 282 of file plda.h.

Referenced by PldaEstimator::EstimateFromStats(), PldaEstimator::GetStatsFromClassMeans(), PldaEstimator::GetStatsFromIntraClass(), and PldaEstimator::ResetPerIterStats().

within_var_stats_

SpMatrix<double> within_var_stats_

private

Definition at line 281 of file plda.h.

Referenced by PldaEstimator::EstimateFromStats(), PldaEstimator::GetStatsFromClassMeans(), PldaEstimator::GetStatsFromIntraClass(), and PldaEstimator::ResetPerIterStats().

---

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

• ivector/plda.h
• ivector/plda.cc