Class for computing mel-filterbank features; see Computing MFCC features for more information. More...

#include <feature-fbank.h>

Collaboration diagram for FbankComputer:

[legend]

Public Types
typedef FbankOptions	Options

Public Member Functions
	FbankComputer (const FbankOptions &opts)

	FbankComputer (const FbankComputer &other)

int32	Dim () const

bool	NeedRawLogEnergy () const

const FrameExtractionOptions &	GetFrameOptions () const

void	Compute (BaseFloat signal_raw_log_energy, BaseFloat vtln_warp, VectorBase< BaseFloat > signal_frame, VectorBase< BaseFloat > feature)
	Function that computes one frame of features from one frame of signal. More...

	~FbankComputer ()

Private Member Functions
const MelBanks *	GetMelBanks (BaseFloat vtln_warp)

FbankComputer &	operator= (const FbankComputer &other)

Private Attributes
FbankOptions	opts_

BaseFloat	log_energy_floor_

std::map< BaseFloat, MelBanks * >	mel_banks_

SplitRadixRealFft< BaseFloat > *	srfft_

Detailed Description

Class for computing mel-filterbank features; see Computing MFCC features for more information.

Definition at line 86 of file feature-fbank.h.

Member Typedef Documentation

◆ Options

typedef FbankOptions Options

Definition at line 88 of file feature-fbank.h.

Constructor & Destructor Documentation

◆ FbankComputer() [1/2]

FbankComputer ( const FbankOptions & opts )

explicit

Definition at line 26 of file feature-fbank.cc.

References FbankOptions::energy_floor, FbankOptions::frame_opts, FbankComputer::GetMelBanks(), kaldi::Log(), FbankComputer::log_energy_floor_, FrameExtractionOptions::PaddedWindowSize(), and FbankComputer::srfft_.

                                                     :
     opts_(opts), srfft_(NULL) {
   if (opts.energy_floor > 0.0)
     log_energy_floor_ = Log(opts.energy_floor);
 
   int32 padded_window_size = opts.frame_opts.PaddedWindowSize();
   if ((padded_window_size & (padded_window_size-1)) == 0)  // Is a power of two...
     srfft_ = new SplitRadixRealFft<BaseFloat>(padded_window_size);
 
   // We'll definitely need the filterbanks info for VTLN warping factor 1.0.
   // [note: this call caches it.]
   GetMelBanks(1.0);
 }

◆ FbankComputer() [2/2]

FbankComputer ( const FbankComputer & other )

Definition at line 40 of file feature-fbank.cc.

References FbankComputer::mel_banks_, and FbankComputer::srfft_.

                                                       :
     opts_(other.opts_), log_energy_floor_(other.log_energy_floor_),
     mel_banks_(other.mel_banks_), srfft_(NULL) {
   for (std::map<BaseFloat, MelBanks*>::iterator iter = mel_banks_.begin();
       iter != mel_banks_.end();
       ++iter)
     iter->second = new MelBanks(*(iter->second));
   if (other.srfft_)
     srfft_ = new SplitRadixRealFft<BaseFloat>(*(other.srfft_));
 }

◆ ~FbankComputer()

~FbankComputer ( )

Definition at line 51 of file feature-fbank.cc.

References FbankComputer::mel_banks_, and FbankComputer::srfft_.

                               {
   for (std::map<BaseFloat, MelBanks*>::iterator iter = mel_banks_.begin();
       iter != mel_banks_.end(); ++iter)
     delete iter->second;
   delete srfft_;
 }

Member Function Documentation

◆ Compute()

void Compute	(	BaseFloat	signal_raw_log_energy,
		BaseFloat	vtln_warp,
		VectorBase< BaseFloat > *	signal_frame,
		VectorBase< BaseFloat > *	feature
	)

Function that computes one frame of features from one frame of signal.

Parameters

[in]	signal_raw_log_energy	The log-energy of the frame of the signal prior to windowing and pre-emphasis, or log(numeric_limits<float>::min()), whichever is greater. Must be ignored by this function if this class returns false from this->NeedsRawLogEnergy().
[in]	vtln_warp	The VTLN warping factor that the user wants to be applied when computing features for this utterance. Will normally be 1.0, meaning no warping is to be done. The value will be ignored for feature types that don't support VLTN, such as spectrogram features.
[in]	signal_frame	One frame of the signal, as extracted using the function ExtractWindow() using the options returned by this->GetFrameOptions(). The function will use the vector as a workspace, which is why it's a non-const pointer.
[out]	feature	Pointer to a vector of size this->Dim(), to which the computed feature will be written.

Definition at line 72 of file feature-fbank.cc.

References VectorBase< Real >::ApplyFloor(), VectorBase< Real >::ApplyLog(), VectorBase< Real >::ApplyPow(), MelBanks::Compute(), kaldi::ComputePowerSpectrum(), VectorBase< Real >::Data(), VectorBase< Real >::Dim(), FbankComputer::Dim(), FbankOptions::energy_floor, FbankOptions::frame_opts, FbankComputer::GetMelBanks(), FbankOptions::htk_compat, KALDI_ASSERT, kaldi::Log(), FbankComputer::log_energy_floor_, FbankOptions::mel_opts, MelBanksOptions::num_bins, FbankComputer::opts_, FrameExtractionOptions::PaddedWindowSize(), FbankOptions::raw_energy, kaldi::RealFft(), FbankComputer::srfft_, FbankOptions::use_energy, FbankOptions::use_log_fbank, FbankOptions::use_power, and kaldi::VecVec().

                                                             {
 
   const MelBanks &mel_banks = *(GetMelBanks(vtln_warp));
 
   KALDI_ASSERT(signal_frame->Dim() == opts_.frame_opts.PaddedWindowSize() &&
                feature->Dim() == this->Dim());
 
 
   // Compute energy after window function (not the raw one).
   if (opts_.use_energy && !opts_.raw_energy)
     signal_raw_log_energy = Log(std::max<BaseFloat>(VecVec(*signal_frame, *signal_frame),
                                      std::numeric_limits<float>::epsilon()));
 
   if (srfft_ != NULL)  // Compute FFT using split-radix algorithm.
     srfft_->Compute(signal_frame->Data(), true);
   else  // An alternative algorithm that works for non-powers-of-two.
     RealFft(signal_frame, true);
 
   // Convert the FFT into a power spectrum.
   ComputePowerSpectrum(signal_frame);
   SubVector<BaseFloat> power_spectrum(*signal_frame, 0,
                                       signal_frame->Dim() / 2 + 1);
 
   // Use magnitude instead of power if requested.
   if (!opts_.use_power)
     power_spectrum.ApplyPow(0.5);
 
   int32 mel_offset = ((opts_.use_energy && !opts_.htk_compat) ? 1 : 0);
   SubVector<BaseFloat> mel_energies(*feature,
                                     mel_offset,
                                     opts_.mel_opts.num_bins);
 
   // Sum with mel fiterbanks over the power spectrum
   mel_banks.Compute(power_spectrum, &mel_energies);
   if (opts_.use_log_fbank) {
     // Avoid log of zero (which should be prevented anyway by dithering).
     mel_energies.ApplyFloor(std::numeric_limits<float>::epsilon());
     mel_energies.ApplyLog();  // take the log.
   }
 
   // Copy energy as first value (or the last, if htk_compat == true).
   if (opts_.use_energy) {
     if (opts_.energy_floor > 0.0 && signal_raw_log_energy < log_energy_floor_) {
       signal_raw_log_energy = log_energy_floor_;
     }
     int32 energy_index = opts_.htk_compat ? opts_.mel_opts.num_bins : 0;
     (*feature)(energy_index) = signal_raw_log_energy;
   }
 }

◆ Dim()

int32 Dim ( ) const

inline

Definition at line 93 of file feature-fbank.h.

Referenced by FbankComputer::Compute().

                     {
     return opts_.mel_opts.num_bins + (opts_.use_energy ? 1 : 0);
   }

◆ GetFrameOptions()

const FrameExtractionOptions& GetFrameOptions ( ) const

inline

Definition at line 99 of file feature-fbank.h.

                                                         {
     return opts_.frame_opts;
   }

◆ GetMelBanks()

const MelBanks * GetMelBanks ( BaseFloat vtln_warp )

private

Definition at line 58 of file feature-fbank.cc.

References FbankOptions::frame_opts, FbankComputer::mel_banks_, FbankOptions::mel_opts, and FbankComputer::opts_.

Referenced by FbankComputer::Compute(), and FbankComputer::FbankComputer().

                                                               {
   MelBanks *this_mel_banks = NULL;
   std::map<BaseFloat, MelBanks*>::iterator iter = mel_banks_.find(vtln_warp);
   if (iter == mel_banks_.end()) {
     this_mel_banks = new MelBanks(opts_.mel_opts,
                                   opts_.frame_opts,
                                   vtln_warp);
     mel_banks_[vtln_warp] = this_mel_banks;
   } else {
     this_mel_banks = iter->second;
   }
   return this_mel_banks;
 }