This templated class is intended for offline feature extraction, i.e. More...

#include <feature-common.h>

Collaboration diagram for OfflineFeatureTpl< F >:

Public Types
typedef F::Options	Options

Public Member Functions
	OfflineFeatureTpl (const Options &opts)

void	Compute (const VectorBase< BaseFloat > &wave, BaseFloat vtln_warp, Matrix< BaseFloat > *output)

void	Compute (const VectorBase< BaseFloat > &wave, BaseFloat vtln_warp, Matrix< BaseFloat > *output) const

void	ComputeFeatures (const VectorBase< BaseFloat > &wave, BaseFloat sample_freq, BaseFloat vtln_warp, Matrix< BaseFloat > *output)
	Computes the features for one file (one sequence of features). More...

void	ComputeFeatures (const VectorBase< BaseFloat > &wave, BaseFloat sample_freq, BaseFloat vtln_warp, Matrix< BaseFloat > *output) const
	This const version of ComputeFeatures() is a wrapper that calls the non-const ComputeFeatures() on a temporary object that is a copy of *this. More...

int32	Dim () const

	OfflineFeatureTpl (const OfflineFeatureTpl< F > &other)

Private Member Functions
OfflineFeatureTpl< F > &	operator= (const OfflineFeatureTpl< F > &other)

Private Attributes
F	computer_

FeatureWindowFunction	feature_window_function_

Detailed Description

template<class F>
class kaldi::OfflineFeatureTpl< F >

This templated class is intended for offline feature extraction, i.e.

where you have access to the entire signal at the start. It exists mainly to be drop-in replacement for the old (pre-2016) classes Mfcc, Plp and so on, for use in the offline case. In April 2016 we reorganized the online feature-computation code for greater modularity and to have correct support for the snip-edges=false option.

Definition at line 111 of file feature-common.h.

Member Typedef Documentation

typedef F::Options Options

Definition at line 113 of file feature-common.h.

Constructor & Destructor Documentation

OfflineFeatureTpl ( const Options & opts )

inline

Definition at line 117 of file feature-common.h.

                                         :
       computer_(opts),
       feature_window_function_(computer_.GetFrameOptions()) { }

OfflineFeatureTpl ( const OfflineFeatureTpl< F > & other )

inline

Definition at line 169 of file feature-common.h.

                                                       :
       computer_(other.computer_),
       feature_window_function_(other.feature_window_function_) { }

Member Function Documentation

void Compute	(	const VectorBase< BaseFloat > &	wave,
		BaseFloat	vtln_warp,
		Matrix< BaseFloat > *	output
	)

Definition at line 75 of file feature-common-inl.h.

References VectorBase< Real >::Dim(), kaldi::ExtractWindow(), KALDI_ASSERT, kaldi::NumFrames(), and Matrix< Real >::Resize().

Referenced by OfflineFeatureTpl< F >::Compute(), main(), kaldi::TestOnlineAppendFeature(), kaldi::TestOnlineMfcc(), kaldi::TestOnlinePlp(), UnitTestHTKCompare1(), UnitTestHTKCompare2(), UnitTestHTKCompare3(), UnitTestHTKCompare4(), UnitTestHTKCompare5(), UnitTestHTKCompare6(), and UnitTestSimple().

                                {
   KALDI_ASSERT(output != NULL);
   int32 rows_out = NumFrames(wave.Dim(), computer_.GetFrameOptions()),
       cols_out = computer_.Dim();
   if (rows_out == 0) {
     output->Resize(0, 0);
     return;
   }
   output->Resize(rows_out, cols_out);
   Vector<BaseFloat> window;  // windowed waveform.
   bool use_raw_log_energy = computer_.NeedRawLogEnergy();
   for (int32 r = 0; r < rows_out; r++) {  // r is frame index.
     BaseFloat raw_log_energy = 0.0;
     ExtractWindow(0, wave, r, computer_.GetFrameOptions(),
                   feature_window_function_, &window,
                   (use_raw_log_energy ? &raw_log_energy : NULL));
 
     SubVector<BaseFloat> output_row(*output, r);
     computer_.Compute(raw_log_energy, vtln_warp, &window, &output_row);
   }
 }

void Compute	(	const VectorBase< BaseFloat > &	wave,
		BaseFloat	vtln_warp,
		Matrix< BaseFloat > *	output
	)		const

Definition at line 101 of file feature-common-inl.h.

References OfflineFeatureTpl< F >::Compute().

                                      {
   OfflineFeatureTpl<F> temp(*this);
   // call the non-const version of Compute() on a temporary copy of this object.
   // This is a workaround for const-ness that may sometimes be useful in
   // multi-threaded code, although it's not optimally efficient.
   temp.Compute(wave, vtln_warp, output);
 }

void ComputeFeatures	(	const VectorBase< BaseFloat > &	wave,
		BaseFloat	sample_freq,
		BaseFloat	vtln_warp,
		Matrix< BaseFloat > *	output
	)

Computes the features for one file (one sequence of features).

This is the newer interface where you specify the sample frequency of the input waveform.

Parameters

[in]	wave	The input waveform
[in]	sample_freq	The sampling frequency with which 'wave' was sampled. if sample_freq is higher than the frequency specified in the config, we will downsample the waveform, but if lower, it's an error.
[in]	vtln_warp	The VTLN warping factor (will normally be 1.0)
[out]	output	The matrix of features, where the row-index is the frame index.

Definition at line 29 of file feature-common-inl.h.

References kaldi::DownsampleWaveForm(), KALDI_ASSERT, and KALDI_ERR.

Referenced by OfflineFeatureTpl< F >::ComputeFeatures(), and main().

                                {
   KALDI_ASSERT(output != NULL);
   BaseFloat new_sample_freq = computer_.GetFrameOptions().samp_freq;
   if (sample_freq == new_sample_freq)
     Compute(wave, vtln_warp, output);
   else {
     if (new_sample_freq < sample_freq) {
       if (! computer_.GetFrameOptions().allow_downsample)
         KALDI_ERR << "Waveform and config sample Frequency mismatch: "
                   << sample_freq << " .vs " << new_sample_freq
                   << " ( use --allow_downsample=true option to allow "
                   << " downsampling the waveform).";
 
       // Downsample the waveform.
       Vector<BaseFloat> downsampled_wave(wave);
       DownsampleWaveForm(sample_freq, wave,
                          new_sample_freq, &downsampled_wave);
       Compute(downsampled_wave, vtln_warp, output);
     } else
       KALDI_ERR << "The waveform is allowed to get downsampled."
                 << "New sample Frequency " << new_sample_freq
                 << " is larger than waveform original sampling frequency "
                 << sample_freq;
 
   }
 }

void ComputeFeatures	(	const VectorBase< BaseFloat > &	wave,
		BaseFloat	sample_freq,
		BaseFloat	vtln_warp,
		Matrix< BaseFloat > *	output
	)		const

This const version of ComputeFeatures() is a wrapper that calls the non-const ComputeFeatures() on a temporary object that is a copy of *this.

It is not as efficient because of the overhead of copying *this.

Definition at line 61 of file feature-common-inl.h.

References OfflineFeatureTpl< F >::ComputeFeatures().

                                      {
   OfflineFeatureTpl<F> temp(*this);
   // This const version of ComputeFeatures() is a wrapper that
   // calls the non-const ComputeFeatures() on a temporary object
   // that is a copy of *this.  It is not as efficient because of the
   // overhead of copying *this.
   temp.ComputeFeatures(wave, vtln_warp, output);
 }