#include <feature-functions.h>

Collaboration diagram for DeltaFeatures:

Public Member Functions
	DeltaFeatures (const DeltaFeaturesOptions &opts)

void	Process (const MatrixBase< BaseFloat > &input_feats, int32 frame, VectorBase< BaseFloat > *output_frame) const

Private Attributes
DeltaFeaturesOptions	opts_

std::vector< Vector< BaseFloat > >	scales_

Detailed Description

Definition at line 64 of file feature-functions.h.

Constructor & Destructor Documentation

◆ DeltaFeatures()

DeltaFeatures ( const DeltaFeaturesOptions & opts )

explicit

Definition at line 54 of file feature-functions.cc.

References VectorBase< Real >::Dim(), rnnlm::i, rnnlm::j, KALDI_ASSERT, DeltaFeaturesOptions::order, VectorBase< Real >::Scale(), DeltaFeatures::scales_, and DeltaFeaturesOptions::window.

                                                             : opts_(opts) {
   KALDI_ASSERT(opts.order >= 0 && opts.order < 1000);  // just make sure we don't get binary junk.
   // opts will normally be 2 or 3.
   KALDI_ASSERT(opts.window > 0 && opts.window < 1000);  // again, basic sanity check.
   // normally the window size will be two.
 
   scales_.resize(opts.order+1);
   scales_[0].Resize(1);
   scales_[0](0) = 1.0;  // trivial window for 0th order delta [i.e. baseline feats]
 
   for (int32 i = 1; i <= opts.order; i++) {
     Vector<BaseFloat> &prev_scales = scales_[i-1],
         &cur_scales = scales_[i];
     int32 window = opts.window;  // this code is designed to still
     // work if instead we later make it an array and do opts.window[i-1],
     // or something like that. "window" is a parameter specifying delta-window
     // width which is actually 2*window + 1.
     KALDI_ASSERT(window != 0);
     int32 prev_offset = (static_cast<int32>(prev_scales.Dim()-1))/2,
         cur_offset = prev_offset + window;
     cur_scales.Resize(prev_scales.Dim() + 2*window);  // also zeros it.
 
     BaseFloat normalizer = 0.0;
     for (int32 j = -window; j <= window; j++) {
       normalizer += j*j;
       for (int32 k = -prev_offset; k <= prev_offset; k++) {
         cur_scales(j+k+cur_offset) +=
             static_cast<BaseFloat>(j) * prev_scales(k+prev_offset);
       }
     }
     cur_scales.Scale(1.0 / normalizer);
   }
 }

Member Function Documentation

◆ Process()

void Process	(	const MatrixBase< BaseFloat > &	input_feats,
		int32	frame,
		VectorBase< BaseFloat > *	output_frame
	)		const

Definition at line 88 of file feature-functions.cc.

References VectorBase< Real >::AddVec(), VectorBase< Real >::Dim(), rnnlm::i, rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), DeltaFeatures::opts_, DeltaFeaturesOptions::order, MatrixBase< Real >::Row(), DeltaFeatures::scales_, and VectorBase< Real >::SetZero().

Referenced by kaldi::ComputeDeltas(), and OnlineDeltaInput::DeltaComputation().

                                                                        {
   KALDI_ASSERT(frame < input_feats.NumRows());
   int32 num_frames = input_feats.NumRows(),
       feat_dim = input_feats.NumCols();
   KALDI_ASSERT(static_cast<int32>(output_frame->Dim()) == feat_dim * (opts_.order+1));
   output_frame->SetZero();
   for (int32 i = 0; i <= opts_.order; i++) {
     const Vector<BaseFloat> &scales = scales_[i];
     int32 max_offset = (scales.Dim() - 1) / 2;
     SubVector<BaseFloat> output(*output_frame, i*feat_dim, feat_dim);
     for (int32 j = -max_offset; j <= max_offset; j++) {
       // if asked to read
       int32 offset_frame = frame + j;
       if (offset_frame < 0) offset_frame = 0;
       else if (offset_frame >= num_frames)
         offset_frame = num_frames - 1;
       BaseFloat scale = scales(j + max_offset);
       if (scale != 0.0)
         output.AddVec(scale, input_feats.Row(offset_frame));
     }
   }
 }