LdaEstimate Class Reference

Class for computing linear discriminant analysis (LDA) transform. More...

#include <lda-estimate.h>

Inheritance diagram for LdaEstimate:

Collaboration diagram for LdaEstimate:

Public Member Functions
	LdaEstimate ()
void	Init (int32 num_classes, int32 dimension)
	Allocates memory for accumulators. More...
int32	NumClasses () const
	Returns the number of classes. More...
int32	Dim () const
	Returns the dimensionality of the feature vectors. More...
void	ZeroAccumulators ()
	Sets all accumulators to zero. More...
void	Scale (BaseFloat f)
	Scales all accumulators. More...
double	TotCount ()
	Return total count of the data. More...
void	Accumulate (const VectorBase< BaseFloat > &data, int32 class_id, BaseFloat weight=1.0)
	Accumulates data. More...
void	Estimate (const LdaEstimateOptions &opts, Matrix< BaseFloat > *M, Matrix< BaseFloat > *Mfull=NULL) const
	Estimates the LDA transform matrix m. More...
void	Read (std::istream &in_stream, bool binary, bool add)
void	Write (std::ostream &out_stream, bool binary) const

Protected Member Functions
void	GetStats (SpMatrix< double > *total_covar, SpMatrix< double > *between_covar, Vector< double > *total_mean, double *sum) const
	Extract a more processed form of the stats. More...
LdaEstimate &	operator= (const LdaEstimate &other)

Static Protected Member Functions
static void	AddMeanOffset (const VectorBase< double > &total_mean, Matrix< BaseFloat > *projection)
	This function modifies the LDA matrix so that it also subtracts the mean feature value. More...

Protected Attributes
Vector< double >	zero_acc_
Matrix< double >	first_acc_
SpMatrix< double >	total_second_acc_

Detailed Description

Class for computing linear discriminant analysis (LDA) transform.

C.f. Linear Discriminant Analysis (LDA) transforms.

Definition at line 57 of file lda-estimate.h.

Constructor & Destructor Documentation

LdaEstimate()

LdaEstimate ( )

inline

Definition at line 59 of file lda-estimate.h.

{}

Member Function Documentation

Accumulate()

void Accumulate	(	const VectorBase< BaseFloat > &	data,
		int32	class_id,
		BaseFloat	weight = 1.0
	)

Accumulates data.

Definition at line 45 of file lda-estimate.cc.

References SpMatrix< Real >::AddVec2(), VectorBase< Real >::Dim(), LdaEstimate::Dim(), LdaEstimate::first_acc_, KALDI_ASSERT, LdaEstimate::NumClasses(), MatrixBase< Real >::Row(), LdaEstimate::total_second_acc_, and LdaEstimate::zero_acc_.

Referenced by NnetLdaStatsAccumulator::AccStatsFromOutput(), main(), and UnitTestEstimateLda().

                                                               {
  KALDI_ASSERT(class_id >= 0);
  KALDI_ASSERT(class_id < NumClasses() && data.Dim() == Dim());

  Vector<double> data_d(data);

  zero_acc_(class_id) += weight;
  first_acc_.Row(class_id).AddVec(weight, data_d);
  total_second_acc_.AddVec2(weight, data_d);
}

AddMeanOffset()

void AddMeanOffset ( const VectorBase< double > &  total_mean, Matrix< BaseFloat > *  projection  )

staticprotected

This function modifies the LDA matrix so that it also subtracts the mean feature value.

Definition at line 166 of file lda-estimate.cc.

References VectorBase< Real >::AddMatVec(), MatrixBase< Real >::CopyColFromVec(), kaldi::kCopyData, kaldi::kNoTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and Matrix< Real >::Resize().

Referenced by LdaEstimate::Estimate(), and FeatureTransformEstimate::EstimateInternal().

                                                               {
  Vector<BaseFloat> mean(mean_dbl);
  Vector<BaseFloat> neg_projected_mean(projection->NumRows());
  // the negative
  neg_projected_mean.AddMatVec(-1.0, *projection, kNoTrans, mean, 0.0);
  projection->Resize(projection->NumRows(),
                     projection->NumCols() + 1,
                     kCopyData);
  projection->CopyColFromVec(neg_projected_mean, projection->NumCols() - 1);
}

Dim()

int32 Dim ( ) const

inline

Returns the dimensionality of the feature vectors.

Definition at line 66 of file lda-estimate.h.

Referenced by NnetLdaStatsAccumulator::AccStatsFromOutput(), LdaEstimate::Accumulate(), LdaEstimate::Estimate(), FeatureTransformEstimateMulti::Estimate(), FeatureTransformEstimateMulti::EstimateTransformPart(), LdaEstimate::GetStats(), main(), LdaEstimate::Read(), test_io(), and LdaEstimate::Write().

{ return first_acc_.NumCols(); }

Estimate()

void Estimate	(	const LdaEstimateOptions &	opts,
		Matrix< BaseFloat > *	M,
		Matrix< BaseFloat > *	Mfull = NULL
	)		const

Estimates the LDA transform matrix m.

If Mfull != NULL, it also outputs the full matrix (without dimensionality reduction), which is useful for some purposes. If opts.remove_offset == true, it will output both matrices with an extra column which corresponds to mean-offset removal (the matrix should be multiplied by the feature with a 1 appended to give the correct result, as with other Kaldi transforms.) The "remove_offset" argument is new and should be set to false for back compatibility.

Definition at line 85 of file lda-estimate.cc.

References SpMatrix< Real >::AddMat2Sp(), MatrixBase< Real >::AddMatMat(), LdaEstimate::AddMeanOffset(), SpMatrix< Real >::AddSp(), LdaEstimateOptions::allow_large_dim, TpMatrix< Real >::Cholesky(), MatrixBase< Real >::CopyFromMat(), count, LdaEstimateOptions::dim, LdaEstimate::Dim(), LdaEstimate::GetStats(), rnnlm::i, MatrixBase< Real >::Invert(), KALDI_ASSERT, KALDI_LOG, kaldi::kNoTrans, kaldi::kTrans, LdaEstimate::NumClasses(), PackedMatrix< Real >::NumRows(), MatrixBase< Real >::Range(), LdaEstimateOptions::remove_offset, Matrix< Real >::Resize(), MatrixBase< Real >::Row(), kaldi::SortSvd(), MatrixBase< Real >::Svd(), SpMatrix< Real >::Trace(), and LdaEstimateOptions::within_class_factor.

Referenced by main(), test_io(), and UnitTestEstimateLda().

                                                           {
  int32 target_dim = opts.dim;
  KALDI_ASSERT(target_dim > 0);
  // between-class covar is of most rank C-1
  KALDI_ASSERT(target_dim <= Dim() && (target_dim < NumClasses() || opts.allow_large_dim));
  int32 dim = Dim();
  
  double count;
  SpMatrix<double> total_covar, bc_covar;
  Vector<double> total_mean;
  GetStats(&total_covar, &bc_covar, &total_mean, &count);
  
  // within-class covariance
  SpMatrix<double> wc_covar(total_covar);
  wc_covar.AddSp(-1.0, bc_covar);
  TpMatrix<double> wc_covar_sqrt(dim);
  try {
    wc_covar_sqrt.Cholesky(wc_covar);
  } catch (...) {
    BaseFloat smooth = 1.0e-03 * wc_covar.Trace() / wc_covar.NumRows();
    KALDI_LOG << "Cholesky failed (possibly not +ve definite), so adding " << smooth
              << " to diagonal and trying again.\n";
    for (int32 i = 0; i < wc_covar.NumRows(); i++)
      wc_covar(i, i) += smooth;
    wc_covar_sqrt.Cholesky(wc_covar);    
  }
  Matrix<double> wc_covar_sqrt_mat(wc_covar_sqrt);
  // copy wc_covar_sqrt to Matrix, because it facilitates further use
  wc_covar_sqrt_mat.Invert();

  SpMatrix<double> tmp_sp(dim);
  tmp_sp.AddMat2Sp(1.0, wc_covar_sqrt_mat, kNoTrans, bc_covar, 0.0);
  Matrix<double> tmp_mat(tmp_sp);

  Matrix<double> svd_u(dim, dim), svd_vt(dim, dim);
  Vector<double> svd_d(dim);
  tmp_mat.Svd(&svd_d, &svd_u, &svd_vt);
  SortSvd(&svd_d, &svd_u);

  KALDI_LOG << "Data count is " << count;
  KALDI_LOG << "LDA singular values are " << svd_d;

  KALDI_LOG << "Sum of all singular values is " << svd_d.Sum();
  KALDI_LOG << "Sum of selected singular values is " <<
      SubVector<double>(svd_d, 0, target_dim).Sum();
  
  Matrix<double> lda_mat(dim, dim);
  lda_mat.AddMatMat(1.0, svd_u, kTrans, wc_covar_sqrt_mat, kNoTrans, 0.0);

  // finally, copy first target_dim rows to m
  m->Resize(target_dim, dim);
  m->CopyFromMat(lda_mat.Range(0, target_dim, 0, dim));
  
  if (mfull != NULL) {
    mfull->Resize(dim, dim);
    mfull->CopyFromMat(lda_mat);
  }

  if (opts.within_class_factor != 1.0) { // This is not the normal code path;
    // it's intended for use in neural net inputs.
    for (int32 i = 0; i < svd_d.Dim(); i++) {
      BaseFloat old_var = 1.0 + svd_d(i), // the total variance of that dim..
          new_var = opts.within_class_factor + svd_d(i), // the variance we want..
          scale = sqrt(new_var / old_var);
      if (i < m->NumRows())
        m->Row(i).Scale(scale);
      if (mfull != NULL)
        mfull->Row(i).Scale(scale);
    }
  }

  if (opts.remove_offset) {
    AddMeanOffset(total_mean, m);
    if (mfull != NULL)
      AddMeanOffset(total_mean, mfull);
  }  
}

GetStats()

void GetStats ( SpMatrix< double > *  total_covar, SpMatrix< double > *  between_covar, Vector< double > *  total_mean, double *  sum  ) const

protected

Extract a more processed form of the stats.

Definition at line 57 of file lda-estimate.cc.

References VectorBase< Real >::AddRowSumMat(), SpMatrix< Real >::AddVec2(), SpMatrix< Real >::CopyFromSp(), VectorBase< Real >::CopyRowFromMat(), LdaEstimate::Dim(), LdaEstimate::first_acc_, LdaEstimate::NumClasses(), SpMatrix< Real >::Resize(), Vector< Real >::Resize(), PackedMatrix< Real >::Scale(), VectorBase< Real >::Scale(), VectorBase< Real >::Sum(), LdaEstimate::total_second_acc_, and LdaEstimate::zero_acc_.

Referenced by LdaEstimate::Estimate(), FeatureTransformEstimate::Estimate(), and FeatureTransformEstimateMulti::Estimate().

                                                    {
  int32 num_class = NumClasses(), dim = Dim();
  double sum = zero_acc_.Sum();
  *tot_count = sum;
  total_covar->Resize(dim);
  total_covar->CopyFromSp(total_second_acc_);
  total_mean->Resize(dim);
  total_mean->AddRowSumMat(1.0, first_acc_);
  total_mean->Scale(1.0 / sum);
  total_covar->Scale(1.0 / sum);
  total_covar->AddVec2(-1.0, *total_mean);
  
  between_covar->Resize(dim);
  Vector<double> class_mean(dim);
  for (int32 c = 0; c < num_class; c++) {
    if (zero_acc_(c) != 0.0) {
      class_mean.CopyRowFromMat(first_acc_, c);
      class_mean.Scale(1.0 / zero_acc_(c));
      between_covar->AddVec2(zero_acc_(c) / sum, class_mean);
    }
  }
  between_covar->AddVec2(-1.0, *total_mean);
}

Init()

void Init	(	int32	num_classes,
		int32	dimension
	)

Allocates memory for accumulators.

Definition at line 26 of file lda-estimate.cc.

References LdaEstimate::first_acc_, SpMatrix< Real >::Resize(), Vector< Real >::Resize(), Matrix< Real >::Resize(), LdaEstimate::total_second_acc_, and LdaEstimate::zero_acc_.

Referenced by NnetLdaStatsAccumulator::AccStatsFromOutput(), main(), LdaEstimate::Read(), test_io(), and UnitTestEstimateLda().

                                                         {
  zero_acc_.Resize(num_classes);
  first_acc_.Resize(num_classes, dimension);
  total_second_acc_.Resize(dimension);
}

NumClasses()

int32 NumClasses ( ) const

inline

Returns the number of classes.

Definition at line 64 of file lda-estimate.h.

Referenced by LdaEstimate::Accumulate(), LdaEstimate::Estimate(), LdaEstimate::GetStats(), LdaEstimate::Read(), test_io(), and LdaEstimate::Write().

{ return first_acc_.NumRows(); }

operator=()

LdaEstimate& operator= ( const LdaEstimate &  other )

protected

Read()

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

Definition at line 180 of file lda-estimate.cc.

References MatrixBase< Real >::AddMat(), SpMatrix< Real >::AddSp(), VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2(), LdaEstimate::Dim(), kaldi::ExpectToken(), LdaEstimate::first_acc_, LdaEstimate::Init(), KALDI_ERR, LdaEstimate::NumClasses(), PackedMatrix< Real >::Read(), Vector< Real >::Read(), Matrix< Real >::Read(), kaldi::ReadBasicType(), kaldi::ReadToken(), MatrixBase< Real >::Row(), VectorBase< Real >::SetZero(), PackedMatrix< Real >::SetZero(), MatrixBase< Real >::SetZero(), LdaEstimate::total_second_acc_, and LdaEstimate::zero_acc_.

Referenced by main(), and test_io().

                                                                   {
  int32 num_classes, dim;
  std::string token;

  ExpectToken(in_stream, binary, "<LDAACCS>");
  ExpectToken(in_stream, binary, "<VECSIZE>");
  ReadBasicType(in_stream, binary, &dim);
  ExpectToken(in_stream, binary, "<NUMCLASSES>");
  ReadBasicType(in_stream, binary, &num_classes);

  if (add) {
    if (NumClasses() != 0 || Dim() != 0) {
      if (num_classes != NumClasses() || dim != Dim()) {
        KALDI_ERR <<"LdaEstimate::Read, dimension or classes count mismatch, "
                  <<(NumClasses()) << ", " <<(Dim()) << ", "
                  << " vs. " <<(num_classes) << ", " << (dim);
      }
    } else {
      Init(num_classes, dim);
    }
  } else {
    Init(num_classes, dim);
  }

  // these are needed for demangling the variances.
  Vector<double> tmp_zero_acc;
  Matrix<double> tmp_first_acc;
  SpMatrix<double> tmp_sec_acc;

  ReadToken(in_stream, binary, &token);
  while (token != "</LDAACCS>") {
    if (token == "<ZERO_ACCS>") {
      tmp_zero_acc.Read(in_stream, binary, false);
      if (!add) zero_acc_.SetZero();
      zero_acc_.AddVec(1.0, tmp_zero_acc);
      // zero_acc_.Read(in_stream, binary, add);
    } else if (token == "<FIRST_ACCS>") {
      tmp_first_acc.Read(in_stream, binary, false);
      if (!add) first_acc_.SetZero();
      first_acc_.AddMat(1.0, tmp_first_acc);
      // first_acc_.Read(in_stream, binary, add);
    } else if (token == "<SECOND_ACCS>") {
      tmp_sec_acc.Read(in_stream, binary, false);
      for (int32 c = 0; c < static_cast<int32>(NumClasses()); c++) {
        if (tmp_zero_acc(c) != 0)
          tmp_sec_acc.AddVec2(1.0 / tmp_zero_acc(c), tmp_first_acc.Row(c));
      }
      if (!add) total_second_acc_.SetZero();
      total_second_acc_.AddSp(1.0, tmp_sec_acc);
      // total_second_acc_.Read(in_stream, binary, add);
    } else {
      KALDI_ERR << "Unexpected token '" << token << "' in file ";
    }
    ReadToken(in_stream, binary, &token);
  }
}

Scale()

void Scale

(

BaseFloat

f

)

Scales all accumulators.

Definition at line 38 of file lda-estimate.cc.

References rnnlm::d, LdaEstimate::first_acc_, PackedMatrix< Real >::Scale(), MatrixBase< Real >::Scale(), VectorBase< Real >::Scale(), LdaEstimate::total_second_acc_, and LdaEstimate::zero_acc_.

Referenced by test_io().

                                   {
  double d = static_cast<double>(f);
  zero_acc_.Scale(d);
  first_acc_.Scale(d);
  total_second_acc_.Scale(d);
}

TotCount()

double TotCount ( )

inline

Return total count of the data.

Definition at line 72 of file lda-estimate.h.

Referenced by NnetLdaStatsAccumulator::WriteStats().

{ return zero_acc_.Sum(); }

Write()

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

Definition at line 237 of file lda-estimate.cc.

References SpMatrix< Real >::AddVec2(), LdaEstimate::Dim(), LdaEstimate::first_acc_, LdaEstimate::NumClasses(), MatrixBase< Real >::Row(), LdaEstimate::total_second_acc_, PackedMatrix< Real >::Write(), VectorBase< Real >::Write(), MatrixBase< Real >::Write(), kaldi::WriteBasicType(), kaldi::WriteToken(), and LdaEstimate::zero_acc_.

Referenced by main(), and test_io().

                                                                 {
  WriteToken(out_stream, binary, "<LDAACCS>");
  WriteToken(out_stream, binary, "<VECSIZE>");
  WriteBasicType(out_stream, binary, static_cast<int32>(Dim()));
  WriteToken(out_stream, binary, "<NUMCLASSES>");
  WriteBasicType(out_stream, binary, static_cast<int32>(NumClasses()));

  WriteToken(out_stream, binary, "<ZERO_ACCS>");
  Vector<BaseFloat> zero_acc_bf(zero_acc_);
  zero_acc_bf.Write(out_stream, binary);
  WriteToken(out_stream, binary, "<FIRST_ACCS>");
  Matrix<BaseFloat> first_acc_bf(first_acc_);
  first_acc_bf.Write(out_stream, binary);
  WriteToken(out_stream, binary, "<SECOND_ACCS>");
  SpMatrix<double> tmp_sec_acc(total_second_acc_);
  for (int32 c = 0; c < static_cast<int32>(NumClasses()); c++) {
    if (zero_acc_(c) != 0)
      tmp_sec_acc.AddVec2(-1.0 / zero_acc_(c), first_acc_.Row(c));
  }
  SpMatrix<BaseFloat> tmp_sec_acc_bf(tmp_sec_acc);
  tmp_sec_acc_bf.Write(out_stream, binary);

  WriteToken(out_stream, binary, "</LDAACCS>");
}

ZeroAccumulators()

void ZeroAccumulators

(

)

Sets all accumulators to zero.

Definition at line 32 of file lda-estimate.cc.

References LdaEstimate::first_acc_, VectorBase< Real >::SetZero(), PackedMatrix< Real >::SetZero(), MatrixBase< Real >::SetZero(), LdaEstimate::total_second_acc_, and LdaEstimate::zero_acc_.

Referenced by UnitTestEstimateLda().

                                   {
  zero_acc_.SetZero();
  first_acc_.SetZero();
  total_second_acc_.SetZero();
}

Member Data Documentation

first_acc_

Matrix<double> first_acc_

protected

Definition at line 94 of file lda-estimate.h.

Referenced by LdaEstimate::Accumulate(), LdaEstimate::GetStats(), LdaEstimate::Init(), LdaEstimate::Read(), LdaEstimate::Scale(), LdaEstimate::Write(), and LdaEstimate::ZeroAccumulators().

total_second_acc_

SpMatrix<double> total_second_acc_

protected

Definition at line 95 of file lda-estimate.h.

Referenced by LdaEstimate::Accumulate(), LdaEstimate::GetStats(), LdaEstimate::Init(), LdaEstimate::Read(), LdaEstimate::Scale(), LdaEstimate::Write(), and LdaEstimate::ZeroAccumulators().

zero_acc_

Vector<double> zero_acc_

protected

Definition at line 93 of file lda-estimate.h.

Referenced by LdaEstimate::Accumulate(), LdaEstimate::GetStats(), LdaEstimate::Init(), LdaEstimate::Read(), LdaEstimate::Scale(), LdaEstimate::Write(), and LdaEstimate::ZeroAccumulators().

---

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

• transform/lda-estimate.h
• transform/lda-estimate.cc