OnlineIvectorFeature Class Reference

OnlineIvectorFeature is an online feature-extraction class that's responsible for extracting iVectors from raw features such as MFCC, PLP or filterbank. More...

#include <online-ivector-feature.h>

Inheritance diagram for OnlineIvectorFeature:

Collaboration diagram for OnlineIvectorFeature:

Public Member Functions
	OnlineIvectorFeature (const OnlineIvectorExtractionInfo &info, OnlineFeatureInterface *base_feature)
	Constructor. More...
virtual int32	Dim () const
	Dim() will return the iVector dimension. More...
virtual bool	IsLastFrame (int32 frame) const
	Returns true if this is the last frame. More...
virtual int32	NumFramesReady () const
	returns the feature dimension. More...
virtual BaseFloat	FrameShiftInSeconds () const
virtual void	GetFrame (int32 frame, VectorBase< BaseFloat > *feat)
	Gets the feature vector for this frame. More...
void	SetAdaptationState (const OnlineIvectorExtractorAdaptationState &adaptation_state)
	Set the adaptation state to a particular value, e.g. More...
void	GetAdaptationState (OnlineIvectorExtractorAdaptationState *adaptation_state) const
	Get the adaptation state; you may want to call this before destroying this object, to get adaptation state that can be used to improve decoding of later utterances of this speaker. More...
virtual	~OnlineIvectorFeature ()
BaseFloat	UbmLogLikePerFrame () const
BaseFloat	ObjfImprPerFrame () const
BaseFloat	NumFrames () const
void	UpdateFrameWeights (const std::vector< std::pair< int32, BaseFloat > > &delta_weights)
Public Member Functions inherited from OnlineFeatureInterface
virtual void	GetFrames (const std::vector< int32 > &frames, MatrixBase< BaseFloat > *feats)
	This is like GetFrame() but for a collection of frames. More...
virtual	~OnlineFeatureInterface ()
	Virtual destructor. More...

Private Member Functions
void	UpdateStatsForFrames (const std::vector< std::pair< int32, BaseFloat > > &frame_weights)
BaseFloat	GetMinPost (BaseFloat weight) const
void	UpdateStatsUntilFrame (int32 frame)
void	UpdateStatsUntilFrameWeighted (int32 frame)
void	PrintDiagnostics () const

Private Attributes
const OnlineIvectorExtractionInfo &	info_
OnlineFeatureInterface *	base_
OnlineFeatureInterface *	lda_
OnlineCmvn *	cmvn_
OnlineFeatureInterface *	lda_normalized_
std::vector< OnlineFeatureInterface * >	to_delete_
OnlineIvectorEstimationStats	ivector_stats_
	the iVector estimation stats More...
int32	num_frames_stats_
	num_frames_stats_ is the number of frames of data we have already accumulated from this utterance and put in ivector_stats_. More...
std::priority_queue< std::pair< int32, BaseFloat >, std::vector< std::pair< int32, BaseFloat > >, std::greater< std::pair< int32, BaseFloat > > >	delta_weights_
	delta_weights_ is written to by UpdateFrameWeights, in the case where the iVector estimation is silence-weighted using the decoder traceback. More...
std::vector< BaseFloat >	current_frame_weight_debug_
	this is only used for validating that the frame-weighting code is not buggy. More...
bool	delta_weights_provided_
	delta_weights_provided_ is set to true if UpdateFrameWeights was ever called; it's used to detect wrong usage of this class. More...
bool	updated_with_no_delta_weights_
	The following is also used to detect wrong usage of this class; it's set to true if UpdateStatsUntilFrame() was ever called. More...
int32	most_recent_frame_with_weight_
	if delta_weights_ was ever called, this keeps track of the most recent frame that ever had a weight. More...
double	tot_ubm_loglike_
	The following is only needed for diagnostics. More...
Vector< double >	current_ivector_
	Most recently estimated iVector, will have been estimated at the greatest time t where t <= num_frames_stats_ and t % info_.ivector_period == 0. More...
std::vector< Vector< BaseFloat > *>	ivectors_history_
	if info_.use_most_recent_ivector == false, we need to store the iVector we estimated each info_.ivector_period frames so that GetFrame() can return the iVector that was active on that frame. More...

Detailed Description

OnlineIvectorFeature is an online feature-extraction class that's responsible for extracting iVectors from raw features such as MFCC, PLP or filterbank.

Internally it processes the raw features using two different pipelines, one online-CMVN+splice+LDA, and one just splice+LDA. It gets GMM posteriors from the CMVN-normalized features, and with those and the unnormalized features it obtains iVectors.

Definition at line 256 of file online-ivector-feature.h.

Constructor & Destructor Documentation

OnlineIvectorFeature()

OnlineIvectorFeature ( const OnlineIvectorExtractionInfo &  info, OnlineFeatureInterface *  base_feature  )

explicit

Constructor.

base_feature is for example raw MFCC or PLP or filterbank features, whatever was used to train the iVector extractor. "info" contains all the configuration information as well as things like the iVector extractor that we won't be modifying. Caution: the class keeps a const reference to "info", so don't delete it while this class or others copied from it still exist.

Definition at line 399 of file online-ivector-feature.cc.

References OnlineIvectorExtractionInfo::Check(), OnlineIvectorFeature::cmvn_, OnlineIvectorExtractionInfo::cmvn_opts, OnlineIvectorFeature::current_ivector_, OnlineIvectorExtractionInfo::extractor, OnlineIvectorExtractionInfo::global_cmvn_stats, OnlineIvectorFeature::info_, IvectorExtractor::IvectorDim(), KALDI_ASSERT, OnlineIvectorFeature::lda_, OnlineIvectorExtractionInfo::lda_mat, OnlineIvectorFeature::lda_normalized_, IvectorExtractor::PriorOffset(), Vector< Real >::Resize(), OnlineIvectorExtractionInfo::splice_opts, and OnlineIvectorFeature::to_delete_.

                                         :
    info_(info),
    base_(base_feature),
    ivector_stats_(info_.extractor.IvectorDim(),
                   info_.extractor.PriorOffset(),
                   info_.max_count),
    num_frames_stats_(0), delta_weights_provided_(false),
    updated_with_no_delta_weights_(false),
    most_recent_frame_with_weight_(-1), tot_ubm_loglike_(0.0) {
  info.Check();
  KALDI_ASSERT(base_feature != NULL);
  OnlineFeatureInterface *splice_feature = new OnlineSpliceFrames(info_.splice_opts, base_feature);
  to_delete_.push_back(splice_feature);
  OnlineFeatureInterface *lda_feature = new OnlineTransform(info.lda_mat, splice_feature);
  to_delete_.push_back(lda_feature);
  OnlineFeatureInterface *lda_cache_feature = new OnlineCacheFeature(lda_feature);
  lda_ = lda_cache_feature;
  to_delete_.push_back(lda_cache_feature);


  OnlineCmvnState naive_cmvn_state(info.global_cmvn_stats);
  // Note: when you call this constructor the CMVN state knows nothing
  // about the speaker.  If you want to inform this class about more specific
  // adaptation state, call this->SetAdaptationState(), most likely derived
  // from a call to GetAdaptationState() from a previous object of this type.
  cmvn_ = new OnlineCmvn(info.cmvn_opts, naive_cmvn_state, base_feature);
  to_delete_.push_back(cmvn_);

  OnlineFeatureInterface *splice_normalized =
      new OnlineSpliceFrames(info_.splice_opts, cmvn_),
      *lda_normalized =
      new OnlineTransform(info.lda_mat, splice_normalized),
      *cache_normalized = new OnlineCacheFeature(lda_normalized);
  lda_normalized_ = cache_normalized;

  to_delete_.push_back(splice_normalized);
  to_delete_.push_back(lda_normalized);
  to_delete_.push_back(cache_normalized);

  // Set the iVector to its default value, [ prior_offset, 0, 0, ... ].
  current_ivector_.Resize(info_.extractor.IvectorDim());
  current_ivector_(0) = info_.extractor.PriorOffset();
}

~OnlineIvectorFeature()

~OnlineIvectorFeature ( )

virtual

Definition at line 377 of file online-ivector-feature.cc.

References rnnlm::i.

                                            {
  PrintDiagnostics();
  // Delete objects owned here.
  for (size_t i = 0; i < to_delete_.size(); i++)
    delete to_delete_[i];
  for (size_t i = 0; i < ivectors_history_.size(); i++)
    delete ivectors_history_[i];
}

Member Function Documentation

Dim()

int32 Dim ( ) const

virtual

Dim() will return the iVector dimension.

Implements OnlineFeatureInterface.

Definition at line 147 of file online-ivector-feature.cc.

Referenced by main().

                                      {
  return info_.extractor.IvectorDim();
}

FrameShiftInSeconds()

BaseFloat FrameShiftInSeconds ( ) const

virtual

Implements OnlineFeatureInterface.

Definition at line 165 of file online-ivector-feature.cc.

                                                          {
  return lda_->FrameShiftInSeconds();
}

GetAdaptationState()

void GetAdaptationState

(

OnlineIvectorExtractorAdaptationState *

adaptation_state

)

const

Get the adaptation state; you may want to call this before destroying this object, to get adaptation state that can be used to improve decoding of later utterances of this speaker.

Definition at line 386 of file online-ivector-feature.cc.

References OnlineIvectorExtractorAdaptationState::cmvn_state, OnlineIvectorExtractorAdaptationState::ivector_stats, and OnlineIvectorExtractorAdaptationState::LimitFrames().

Referenced by OnlineNnet2FeaturePipeline::GetAdaptationState(), and main().

                                                                   {
  // Note: the following call will work even if cmvn_->NumFramesReady() == 0; in
  // that case it will return the unmodified adaptation state that cmvn_ was
  // initialized with.
  cmvn_->GetState(cmvn_->NumFramesReady() - 1,
                  &(adaptation_state->cmvn_state));
  adaptation_state->ivector_stats = ivector_stats_;
  adaptation_state->LimitFrames(info_.max_remembered_frames,
                                info_.posterior_scale);
}

GetFrame()

void GetFrame ( int32  frame, VectorBase< BaseFloat > *  feat  )

virtual

Gets the feature vector for this frame.

Before calling this for a given frame, it is assumed that you called NumFramesReady() and it returned a number greater than "frame". Otherwise this call will likely crash with an assert failure. This function is not declared const, in case there is some kind of caching going on, but most of the time it shouldn't modify the class.

Implements OnlineFeatureInterface.

Definition at line 327 of file online-ivector-feature.cc.

References VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Dim(), rnnlm::i, KALDI_ASSERT, and KALDI_VLOG.

Referenced by main().

                                                                 {
  int32 frame_to_update_until = (info_.greedy_ivector_extractor ?
                                 lda_->NumFramesReady() - 1 : frame);
  if (!delta_weights_provided_)  // No silence weighting.
    UpdateStatsUntilFrame(frame_to_update_until);
  else
    UpdateStatsUntilFrameWeighted(frame_to_update_until);

  KALDI_ASSERT(feat->Dim() == this->Dim());

  if (info_.use_most_recent_ivector) {
    KALDI_VLOG(5) << "due to --use-most-recent-ivector=true, using iVector "
                  << "from frame " << num_frames_stats_ << " for frame "
                  << frame;
    // use the most recent iVector we have, even if 'frame' is significantly in
    // the past.
    feat->CopyFromVec(current_ivector_);
    // Subtract the prior-mean from the first dimension of the output feature so
    // it's approximately zero-mean.
    (*feat)(0) -= info_.extractor.PriorOffset();
  } else {
    int32 i = frame / info_.ivector_period;  // rounds down.
    // if the following fails, UpdateStatsUntilFrame would have a bug.
    KALDI_ASSERT(static_cast<size_t>(i) <  ivectors_history_.size());
    feat->CopyFromVec(*(ivectors_history_[i]));
    (*feat)(0) -= info_.extractor.PriorOffset();
  }
}

GetMinPost()

BaseFloat GetMinPost ( BaseFloat  weight ) const

private

Definition at line 188 of file online-ivector-feature.cc.

                                                                 {
  BaseFloat min_post = info_.min_post;
  BaseFloat abs_weight = fabs(weight);
  // If we return 0.99, it will have the same effect as just picking the
  // most probable Gaussian on that frame.
  if (abs_weight == 0.0)
    return 0.99;   // I don't anticipate reaching here.
  min_post /= abs_weight;
  if (min_post > 0.99)
    min_post = 0.99;
  return min_post;
}

IsLastFrame()

bool IsLastFrame ( int32  frame ) const

virtual

Returns true if this is the last frame.

Frame indices are zero-based, so the first frame is zero. IsLastFrame(-1) will return false, unless the file is empty (which is a case that I'm not sure all the code will handle, so be careful). This function may return false for some frame if we haven't yet decided to terminate decoding, but later true if we decide to terminate decoding. This function exists mainly to correctly handle end effects in feature extraction, and is not a mechanism to determine how many frames are in the decodable object (as it used to be, and for backward compatibility, still is, in the Decodable interface).

Implements OnlineFeatureInterface.

Definition at line 151 of file online-ivector-feature.cc.

                                                        {
  // Note: it might be more logical to return, say, lda_->IsLastFrame()
  // since this is the feature the iVector extractor directly consumes,
  // but it will give the same answer as base_->IsLastFrame() anyway.
  // [note: the splicing component pads at begin and end so it always
  // returns the same number of frames as its input.]
  return base_->IsLastFrame(frame);
}

NumFrames()

BaseFloat NumFrames ( ) const

inline

Definition at line 307 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::UbmLogLikePerFrame().

                              {
    return ivector_stats_.NumFrames() / info_.posterior_scale;
  }

NumFramesReady()

int32 NumFramesReady ( ) const

virtual

returns the feature dimension.

Returns the total number of frames, since the start of the utterance, that are now available. In an online-decoding context, this will likely increase with time as more data becomes available.

Implements OnlineFeatureInterface.

Definition at line 160 of file online-ivector-feature.cc.

References KALDI_ASSERT.

Referenced by SingleUtteranceNnet2DecoderThreaded::RunNnetEvaluationInternal().

                                                 {
  KALDI_ASSERT(lda_ != NULL);
  return lda_->NumFramesReady();
}

ObjfImprPerFrame()

BaseFloat ObjfImprPerFrame

(

)

const

Definition at line 460 of file online-ivector-feature.cc.

References OnlineIvectorFeature::current_ivector_, OnlineIvectorFeature::ivector_stats_, and OnlineIvectorEstimationStats::ObjfChange().

Referenced by main().

                                                       {
  return ivector_stats_.ObjfChange(current_ivector_);
}

PrintDiagnostics()

void PrintDiagnostics ( ) const

private

Definition at line 357 of file online-ivector-feature.cc.

References KALDI_VLOG, VectorBase< Real >::Norm(), and kaldi::NumFrames().

                                                  {
  if (num_frames_stats_ == 0) {
    KALDI_VLOG(3) << "Processed no data.";
  } else {
    KALDI_VLOG(3) << "UBM log-likelihood was "
                  << (tot_ubm_loglike_ / NumFrames())
                  << " per frame, over " << NumFrames()
                  << " frames.";

    Vector<BaseFloat> temp_ivector(current_ivector_);
    temp_ivector(0) -= info_.extractor.PriorOffset();

    KALDI_VLOG(2) << "By the end of the utterance, objf change/frame "
                  << "from estimating iVector (vs. default) was "
                  << ivector_stats_.ObjfChange(current_ivector_)
                  << " and iVector length was "
                  << temp_ivector.Norm(2.0);
  }
}

SetAdaptationState()

void SetAdaptationState

(

const OnlineIvectorExtractorAdaptationState &

adaptation_state

)

Set the adaptation state to a particular value, e.g.

reflecting previous utterances of the same speaker; this will generally be called after constructing a new instance of this class.

Definition at line 445 of file online-ivector-feature.cc.

References OnlineIvectorFeature::cmvn_, OnlineIvectorExtractorAdaptationState::cmvn_state, OnlineIvectorExtractorAdaptationState::ivector_stats, OnlineIvectorFeature::ivector_stats_, OnlineIvectorEstimationStats::IvectorDim(), KALDI_ASSERT, OnlineIvectorFeature::num_frames_stats_, and OnlineCmvn::SetState().

Referenced by main(), and OnlineNnet2FeaturePipeline::SetAdaptationState().

                                                                   {
  KALDI_ASSERT(num_frames_stats_ == 0 &&
               "SetAdaptationState called after frames were processed.");
  KALDI_ASSERT(ivector_stats_.IvectorDim() ==
               adaptation_state.ivector_stats.IvectorDim());
  ivector_stats_ = adaptation_state.ivector_stats;
  cmvn_->SetState(adaptation_state.cmvn_state);
}

UbmLogLikePerFrame()

BaseFloat UbmLogLikePerFrame

(

)

const

Definition at line 455 of file online-ivector-feature.cc.

References OnlineIvectorFeature::NumFrames(), and OnlineIvectorFeature::tot_ubm_loglike_.

Referenced by main().

                                                         {
  if (NumFrames() == 0) return 0;
  else return tot_ubm_loglike_ / NumFrames();
}

UpdateFrameWeights()

void UpdateFrameWeights

(

const std::vector< std::pair< int32, BaseFloat > > &

delta_weights

)

Definition at line 169 of file online-ivector-feature.cc.

References rnnlm::i, and KALDI_ASSERT.

Referenced by main(), SingleUtteranceNnet2DecoderThreaded::RunNnetEvaluationInternal(), and OnlineNnet2FeaturePipeline::UpdateFrameWeights().

                                                                {
  // add the elements to delta_weights_, which is a priority queue.  The top
  // element of the priority queue is the lowest numbered frame (we ensured this
  // by making the comparison object std::greater instead of std::less).  Adding
  // elements from top (lower-numbered frames) to bottom (higher-numbered
  // frames) should be most efficient, assuming it's a heap internally.  So we
  // go forward not backward in delta_weights while adding.
  for (size_t i = 0; i < delta_weights.size(); i++) {
    delta_weights_.push(delta_weights[i]);
    int32 frame = delta_weights[i].first;
    KALDI_ASSERT(frame >= 0);
    if (frame > most_recent_frame_with_weight_)
      most_recent_frame_with_weight_ = frame;
  }
  delta_weights_provided_ = true;
}

UpdateStatsForFrames()

void UpdateStatsForFrames ( const std::vector< std::pair< int32, BaseFloat > > &  frame_weights )

private

Definition at line 201 of file online-ivector-feature.cc.

References rnnlm::i, rnnlm::j, kaldi::kUndefined, kaldi::MergePairVectorSumming(), MatrixBase< Real >::Row(), and kaldi::VectorToPosteriorEntry().

                                                                   {

  std::vector<std::pair<int32, BaseFloat> > frame_weights(frame_weights_in);
  // Remove duplicates of frames.
  MergePairVectorSumming(&frame_weights);

  if (frame_weights.empty())
    return;

  int32 num_frames = static_cast<int32>(frame_weights.size());
  int32 feat_dim = lda_normalized_->Dim();
  Matrix<BaseFloat> feats(num_frames, feat_dim, kUndefined),
      log_likes;

  std::vector<int32> frames;
  frames.reserve(frame_weights.size());
  for (int32 i = 0; i < num_frames; i++)
    frames.push_back(frame_weights[i].first);
  lda_normalized_->GetFrames(frames, &feats);

  info_.diag_ubm.LogLikelihoods(feats, &log_likes);

  // "posteriors" stores, for each frame index in the range of frames, the
  // pruned posteriors for the Gaussians in the UBM.
  std::vector<std::vector<std::pair<int32, BaseFloat> > > posteriors(num_frames);
  for (int32 i = 0; i < num_frames; i++) {
    std::vector<std::pair<int32, BaseFloat> > &posterior = posteriors[i];
    BaseFloat weight = frame_weights[i].second;
    if (weight != 0.0) {
      tot_ubm_loglike_ += weight *
          VectorToPosteriorEntry(log_likes.Row(i), info_.num_gselect,
                                 GetMinPost(weight), &posterior);
      for (size_t j = 0; j < posterior.size(); j++)
        posterior[j].second *= info_.posterior_scale * weight;
    }
  }

  if (! info_.online_cmvn_iextractor) {
    lda_->GetFrames(frames, &feats);  // default, get features without OnlineCmvn
  } else {
    lda_normalized_->GetFrames(frames, &feats); // get features with OnlineCmvn
  }
  ivector_stats_.AccStats(info_.extractor, feats, posteriors);
}

UpdateStatsUntilFrame()

void UpdateStatsUntilFrame ( int32  frame )

private

Definition at line 248 of file online-ivector-feature.cc.

References KALDI_ASSERT.

                                                            {
  KALDI_ASSERT(frame >= 0 && frame < this->NumFramesReady() &&
               !delta_weights_provided_);
  updated_with_no_delta_weights_ = true;

  int32 ivector_period = info_.ivector_period;
  int32 num_cg_iters = info_.num_cg_iters;

  std::vector<std::pair<int32, BaseFloat> > frame_weights;

  for (; num_frames_stats_ <= frame; num_frames_stats_++) {
    int32 t = num_frames_stats_;
    BaseFloat frame_weight = 1.0;
    frame_weights.push_back(std::pair<int32, BaseFloat>(t, frame_weight));
    if ((!info_.use_most_recent_ivector && t % ivector_period == 0) ||
        (info_.use_most_recent_ivector && t == frame)) {
      // The call below to UpdateStatsForFrames() is equivalent to doing, for
      // all valid indexes i:
      //  UpdateStatsForFrame(cur_start_frame + i, frame_weights[i])
      UpdateStatsForFrames(frame_weights);
      frame_weights.clear();
      ivector_stats_.GetIvector(num_cg_iters, &current_ivector_);
      if (!info_.use_most_recent_ivector) {  // need to cache iVectors.
        int32 ivec_index = t / ivector_period;
        KALDI_ASSERT(ivec_index == static_cast<int32>(ivectors_history_.size()));
        ivectors_history_.push_back(new Vector<BaseFloat>(current_ivector_));
      }
    }
  }
  if (!frame_weights.empty())
    UpdateStatsForFrames(frame_weights);
}

UpdateStatsUntilFrameWeighted()

void UpdateStatsUntilFrameWeighted ( int32  frame )

private

Definition at line 281 of file online-ivector-feature.cc.

References KALDI_ASSERT.

                                                                    {
  KALDI_ASSERT(frame >= 0 && frame < this->NumFramesReady() &&
               delta_weights_provided_ &&
               ! updated_with_no_delta_weights_ &&
               frame <= most_recent_frame_with_weight_);
  bool debug_weights = false;

  int32 ivector_period = info_.ivector_period;
  int32 num_cg_iters = info_.num_cg_iters;

  std::vector<std::pair<int32, BaseFloat> > frame_weights;
  frame_weights.reserve(delta_weights_.size());

  for (; num_frames_stats_ <= frame; num_frames_stats_++) {
    int32 t = num_frames_stats_;
    // Instead of just updating frame t, we update all frames that need updating
    // with index <= t, in case old frames were reclassified as silence/nonsilence.
    while (!delta_weights_.empty() &&
           delta_weights_.top().first <= t) {
      int32 frame = delta_weights_.top().first;
      BaseFloat weight = delta_weights_.top().second;
      frame_weights.push_back(delta_weights_.top());
      delta_weights_.pop();
      if (debug_weights) {
        if (current_frame_weight_debug_.size() <= frame)
          current_frame_weight_debug_.resize(frame + 1, 0.0);
        current_frame_weight_debug_[frame] += weight;
      }
    }
    if ((!info_.use_most_recent_ivector && t % ivector_period == 0) ||
        (info_.use_most_recent_ivector && t == frame)) {
      UpdateStatsForFrames(frame_weights);
      frame_weights.clear();
      ivector_stats_.GetIvector(num_cg_iters, &current_ivector_);
      if (!info_.use_most_recent_ivector) {  // need to cache iVectors.
        int32 ivec_index = t / ivector_period;
        KALDI_ASSERT(ivec_index == static_cast<int32>(ivectors_history_.size()));
        ivectors_history_.push_back(new Vector<BaseFloat>(current_ivector_));
      }
    }
  }
  if (!frame_weights.empty())
    UpdateStatsForFrames(frame_weights);
}

Member Data Documentation

base_

OnlineFeatureInterface* base_

private

Definition at line 352 of file online-ivector-feature.h.

cmvn_

OnlineCmvn* cmvn_

private

Definition at line 356 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::OnlineIvectorFeature(), and OnlineIvectorFeature::SetAdaptationState().

current_frame_weight_debug_

std::vector<BaseFloat> current_frame_weight_debug_

private

this is only used for validating that the frame-weighting code is not buggy.

Definition at line 385 of file online-ivector-feature.h.

current_ivector_

Vector<double> current_ivector_

private

Most recently estimated iVector, will have been estimated at the greatest time t where t <= num_frames_stats_ and t % info_.ivector_period == 0.

Definition at line 404 of file online-ivector-feature.h.

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

delta_weights_

std::priority_queue<std::pair<int32, BaseFloat>, std::vector<std::pair<int32, BaseFloat> >, std::greater<std::pair<int32, BaseFloat> > > delta_weights_

private

delta_weights_ is written to by UpdateFrameWeights, in the case where the iVector estimation is silence-weighted using the decoder traceback.

Its elements are consumed by UpdateStatsUntilFrameWeighted(). We provide std::greater<std::pair<int32, BaseFloat> > > as the comparison type (default is std::less) so that the lowest-numbered frame, not the highest-numbered one, will be returned by top().

Definition at line 382 of file online-ivector-feature.h.

delta_weights_provided_

bool delta_weights_provided_

private

delta_weights_provided_ is set to true if UpdateFrameWeights was ever called; it's used to detect wrong usage of this class.

Definition at line 389 of file online-ivector-feature.h.

info_

const OnlineIvectorExtractionInfo& info_

private

Definition at line 350 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::OnlineIvectorFeature().

ivector_stats_

OnlineIvectorEstimationStats ivector_stats_

private

the iVector estimation stats

Definition at line 364 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::ObjfImprPerFrame(), and OnlineIvectorFeature::SetAdaptationState().

ivectors_history_

std::vector<Vector<BaseFloat>* > ivectors_history_

private

if info_.use_most_recent_ivector == false, we need to store the iVector we estimated each info_.ivector_period frames so that GetFrame() can return the iVector that was active on that frame.

ivectors_history_[i] contains the iVector we estimated on frame t = i * info_.ivector_period.

Definition at line 411 of file online-ivector-feature.h.

lda_

OnlineFeatureInterface* lda_

private

Definition at line 355 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::OnlineIvectorFeature().

lda_normalized_

OnlineFeatureInterface* lda_normalized_

private

Definition at line 357 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::OnlineIvectorFeature().

most_recent_frame_with_weight_

int32 most_recent_frame_with_weight_

private

if delta_weights_ was ever called, this keeps track of the most recent frame that ever had a weight.

It's mostly for detecting errors.

Definition at line 396 of file online-ivector-feature.h.

num_frames_stats_

int32 num_frames_stats_

private

num_frames_stats_ is the number of frames of data we have already accumulated from this utterance and put in ivector_stats_.

Each frame t < num_frames_stats_ is in the stats. In case you are doing the silence-weighted iVector estimation, with UpdateFrameWeights() being called, this variable is still used but you may later have to revisit earlier frames to adjust their weights... see the code.

Definition at line 372 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::SetAdaptationState().

to_delete_

std::vector<OnlineFeatureInterface*> to_delete_

private

Definition at line 361 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::OnlineIvectorFeature().

tot_ubm_loglike_

double tot_ubm_loglike_

private

The following is only needed for diagnostics.

Definition at line 399 of file online-ivector-feature.h.

Referenced by OnlineIvectorFeature::UbmLogLikePerFrame().

updated_with_no_delta_weights_

bool updated_with_no_delta_weights_

private

The following is also used to detect wrong usage of this class; it's set to true if UpdateStatsUntilFrame() was ever called.

Definition at line 392 of file online-ivector-feature.h.

---

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

• online2/online-ivector-feature.h
• online2/online-ivector-feature.cc