#include <online-feat-input.h>

Inheritance diagram for OnlineLdaInput:

Collaboration diagram for OnlineLdaInput:

[legend]

Public Member Functions
	OnlineLdaInput (OnlineFeatInputItf *input, const Matrix< BaseFloat > &transform, int32 left_context, int32 right_context)

virtual bool	Compute (Matrix< BaseFloat > *output)

virtual int32	Dim () const

Public Member Functions inherited from OnlineFeatInputItf
virtual	~OnlineFeatInputItf ()

Private Member Functions
void	TransformToOutput (const MatrixBase< BaseFloat > &spliced_feats, Matrix< BaseFloat > *output)

void	ComputeNextRemainder (const MatrixBase< BaseFloat > &input)

	KALDI_DISALLOW_COPY_AND_ASSIGN (OnlineLdaInput)

Static Private Member Functions
static void	SpliceFrames (const MatrixBase< BaseFloat > &input1, const MatrixBase< BaseFloat > &input2, const MatrixBase< BaseFloat > &input3, int32 context_window, Matrix< BaseFloat > *output)

Private Attributes
OnlineFeatInputItf *	input_

const int32	input_dim_

const int32	left_context_

const int32	right_context_

Matrix< BaseFloat >	linear_transform_

Vector< BaseFloat >	offset_

Matrix< BaseFloat >	remainder_

Detailed Description

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

Constructor & Destructor Documentation

◆ OnlineLdaInput()

OnlineLdaInput	(	OnlineFeatInputItf *	input,
		const Matrix< BaseFloat > &	transform,
		int32	left_context,
		int32	right_context
	)

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

References MatrixBase< Real >::CopyFromMat(), OnlineLdaInput::input_dim_, KALDI_ERR, OnlineLdaInput::linear_transform_, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), OnlineLdaInput::offset_, MatrixBase< Real >::Range(), and Matrix< Real >::Resize().

                                                    :
     input_(input), input_dim_(input->Dim()),
     left_context_(left_context), right_context_(right_context) {
 
   int32 tot_context = left_context + 1 + right_context;
   if (transform.NumCols() == input_dim_ * tot_context) {
     linear_transform_ = transform;
     // and offset_ stays empty.
   } else if (transform.NumCols() == input_dim_ * tot_context + 1) {
     linear_transform_.Resize(transform.NumRows(), transform.NumCols() - 1);
     linear_transform_.CopyFromMat(transform.Range(0, transform.NumRows(),
                                            0, transform.NumCols() - 1));
     offset_.Resize(transform.NumRows());
     offset_.CopyColFromMat(transform, transform.NumCols() - 1);
   } else {
     KALDI_ERR << "Invalid parameters supplied to OnlineLdaInput";
   }
 }

Member Function Documentation

◆ Compute()

bool Compute ( Matrix< BaseFloat > * output )

virtual

Implements OnlineFeatInputItf.

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

References OnlineFeatInputItf::Compute(), OnlineLdaInput::ComputeNextRemainder(), rnnlm::i, OnlineLdaInput::input_, OnlineLdaInput::input_dim_, KALDI_ASSERT, OnlineLdaInput::left_context_, OnlineLdaInput::linear_transform_, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), OnlineLdaInput::remainder_, Matrix< Real >::Resize(), OnlineLdaInput::right_context_, MatrixBase< Real >::Row(), OnlineLdaInput::SpliceFrames(), and OnlineLdaInput::TransformToOutput().

                                                       {
   KALDI_ASSERT(output->NumRows() > 0 &&
                output->NumCols() == linear_transform_.NumRows());
   // If output->NumRows() == 0, it corresponds to a request for zero frames,
   // which makes no sense.
 
   // We request the same number of frames of data that we were requested.
   Matrix<BaseFloat> input(output->NumRows(), input_dim_);
   bool ans = input_->Compute(&input);
   // If we got no input (timed out) and we're not at the end, we return
   // empty output.
 
   if (input.NumRows() == 0 && ans) {
     output->Resize(0, 0);
     return ans;
   } else if (input.NumRows() == 0 && !ans) {
     // The end of the input stream, but no input this time.
     if (remainder_.NumRows() == 0) {
       output->Resize(0, 0);
       return ans;
     }
   }
 
   // If this is the first segment of the utterance, we put in the
   // initial duplicates of the first frame, numbered "left_context".
   if (remainder_.NumRows() == 0 && input.NumRows() != 0 && left_context_ != 0) {
     remainder_.Resize(left_context_, input_dim_);
     for (int32 i = 0; i < left_context_; i++)
       remainder_.Row(i).CopyFromVec(input.Row(0));
   }
 
   // If this is the last segment, we put in the final duplicates of the
   // last frame, numbered "right_context".
   Matrix<BaseFloat> tail;
   if (!ans && right_context_ > 0) {
     tail.Resize(right_context_, input_dim_);
     for (int32 i = 0; i < right_context_; i++) {
       if (input.NumRows() > 0)
         tail.Row(i).CopyFromVec(input.Row(input.NumRows() - 1));
       else
         tail.Row(i).CopyFromVec(remainder_.Row(remainder_.NumRows() - 1));
     }
   }
 
   Matrix<BaseFloat> spliced_feats;
   int32 context_window = left_context_ + 1 + right_context_;
   // The next line is a call to a member function.
   SpliceFrames(remainder_, input, tail, context_window, &spliced_feats);
   TransformToOutput(spliced_feats, output);
   ComputeNextRemainder(input);
   return ans;
 }

◆ ComputeNextRemainder()

void ComputeNextRemainder ( const MatrixBase< BaseFloat > & input )

private

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

References VectorBase< Real >::CopyFromVec(), rnnlm::i, OnlineLdaInput::input_dim_, OnlineLdaInput::left_context_, MatrixBase< Real >::NumRows(), OnlineLdaInput::remainder_, Matrix< Real >::Resize(), OnlineLdaInput::right_context_, and MatrixBase< Real >::Row().

Referenced by OnlineLdaInput::Compute().

                                                                             {
   // The size of the remainder that we propagate to the next frame is
   // context_window - 1, if available.
   int32 context_window = left_context_ + 1 + right_context_;
   int32 next_remainder_len = std::min(context_window - 1,
                                       remainder_.NumRows() + input.NumRows());
   if (next_remainder_len == 0) {
     remainder_.Resize(0, 0);
     return;
   }
   Matrix<BaseFloat> next_remainder(next_remainder_len, input_dim_);
   int32 rsize = remainder_.NumRows(), isize = input.NumRows();
   for (int32 i = 0; i < next_remainder_len; i++) {
     SubVector<BaseFloat> dest(next_remainder, i);
     int32 t = (rsize + isize) - next_remainder_len + i;
     // Here, t is an offset into a numbering of the frames where we first have
     // the old "remainder" frames, then the regular frames.
     if (t < rsize) dest.CopyFromVec(remainder_.Row(t));
     else dest.CopyFromVec(input.Row(t - rsize));
   }
   remainder_ = next_remainder;
 }

◆ Dim()

virtual int32 Dim ( ) const

inlinevirtual

Implements OnlineFeatInputItf.

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

References kaldi::SpliceFrames().

195 { return linear_transform_.NumRows(); }

kaldi::MatrixBase::NumRows

MatrixIndexT NumRows() const

Returns number of rows (or zero for empty matrix).

Definition: kaldi-matrix.h:64

kaldi::OnlineLdaInput::linear_transform_

Matrix< BaseFloat > linear_transform_

Definition: online-feat-input.h:219

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( OnlineLdaInput )

private

◆ SpliceFrames()

void SpliceFrames	(	const MatrixBase< BaseFloat > &	input1,
		const MatrixBase< BaseFloat > &	input2,
		const MatrixBase< BaseFloat > &	input3,
		int32	context_window,
		Matrix< BaseFloat > *	output
	)

staticprivate

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

References VectorBase< Real >::CopyFromVec(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Matrix< Real >::Resize(), and MatrixBase< Real >::Row().

Referenced by OnlineLdaInput::Compute().

                                                              {
   KALDI_ASSERT(context_window > 0);
   const int32 size1 = input1.NumRows(), size2 = input2.NumRows(),
       size3 = input3.NumRows();
   int32 num_frames_in = size1 + size2 + size3,
       num_frames_out = num_frames_in - (context_window - 1),
       dim = std::max(input1.NumCols(), std::max(input2.NumCols(), input3.NumCols()));
   // do std::max in case one or more of the input matrices is empty.
 
   if (num_frames_out <= 0) {
     output->Resize(0, 0);
     return;
   }
   output->Resize(num_frames_out, dim * context_window);
   for (int32 t_out = 0; t_out < num_frames_out; t_out++) {
     for (int32 pos = 0; pos < context_window; pos++) {
       int32 t_in = t_out + pos;
       SubVector<BaseFloat> vec_out(output->Row(t_out), pos * dim, dim);
       if (t_in < size1)
         vec_out.CopyFromVec(input1.Row(t_in));
       else if (t_in < size1 + size2)
         vec_out.CopyFromVec(input2.Row(t_in - size1));
       else
         vec_out.CopyFromVec(input3.Row(t_in - size1 - size2));
     }
   }
 }

◆ TransformToOutput()

void TransformToOutput	(	const MatrixBase< BaseFloat > &	spliced_feats,
		Matrix< BaseFloat > *	output
	)

private

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

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddVecToRows(), kaldi::kNoTrans, kaldi::kTrans, OnlineLdaInput::linear_transform_, MatrixBase< Real >::NumRows(), OnlineLdaInput::offset_, and Matrix< Real >::Resize().

Referenced by OnlineLdaInput::Compute().

                                                                   {
   if (spliced_feats.NumRows() == 0) {
     output->Resize(0, 0);
   } else {
     output->Resize(spliced_feats.NumRows(), linear_transform_.NumRows());
     output->AddMatMat(1.0, spliced_feats, kNoTrans,
                       linear_transform_, kTrans, 0.0);
     if (offset_.Dim() != 0)
       output->AddVecToRows(1.0, offset_);
   }
 }