OnlineCmvn Class Reference

This class does an online version of the cepstral mean and [optionally] variance, but note that this is not equivalent to the offline version. More...

#include <online-feature.h>

Inheritance diagram for OnlineCmvn:

Collaboration diagram for OnlineCmvn:

Public Member Functions
virtual int32	Dim () const
virtual bool	IsLastFrame (int32 frame) const
	Returns true if this is the last frame. More...
virtual BaseFloat	FrameShiftInSeconds () const
virtual int32	NumFramesReady () const
	returns the feature dimension. More...
virtual void	GetFrame (int32 frame, VectorBase< BaseFloat > *feat)
	Gets the feature vector for this frame. More...
	OnlineCmvn (const OnlineCmvnOptions &opts, const OnlineCmvnState &cmvn_state, OnlineFeatureInterface *src)
	Initializer that sets the cmvn state. More...
	OnlineCmvn (const OnlineCmvnOptions &opts, OnlineFeatureInterface *src)
	Initializer that does not set the cmvn state: after calling this, you should call SetState(). More...
void	GetState (int32 cur_frame, OnlineCmvnState *cmvn_state)
void	SetState (const OnlineCmvnState &cmvn_state)
void	Freeze (int32 cur_frame)
virtual	~OnlineCmvn ()
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	GetMostRecentCachedFrame (int32 frame, int32 *cached_frame, MatrixBase< double > *stats)
	Get the most recent cached frame of CMVN stats. More...
void	CacheFrame (int32 frame, const MatrixBase< double > &stats)
	Cache this frame of stats. More...
void	InitRingBufferIfNeeded ()
	Initialize ring buffer for caching stats. More...
void	ComputeStatsForFrame (int32 frame, MatrixBase< double > *stats)
	Computes the raw CMVN stats for this frame, making use of (and updating if necessary) the cached statistics in raw_stats_. More...

Static Private Member Functions
static void	SmoothOnlineCmvnStats (const MatrixBase< double > &speaker_stats, const MatrixBase< double > &global_stats, const OnlineCmvnOptions &opts, MatrixBase< double > *stats)
	Smooth the CMVN stats "stats" (which are stored in the normal format as a 2 x (dim+1) matrix), by possibly adding some stats from "global_stats" and/or "speaker_stats", controlled by the config. More...

Private Attributes
OnlineCmvnOptions	opts_
std::vector< int32 >	skip_dims_
OnlineCmvnState	orig_state_
Matrix< double >	frozen_state_
std::vector< Matrix< double > * >	cached_stats_modulo_
std::vector< std::pair< int32, Matrix< double > > >	cached_stats_ring_
Matrix< double >	temp_stats_
Vector< BaseFloat >	temp_feats_
Vector< double >	temp_feats_dbl_
OnlineFeatureInterface *	src_

Detailed Description

This class does an online version of the cepstral mean and [optionally] variance, but note that this is not equivalent to the offline version.

This is necessarily so, as the offline computation involves looking into the future. If you plan to use features normalized with this type of CMVN then you need to train in a `matched' way, i.e. with the same type of features. We normally only do so in the "online" GMM-based decoding, e.g. in online2bin/online2-wav-gmm-latgen-faster.cc; see also the script steps/online/prepare_online_decoding.sh and steps/online/decode.sh.

In the steady state (in the middle of a long utterance), this class accumulates CMVN statistics from the previous "cmn_window" frames (default 600 frames, or 6 seconds), and uses these to normalize the mean and possibly variance of the current frame.

The config variables "speaker_frames" and "global_frames" relate to what happens at the beginning of the utterance when we have seen fewer than "cmn_window" frames of context, and so might not have very good stats to normalize with. Basically, we first augment any existing stats with up to "speaker_frames" frames of stats from previous utterances of the current speaker, and if this doesn't take us up to the required "cmn_window" frame count, we further augment with up to "global_frames" frames of global stats. The global stats are CMVN stats accumulated from training or testing data, that give us a reasonable source of mean and variance for "typical" data.

Definition at line 321 of file online-feature.h.

Constructor & Destructor Documentation

OnlineCmvn() [1/2]

OnlineCmvn	(	const OnlineCmvnOptions &	opts,
		const OnlineCmvnState &	cmvn_state,
		OnlineFeatureInterface *	src
	)

Initializer that sets the cmvn state.

If you don't have previous utterances from the same speaker you are supposed to initialize the CMVN state from some global CMVN stats, which you can get from summing all cmvn stats you have in your training data using "sum-matrix". This just gives it a reasonable starting point at the start of the file. If you do have previous utterances from the same speaker or at least a similar environment, you are supposed to initialize it by calling GetState from the previous utterance

Definition at line 238 of file online-feature.cc.

References KALDI_ERR, OnlineCmvn::SetState(), OnlineCmvnOptions::skip_dims, OnlineCmvn::skip_dims_, and kaldi::SplitStringToIntegers().

                                                   :
    opts_(opts), temp_stats_(2, src->Dim() + 1),
    temp_feats_(src->Dim()), temp_feats_dbl_(src->Dim()),
    src_(src) {
  SetState(cmvn_state);
  if (!SplitStringToIntegers(opts.skip_dims, ":", false, &skip_dims_))
    KALDI_ERR << "Bad --skip-dims option (should be colon-separated list of "
              <<  "integers)";
}

OnlineCmvn() [2/2]

OnlineCmvn	(	const OnlineCmvnOptions &	opts,
		OnlineFeatureInterface *	src
	)

Initializer that does not set the cmvn state: after calling this, you should call SetState().

Definition at line 250 of file online-feature.cc.

References KALDI_ERR, OnlineCmvnOptions::skip_dims, OnlineCmvn::skip_dims_, and kaldi::SplitStringToIntegers().

                                                   :
    opts_(opts), temp_stats_(2, src->Dim() + 1),
    temp_feats_(src->Dim()), temp_feats_dbl_(src->Dim()),
    src_(src) {
  if (!SplitStringToIntegers(opts.skip_dims, ":", false, &skip_dims_))
    KALDI_ERR << "Bad --skip-dims option (should be colon-separated list of "
              <<  "integers)";
}

~OnlineCmvn()

~OnlineCmvn ( )

virtual

Definition at line 331 of file online-feature.cc.

References OnlineCmvn::cached_stats_modulo_, and rnnlm::i.

                        {
  for (size_t i = 0; i < cached_stats_modulo_.size(); i++)
    delete cached_stats_modulo_[i];
  cached_stats_modulo_.clear();
}

Member Function Documentation

CacheFrame()

void CacheFrame ( int32  frame, const MatrixBase< double > &  stats  )

private

Cache this frame of stats.

Definition at line 305 of file online-feature.cc.

References OnlineCmvn::cached_stats_modulo_, OnlineCmvn::cached_stats_ring_, OnlineCmvn::InitRingBufferIfNeeded(), KALDI_ASSERT, KALDI_WARN, OnlineCmvnOptions::modulus, rnnlm::n, and OnlineCmvn::opts_.

Referenced by OnlineCmvn::ComputeStatsForFrame().

                                                                        {
  KALDI_ASSERT(frame >= 0);
  if (frame % opts_.modulus == 0) {  // store in cached_stats_modulo_.
    int32 n = frame / opts_.modulus;
    if (n >= cached_stats_modulo_.size()) {
      // The following assert is a limitation on in what order you can call
      // CacheFrame.  Fortunately the calling code always calls it in sequence,
      // which it has to because you need a previous frame to compute the
      // current one.
      KALDI_ASSERT(n == cached_stats_modulo_.size());
      cached_stats_modulo_.push_back(new Matrix<double>(stats));
    } else {
      KALDI_WARN << "Did not expect to reach this part of code.";
      // do what seems right, but we shouldn't get here.
      cached_stats_modulo_[n]->CopyFromMat(stats);
    }
  } else {  // store in the ring buffer.
    InitRingBufferIfNeeded();
    if (!cached_stats_ring_.empty()) {
      int32 index = frame % cached_stats_ring_.size();
      cached_stats_ring_[index].first = frame;
      cached_stats_ring_[index].second.CopyFromMat(stats);
    }
  }
}

ComputeStatsForFrame()

void ComputeStatsForFrame ( int32  frame, MatrixBase< double > *  stats  )

private

Computes the raw CMVN stats for this frame, making use of (and updating if necessary) the cached statistics in raw_stats_.

This means the (x, x^2, count) stats for the last up to opts_.cmn_window frames.

Definition at line 337 of file online-feature.cc.

References OnlineCmvn::CacheFrame(), OnlineCmvnOptions::cmn_window, VectorBase< Real >::CopyFromVec(), OnlineCmvn::Dim(), OnlineFeatureInterface::GetFrame(), OnlineCmvn::GetMostRecentCachedFrame(), KALDI_ASSERT, OnlineCmvnOptions::normalize_variance, OnlineCmvn::NumFramesReady(), OnlineCmvn::opts_, MatrixBase< Real >::Row(), OnlineCmvn::src_, OnlineCmvn::temp_feats_, and OnlineCmvn::temp_feats_dbl_.

Referenced by OnlineCmvn::Freeze(), and OnlineCmvn::GetFrame().

                                                                     {
  KALDI_ASSERT(frame >= 0 && frame < src_->NumFramesReady());

  int32 dim = this->Dim(), cur_frame;
  GetMostRecentCachedFrame(frame, &cur_frame, stats_out);

  Vector<BaseFloat> &feats(temp_feats_);
  Vector<double> &feats_dbl(temp_feats_dbl_);
  while (cur_frame < frame) {
    cur_frame++;
    src_->GetFrame(cur_frame, &feats);
    feats_dbl.CopyFromVec(feats);
    stats_out->Row(0).Range(0, dim).AddVec(1.0, feats_dbl);
    if (opts_.normalize_variance)
      stats_out->Row(1).Range(0, dim).AddVec2(1.0, feats_dbl);
    (*stats_out)(0, dim) += 1.0;
    // it's a sliding buffer; a frame at the back may be
    // leaving the buffer so we have to subtract that.
    int32 prev_frame = cur_frame - opts_.cmn_window;
    if (prev_frame >= 0) {
      // we need to subtract frame prev_f from the stats.
      src_->GetFrame(prev_frame, &feats);
      feats_dbl.CopyFromVec(feats);
      stats_out->Row(0).Range(0, dim).AddVec(-1.0, feats_dbl);
      if (opts_.normalize_variance)
        stats_out->Row(1).Range(0, dim).AddVec2(-1.0, feats_dbl);
      (*stats_out)(0, dim) -= 1.0;
    }
    CacheFrame(cur_frame, (*stats_out));
  }
}

Dim()

virtual int32 Dim ( ) const

inlinevirtual

Implements OnlineFeatureInterface.

Definition at line 327 of file online-feature.h.

Referenced by OnlineCmvn::ComputeStatsForFrame(), OnlineCmvn::Freeze(), OnlineCmvn::GetFrame(), OnlineCmvn::GetState(), and OnlineCmvn::InitRingBufferIfNeeded().

{ return src_->Dim(); }

FrameShiftInSeconds()

virtual BaseFloat FrameShiftInSeconds ( ) const

inlinevirtual

Implements OnlineFeatureInterface.

Definition at line 332 of file online-feature.h.

                                                {
    return src_->FrameShiftInSeconds();
  }

Freeze()

void Freeze

(

int32

cur_frame

)

Definition at line 454 of file online-feature.cc.

References OnlineCmvn::ComputeStatsForFrame(), OnlineCmvn::Dim(), OnlineCmvn::frozen_state_, OnlineCmvnState::global_cmvn_stats, OnlineCmvn::opts_, OnlineCmvn::orig_state_, OnlineCmvn::SmoothOnlineCmvnStats(), and OnlineCmvnState::speaker_cmvn_stats.

Referenced by OnlineFeaturePipeline::FreezeCmvn().

                                       {
  int32 dim = this->Dim();
  Matrix<double> stats(2, dim + 1);
  // get the raw CMVN stats
  this->ComputeStatsForFrame(cur_frame, &stats);
  // now smooth them.
  SmoothOnlineCmvnStats(orig_state_.speaker_cmvn_stats,
                        orig_state_.global_cmvn_stats,
                        opts_,
                        &stats);
  this->frozen_state_ = stats;
}

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 421 of file online-feature.cc.

References kaldi::ApplyCmvn(), OnlineCmvn::ComputeStatsForFrame(), MatrixBase< Real >::CopyFromMat(), VectorBase< Real >::Data(), VectorBase< Real >::Dim(), OnlineCmvn::Dim(), kaldi::FakeStatsForSomeDims(), OnlineCmvn::frozen_state_, OnlineFeatureInterface::GetFrame(), OnlineCmvnState::global_cmvn_stats, KALDI_ASSERT, kaldi::kUndefined, OnlineCmvnOptions::normalize_mean, OnlineCmvnOptions::normalize_variance, MatrixBase< Real >::NumRows(), OnlineCmvn::opts_, OnlineCmvn::orig_state_, Matrix< Real >::Resize(), OnlineCmvn::skip_dims_, OnlineCmvn::SmoothOnlineCmvnStats(), OnlineCmvnState::speaker_cmvn_stats, OnlineCmvn::src_, and OnlineCmvn::temp_stats_.

Referenced by main().

                                                       {
  src_->GetFrame(frame, feat);
  KALDI_ASSERT(feat->Dim() == this->Dim());
  int32 dim = feat->Dim();
  Matrix<double> &stats(temp_stats_);
  stats.Resize(2, dim + 1, kUndefined);  // Will do nothing if size was correct.
  if (frozen_state_.NumRows() != 0) {  // the CMVN state has been frozen.
    stats.CopyFromMat(frozen_state_);
  } else {
    // first get the raw CMVN stats (this involves caching..)
    this->ComputeStatsForFrame(frame, &stats);
    // now smooth them.
    SmoothOnlineCmvnStats(orig_state_.speaker_cmvn_stats,
                          orig_state_.global_cmvn_stats,
                          opts_,
                          &stats);
  }

  if (!skip_dims_.empty())
    FakeStatsForSomeDims(skip_dims_, &stats);

  // call the function ApplyCmvn declared in ../transform/cmvn.h, which
  // requires a matrix.
  // 1 row; num-cols == dim; stride  == dim.
  SubMatrix<BaseFloat> feat_mat(feat->Data(), 1, dim, dim);
  // the function ApplyCmvn takes a matrix, so form a one-row matrix to give it.
  if (opts_.normalize_mean)
    ApplyCmvn(stats, opts_.normalize_variance, &feat_mat);
  else
    KALDI_ASSERT(!opts_.normalize_variance);
}

GetMostRecentCachedFrame()

void GetMostRecentCachedFrame ( int32  frame, int32 *  cached_frame, MatrixBase< double > *  stats  )

private

Get the most recent cached frame of CMVN stats.

[If no frames were cached, sets up empty stats for frame zero and returns that].

Definition at line 261 of file online-feature.cc.

References OnlineCmvn::cached_stats_modulo_, OnlineCmvn::cached_stats_ring_, MatrixBase< Real >::CopyFromMat(), OnlineCmvn::InitRingBufferIfNeeded(), KALDI_ASSERT, OnlineCmvnOptions::modulus, rnnlm::n, OnlineCmvn::opts_, OnlineCmvnOptions::ring_buffer_size, and MatrixBase< Real >::SetZero().

Referenced by OnlineCmvn::ComputeStatsForFrame().

                                                                     {
  KALDI_ASSERT(frame >= 0);
  InitRingBufferIfNeeded();
  // look for a cached frame on a previous frame as close as possible in time
  // to "frame".  Return if we get one.
  for (int32 t = frame; t >= 0 && t >= frame - opts_.ring_buffer_size; t--) {
    if (t % opts_.modulus == 0) {
      // if this frame should be cached in cached_stats_modulo_, then
      // we'll look there, and we won't go back any further in time.
      break;
    }
    int32 index = t % opts_.ring_buffer_size;
    if (cached_stats_ring_[index].first == t) {
      *cached_frame = t;
      stats->CopyFromMat(cached_stats_ring_[index].second);
      return;
    }
  }
  int32 n = frame / opts_.modulus;
  if (n >= cached_stats_modulo_.size()) {
    if (cached_stats_modulo_.size() == 0) {
      *cached_frame = -1;
      stats->SetZero();
      return;
    } else {
      n = static_cast<int32>(cached_stats_modulo_.size() - 1);
    }
  }
  *cached_frame = n * opts_.modulus;
  KALDI_ASSERT(cached_stats_modulo_[n] != NULL);
  stats->CopyFromMat(*(cached_stats_modulo_[n]));
}

GetState()

void GetState	(	int32	cur_frame,
		OnlineCmvnState *	cmvn_state
	)

Definition at line 467 of file online-feature.cc.

References VectorBase< Real >::CopyFromVec(), OnlineCmvn::Dim(), OnlineCmvnState::frozen_state, OnlineCmvn::frozen_state_, OnlineFeatureInterface::GetFrame(), MatrixBase< Real >::NumRows(), OnlineCmvn::orig_state_, Matrix< Real >::Resize(), MatrixBase< Real >::Row(), OnlineCmvnState::speaker_cmvn_stats, and OnlineCmvn::src_.

Referenced by OnlineFeaturePipeline::GetCmvnState(), OnlineNnet2FeaturePipeline::GetCmvnState(), and main().

                                                      {
  *state_out = this->orig_state_;
  { // This block updates state_out->speaker_cmvn_stats
    int32 dim = this->Dim();
    if (state_out->speaker_cmvn_stats.NumRows() == 0)
      state_out->speaker_cmvn_stats.Resize(2, dim + 1);
    Vector<BaseFloat> feat(dim);
    Vector<double> feat_dbl(dim);
    for (int32 t = 0; t <= cur_frame; t++) {
      src_->GetFrame(t, &feat);
      feat_dbl.CopyFromVec(feat);
      state_out->speaker_cmvn_stats(0, dim) += 1.0;
      state_out->speaker_cmvn_stats.Row(0).Range(0, dim).AddVec(1.0, feat_dbl);
      state_out->speaker_cmvn_stats.Row(1).Range(0, dim).AddVec2(1.0, feat_dbl);
    }
  }
  // Store any frozen state (the effect of the user possibly
  // having called Freeze().
  state_out->frozen_state = frozen_state_;
}

InitRingBufferIfNeeded()

void InitRingBufferIfNeeded ( )

inlineprivate

Initialize ring buffer for caching stats.

Definition at line 297 of file online-feature.cc.

References OnlineCmvn::cached_stats_ring_, OnlineCmvn::Dim(), OnlineCmvn::opts_, and OnlineCmvnOptions::ring_buffer_size.

Referenced by OnlineCmvn::CacheFrame(), and OnlineCmvn::GetMostRecentCachedFrame().

                                        {
  if (cached_stats_ring_.empty() && opts_.ring_buffer_size > 0) {
    Matrix<double> temp(2, this->Dim() + 1);
    cached_stats_ring_.resize(opts_.ring_buffer_size,
                              std::pair<int32, Matrix<double> >(-1, temp));
  }
}

IsLastFrame()

virtual bool IsLastFrame ( int32  frame ) const

inlinevirtual

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 329 of file online-feature.h.

                                              {
    return src_->IsLastFrame(frame);
  }

NumFramesReady()

virtual int32 NumFramesReady ( ) const

inlinevirtual

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 337 of file online-feature.h.

Referenced by OnlineCmvn::ComputeStatsForFrame(), OnlineFeaturePipeline::FreezeCmvn(), OnlineFeaturePipeline::GetCmvnState(), OnlineNnet2FeaturePipeline::GetCmvnState(), and OnlineSpliceFrames::GetFrame().

{ return src_->NumFramesReady(); }

SetState()

void SetState

(

const OnlineCmvnState &

cmvn_state

)

Definition at line 489 of file online-feature.cc.

References OnlineCmvn::cached_stats_modulo_, OnlineCmvnState::frozen_state, OnlineCmvn::frozen_state_, KALDI_ASSERT, and OnlineCmvn::orig_state_.

Referenced by OnlineCmvn::OnlineCmvn(), OnlineIvectorFeature::SetAdaptationState(), OnlineFeaturePipeline::SetCmvnState(), and OnlineNnet2FeaturePipeline::SetCmvnState().

                                                           {
  KALDI_ASSERT(cached_stats_modulo_.empty() &&
               "You cannot call SetState() after processing data.");
  orig_state_ = cmvn_state;
  frozen_state_ = cmvn_state.frozen_state;
}

SmoothOnlineCmvnStats()

void SmoothOnlineCmvnStats ( const MatrixBase< double > &  speaker_stats, const MatrixBase< double > &  global_stats, const OnlineCmvnOptions &  opts, MatrixBase< double > *  stats  )

staticprivate

Smooth the CMVN stats "stats" (which are stored in the normal format as a 2 x (dim+1) matrix), by possibly adding some stats from "global_stats" and/or "speaker_stats", controlled by the config.

The best way to understand the smoothing rule we use is just to look at the code.

Definition at line 372 of file online-feature.cc.

References MatrixBase< Real >::AddMat(), OnlineCmvnOptions::cmn_window, OnlineCmvnOptions::global_frames, KALDI_ASSERT, KALDI_ERR, OnlineCmvnOptions::normalize_variance, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::RowRange(), and OnlineCmvnOptions::speaker_frames.

Referenced by OnlineCmvn::Freeze(), and OnlineCmvn::GetFrame().

                                                                  {
  if (speaker_stats.NumRows() == 2 && !opts.normalize_variance) {
    // this is just for efficiency: don't operate on the variance if it's not
    // needed.
    int32 cols = speaker_stats.NumCols();  // dim + 1
    SubMatrix<double> stats_temp(*stats, 0, 1, 0, cols);
    SmoothOnlineCmvnStats(speaker_stats.RowRange(0, 1),
                          global_stats.RowRange(0, 1),
                          opts, &stats_temp);
    return;
  }
  int32 dim = stats->NumCols() - 1;
  double cur_count = (*stats)(0, dim);
  // If count exceeded cmn_window it would be an error in how "window_stats"
  // was accumulated.
  KALDI_ASSERT(cur_count <= 1.001 * opts.cmn_window);
  if (cur_count >= opts.cmn_window)
    return;
  if (speaker_stats.NumRows() != 0) {  // if we have speaker stats..
    double count_from_speaker = opts.cmn_window - cur_count,
        speaker_count = speaker_stats(0, dim);
    if (count_from_speaker > opts.speaker_frames)
      count_from_speaker = opts.speaker_frames;
    if (count_from_speaker > speaker_count)
      count_from_speaker = speaker_count;
    if (count_from_speaker > 0.0)
      stats->AddMat(count_from_speaker / speaker_count,
                             speaker_stats);
    cur_count = (*stats)(0, dim);
  }
  if (cur_count >= opts.cmn_window)
    return;
  if (global_stats.NumRows() != 0) {
    double count_from_global = opts.cmn_window - cur_count,
        global_count = global_stats(0, dim);
    KALDI_ASSERT(global_count > 0.0);
    if (count_from_global > opts.global_frames)
      count_from_global = opts.global_frames;
    if (count_from_global > 0.0)
      stats->AddMat(count_from_global / global_count,
                    global_stats);
  } else {
    KALDI_ERR << "Global CMN stats are required";
  }
}

Member Data Documentation

cached_stats_modulo_

std::vector<Matrix<double>*> cached_stats_modulo_

private

Definition at line 431 of file online-feature.h.

Referenced by OnlineCmvn::CacheFrame(), OnlineCmvn::GetMostRecentCachedFrame(), OnlineCmvn::SetState(), and OnlineCmvn::~OnlineCmvn().

cached_stats_ring_

std::vector<std::pair<int32, Matrix<double> > > cached_stats_ring_

private

Definition at line 434 of file online-feature.h.

Referenced by OnlineCmvn::CacheFrame(), OnlineCmvn::GetMostRecentCachedFrame(), and OnlineCmvn::InitRingBufferIfNeeded().

frozen_state_

Matrix<double> frozen_state_

private

Definition at line 423 of file online-feature.h.

Referenced by OnlineCmvn::Freeze(), OnlineCmvn::GetFrame(), OnlineCmvn::GetState(), and OnlineCmvn::SetState().

opts_

OnlineCmvnOptions opts_

private

Definition at line 419 of file online-feature.h.

Referenced by OnlineCmvn::CacheFrame(), OnlineCmvn::ComputeStatsForFrame(), OnlineCmvn::Freeze(), OnlineCmvn::GetFrame(), OnlineCmvn::GetMostRecentCachedFrame(), and OnlineCmvn::InitRingBufferIfNeeded().

orig_state_

OnlineCmvnState orig_state_

private

Definition at line 421 of file online-feature.h.

Referenced by OnlineCmvn::Freeze(), OnlineCmvn::GetFrame(), OnlineCmvn::GetState(), and OnlineCmvn::SetState().

skip_dims_

std::vector<int32> skip_dims_

private

Definition at line 420 of file online-feature.h.

Referenced by OnlineCmvn::GetFrame(), and OnlineCmvn::OnlineCmvn().

src_

OnlineFeatureInterface* src_

private

Definition at line 442 of file online-feature.h.

Referenced by OnlineCmvn::ComputeStatsForFrame(), OnlineCmvn::GetFrame(), OnlineSpliceFrames::GetFrame(), OnlineCmvn::GetState(), and OnlineSpliceFrames::NumFramesReady().

temp_feats_

Vector<BaseFloat> temp_feats_

private

Definition at line 439 of file online-feature.h.

Referenced by OnlineCmvn::ComputeStatsForFrame().

temp_feats_dbl_

Vector<double> temp_feats_dbl_

private

Definition at line 440 of file online-feature.h.

Referenced by OnlineCmvn::ComputeStatsForFrame().

temp_stats_

Matrix<double> temp_stats_

private

Definition at line 438 of file online-feature.h.

Referenced by OnlineCmvn::GetFrame().

---

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

• feat/online-feature.h
• feat/online-feature.cc