#include <online-feat-input.h>

Inheritance diagram for OnlineCmnInput:

Collaboration diagram for OnlineCmnInput:

[legend]

Public Member Functions
	OnlineCmnInput (OnlineFeatInputItf *input, int32 cmn_window, int32 min_window)

virtual bool	Compute (Matrix< BaseFloat > *output)

virtual int32	Dim () const

Public Member Functions inherited from OnlineFeatInputItf
virtual	~OnlineFeatInputItf ()

Private Member Functions
bool	ComputeInternal (Matrix< BaseFloat > *output)

void	AcceptFrame (const VectorBase< BaseFloat > &input)

void	OutputFrame (VectorBase< BaseFloat > *output)

int32	NumOutputFrames (int32 num_new_frames, bool more_data) const

	KALDI_DISALLOW_COPY_AND_ASSIGN (OnlineCmnInput)

Private Attributes
OnlineFeatInputItf *	input_

const int32	cmn_window_

const int32	min_window_

Matrix< BaseFloat >	history_

int64	t_in_

int64	t_out_

Vector< double >	sum_

Detailed Description

Definition at line 80 of file online-feat-input.h.

Constructor & Destructor Documentation

◆ OnlineCmnInput()

OnlineCmnInput	(	OnlineFeatInputItf *	input,
		int32	cmn_window,
		int32	min_window
	)

inline

Definition at line 88 of file online-feat-input.h.

References OnlineFeatInputItf::Compute(), and KALDI_ASSERT.

       : input_(input), cmn_window_(cmn_window), min_window_(min_window),
         history_(cmn_window + 1, input->Dim()), t_in_(0), t_out_(0),
         sum_(input->Dim()) { KALDI_ASSERT(cmn_window >= min_window && min_window > 0); }

Member Function Documentation

◆ AcceptFrame()

void AcceptFrame ( const VectorBase< BaseFloat > & input )

private

Definition at line 109 of file online-feat-input.cc.

References OnlineCmnInput::cmn_window_, OnlineCmnInput::history_, KALDI_ASSERT, MatrixBase< Real >::Row(), OnlineCmnInput::t_in_, and OnlineCmnInput::t_out_.

Referenced by OnlineCmnInput::ComputeInternal().

                                                                    {
   KALDI_ASSERT(t_in_ <= t_out_ + cmn_window_);
   history_.Row(t_in_ % (cmn_window_ + 1)).CopyFromVec(input);
   t_in_++;
 }

◆ Compute()

bool Compute ( Matrix< BaseFloat > * output )

virtual

Implements OnlineFeatInputItf.

Definition at line 35 of file online-feat-input.cc.

References OnlineCmnInput::ComputeInternal(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Matrix< Real >::Resize(), and OnlineCmnInput::t_in_.

                                                       {
 
   int32 orig_nr = output->NumRows(), orig_nc = output->NumCols();
   int32 initial_t_in = t_in_;
   bool ans;
   while ((ans = ComputeInternal(output))) {
     if (output->NumRows() == 0 &&
         t_in_ != initial_t_in) {
       // we produced no output but added to our internal buffer.
       // Call ComputeInternal again.
       initial_t_in = t_in_;
       output->Resize(orig_nr, orig_nc); // make the same request.
     } else {
       return ans;
     }
   }
   return ans;
   // ans = false.  If ComputeInternal returned false,
   // it means we are done, so no point calling it again.
 }

◆ ComputeInternal()

bool ComputeInternal ( Matrix< BaseFloat > * output )

private

Definition at line 76 of file online-feat-input.cc.

References OnlineCmnInput::AcceptFrame(), OnlineCmnInput::cmn_window_, OnlineFeatInputItf::Compute(), OnlineCmnInput::Dim(), rnnlm::i, OnlineCmnInput::input_, KALDI_ASSERT, MatrixBase< Real >::NumCols(), OnlineCmnInput::NumOutputFrames(), MatrixBase< Real >::NumRows(), OnlineCmnInput::OutputFrame(), Matrix< Real >::Resize(), Matrix< Real >::Swap(), OnlineCmnInput::t_in_, and OnlineCmnInput::t_out_.

Referenced by OnlineCmnInput::Compute().

                                                               {
   KALDI_ASSERT(output->NumRows() > 0 && output->NumCols() == Dim());
 
   Matrix<BaseFloat> input;
   input.Swap(output);
 
   bool more_data = input_->Compute(&input);
 
   int32 num_input_frames = input.NumRows();
 
   int32 output_frames = NumOutputFrames(num_input_frames,
                                         more_data);
   output->Resize(output_frames,
                  output_frames == 0 ? 0 : Dim());
 
   int32 output_counter = 0;
   for (int32 i = 0; i < num_input_frames; i++) {
     AcceptFrame(input.Row(i));
     while (t_in_ >= cmn_window_ && t_out_ < t_in_) {
       // We must output a frame now or we'll overwrite
       // frames we need in the buffer.
       SubVector<BaseFloat> this_frame(*output, output_counter);
       OutputFrame(&this_frame);
       output_counter++;
     }
   }
   for (; output_counter < output_frames; output_counter++) {
     SubVector<BaseFloat> this_frame(*output, output_counter);
     OutputFrame(&this_frame);
   }
   return more_data;
 }

◆ Dim()

virtual int32 Dim ( ) const

inlinevirtual

Implements OnlineFeatInputItf.

Definition at line 95 of file online-feat-input.h.

Referenced by OnlineCmnInput::ComputeInternal().

95 { return input_->Dim(); }

kaldi::OnlineFeatInputItf::Dim

virtual int32 Dim() const =0

kaldi::OnlineCmnInput::input_

OnlineFeatInputItf * input_

Definition: online-feat-input.h:101

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( OnlineCmnInput )

private

◆ NumOutputFrames()

int32 NumOutputFrames	(	int32	num_new_frames,
		bool	more_data
	)		const

private

Definition at line 57 of file online-feat-input.cc.

References OnlineCmnInput::min_window_, OnlineCmnInput::t_in_, and OnlineCmnInput::t_out_.

Referenced by OnlineCmnInput::ComputeInternal().

                                                             {
   // Tells the caller, assuming we get given "num_new_frames" of input (and
   // given knowledge of whether there is more data coming), how many frames
   // would we be able to output?
 
   int32 max_t = t_in_ + num_new_frames;
   if (max_t >= min_window_ || !more_data) {
     // If this takes us to "min_window_" frames, we'll output all we have.
     return num_new_frames + t_in_ - t_out_;
   } else {
     return 0; // We'll wait till we have at least "min_window_" frames.
   }
 }

◆ OutputFrame()

void OutputFrame ( VectorBase< BaseFloat > * output )

private

Definition at line 116 of file online-feat-input.cc.

References VectorBase< Real >::AddVec(), OnlineCmnInput::cmn_window_, VectorBase< Real >::CopyFromVec(), OnlineCmnInput::history_, rnnlm::i, KALDI_ASSERT, OnlineCmnInput::min_window_, MatrixBase< Real >::Row(), OnlineCmnInput::sum_, OnlineCmnInput::t_in_, and OnlineCmnInput::t_out_.

Referenced by OnlineCmnInput::ComputeInternal().

                                                               {
   KALDI_ASSERT(t_out_ < t_in_); // or there is nothing to output.
   // First set "sum_".
   if (t_out_ == 0) { // This is the first request for an output frame,
     // so in general we need to set sum_ to the sum of the first "min_window_"
     // frames.  We will have less than min_window_ frames if the input finished
     // before then (if the input were not finished, we'd not have reached this
     // code).
     int32 num_frames = t_in_ < min_window_ ? t_in_ : min_window_;
     for (int32 i = 0; i < num_frames; i++)
       sum_.AddVec(1.0, history_.Row(i));
   }
   int32 num_history_frames;
   if (t_out_ >= cmn_window_) num_history_frames = cmn_window_;
   else if (t_out_ < min_window_)
     num_history_frames = (t_in_ < min_window_ ? t_in_ : min_window_);
   else
     num_history_frames = t_out_;
 
   SubVector<BaseFloat> input_frame(history_, t_out_ % (cmn_window_ + 1));
   output->CopyFromVec(input_frame);
   output->AddVec(-1.0 / num_history_frames, sum_); // Apply CMN to the output.
 
   // Update sum.
   if (t_out_ >= min_window_)
     sum_.AddVec(1.0, input_frame);
   if (t_out_ >= cmn_window_) { // Remove the frame from "cmn_window_" frames ago.
     sum_.AddVec(-1.0, history_.Row((t_out_ - cmn_window_) % (cmn_window_ + 1)));
     KALDI_ASSERT(t_in_ == t_out_ + 1); // or else the frame indexed t_out_ -
                                        // cmn_window_ would not be the right one.
   }
   t_out_++;
 }