This is the new-style interface to the PLP computation. More...

#include <feature-plp.h>

Collaboration diagram for PlpComputer:

[legend]

Public Types
typedef PlpOptions	Options

Public Member Functions
	PlpComputer (const PlpOptions &opts)

	PlpComputer (const PlpComputer &other)

const FrameExtractionOptions &	GetFrameOptions () const

int32	Dim () const

bool	NeedRawLogEnergy () 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...

	~PlpComputer ()

Private Member Functions
const MelBanks *	GetMelBanks (BaseFloat vtln_warp)

const Vector< BaseFloat > *	GetEqualLoudness (BaseFloat vtln_warp)

PlpComputer &	operator= (const PlpComputer &other)

Private Attributes
PlpOptions	opts_

Vector< BaseFloat >	lifter_coeffs_

Matrix< BaseFloat >	idft_bases_

BaseFloat	log_energy_floor_

std::map< BaseFloat, MelBanks * >	mel_banks_

std::map< BaseFloat, Vector< BaseFloat > *>	equal_loudness_

SplitRadixRealFft< BaseFloat > *	srfft_

Vector< BaseFloat >	mel_energies_duplicated_

Vector< BaseFloat >	autocorr_coeffs_

Vector< BaseFloat >	lpc_coeffs_

Vector< BaseFloat >	raw_cepstrum_

Detailed Description

This is the new-style interface to the PLP computation.

Definition at line 101 of file feature-plp.h.

Member Typedef Documentation

◆ Options

typedef PlpOptions Options

Definition at line 103 of file feature-plp.h.

Constructor & Destructor Documentation

◆ PlpComputer() [1/2]

PlpComputer ( const PlpOptions & opts )

explicit

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

References PlpOptions::cepstral_lifter, kaldi::ComputeLifterCoeffs(), PlpOptions::energy_floor, PlpOptions::frame_opts, PlpComputer::GetMelBanks(), PlpComputer::idft_bases_, kaldi::InitIdftBases(), PlpComputer::lifter_coeffs_, kaldi::Log(), PlpComputer::log_energy_floor_, PlpOptions::lpc_order, PlpOptions::mel_opts, MelBanksOptions::num_bins, PlpOptions::num_ceps, PlpComputer::opts_, FrameExtractionOptions::PaddedWindowSize(), and PlpComputer::srfft_.

                                               :
     opts_(opts), srfft_(NULL),
     mel_energies_duplicated_(opts_.mel_opts.num_bins + 2, kUndefined),
     autocorr_coeffs_(opts_.lpc_order + 1, kUndefined),
     lpc_coeffs_(opts_.lpc_order, kUndefined),
     raw_cepstrum_(opts_.lpc_order, kUndefined) {
 
   if (opts.cepstral_lifter != 0.0) {
     lifter_coeffs_.Resize(opts.num_ceps);
     ComputeLifterCoeffs(opts.cepstral_lifter, &lifter_coeffs_);
   }
   InitIdftBases(opts_.lpc_order + 1, opts_.mel_opts.num_bins + 2,
                 &idft_bases_);
 
   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);
 }

◆ PlpComputer() [2/2]

PlpComputer ( const PlpComputer & other )

Definition at line 52 of file feature-plp.cc.

References PlpComputer::equal_loudness_, PlpComputer::mel_banks_, and PlpComputer::srfft_.

                                                 :
     opts_(other.opts_), lifter_coeffs_(other.lifter_coeffs_),
     idft_bases_(other.idft_bases_), log_energy_floor_(other.log_energy_floor_),
     mel_banks_(other.mel_banks_), equal_loudness_(other.equal_loudness_),
     srfft_(NULL),
     mel_energies_duplicated_(opts_.mel_opts.num_bins + 2, kUndefined),
     autocorr_coeffs_(opts_.lpc_order + 1, kUndefined),
     lpc_coeffs_(opts_.lpc_order, kUndefined),
     raw_cepstrum_(opts_.lpc_order, kUndefined) {
   for (std::map<BaseFloat, MelBanks*>::iterator iter = mel_banks_.begin();
        iter != mel_banks_.end(); ++iter)
     iter->second = new MelBanks(*(iter->second));
   for (std::map<BaseFloat, Vector<BaseFloat>*>::iterator
            iter = equal_loudness_.begin();
        iter != equal_loudness_.end(); ++iter)
     iter->second = new Vector<BaseFloat>(*(iter->second));
   if (other.srfft_ != NULL)
     srfft_ = new SplitRadixRealFft<BaseFloat>(*(other.srfft_));
 }

◆ ~PlpComputer()

~PlpComputer ( )

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

References PlpComputer::equal_loudness_, PlpComputer::mel_banks_, and PlpComputer::srfft_.

                           {
   for (std::map<BaseFloat, MelBanks*>::iterator iter = mel_banks_.begin();
       iter != mel_banks_.end(); ++iter)
     delete iter->second;
   for (std::map<BaseFloat, Vector<BaseFloat>* >::iterator
            iter = equal_loudness_.begin();
        iter != equal_loudness_.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 112 of file feature-plp.cc.

References VectorBase< Real >::ApplyPow(), PlpComputer::autocorr_coeffs_, PlpOptions::cepstral_lifter, PlpOptions::cepstral_scale, PlpOptions::compress_factor, kaldi::ComputeLpc(), kaldi::ComputePowerSpectrum(), VectorBase< Real >::Data(), VectorBase< Real >::Dim(), PlpComputer::Dim(), PlpOptions::energy_floor, PlpOptions::frame_opts, PlpComputer::GetEqualLoudness(), PlpComputer::GetMelBanks(), PlpOptions::htk_compat, rnnlm::i, PlpComputer::idft_bases_, KALDI_ASSERT, kaldi::kNoTrans, PlpComputer::lifter_coeffs_, kaldi::Log(), PlpComputer::log_energy_floor_, kaldi::Lpc2Cepstrum(), PlpComputer::lpc_coeffs_, PlpOptions::lpc_order, PlpComputer::mel_energies_duplicated_, PlpOptions::mel_opts, VectorBase< Real >::MulElements(), MelBanksOptions::num_bins, PlpOptions::num_ceps, PlpComputer::opts_, FrameExtractionOptions::PaddedWindowSize(), VectorBase< Real >::Range(), PlpComputer::raw_cepstrum_, PlpOptions::raw_energy, kaldi::RealFft(), VectorBase< Real >::Scale(), PlpComputer::srfft_, PlpOptions::use_energy, and kaldi::VecVec().

                                                           {
   KALDI_ASSERT(signal_frame->Dim() == opts_.frame_opts.PaddedWindowSize() &&
                feature->Dim() == this->Dim());
 
   const MelBanks &mel_banks = *GetMelBanks(vtln_warp);
   const Vector<BaseFloat> &equal_loudness = *GetEqualLoudness(vtln_warp);
 
 
   KALDI_ASSERT(opts_.num_ceps <= opts_.lpc_order+1);  // our num-ceps includes C0.
 
 
   if (opts_.use_energy && !opts_.raw_energy)
     signal_raw_log_energy = Log(std::max<BaseFloat>(VecVec(*signal_frame, *signal_frame),
                                      std::numeric_limits<float>::min()));
 
   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);  // elements 0 ... signal_frame->Dim()/2
 
   SubVector<BaseFloat> power_spectrum(*signal_frame,
                                       0, signal_frame->Dim() / 2 + 1);
 
   int32 num_mel_bins = opts_.mel_opts.num_bins;
 
   SubVector<BaseFloat> mel_energies(mel_energies_duplicated_, 1, num_mel_bins);
 
   mel_banks.Compute(power_spectrum, &mel_energies);
 
   mel_energies.MulElements(equal_loudness);
 
   mel_energies.ApplyPow(opts_.compress_factor);
 
   // duplicate first and last elements
   mel_energies_duplicated_(0) = mel_energies_duplicated_(1);
   mel_energies_duplicated_(num_mel_bins + 1) =
       mel_energies_duplicated_(num_mel_bins);
 
   autocorr_coeffs_.SetZero();  // In case of NaNs or infs
   autocorr_coeffs_.AddMatVec(1.0, idft_bases_, kNoTrans,
                              mel_energies_duplicated_,  0.0);
 
   BaseFloat residual_log_energy = ComputeLpc(autocorr_coeffs_, &lpc_coeffs_);
 
   residual_log_energy = std::max<BaseFloat>(residual_log_energy,
                                  std::numeric_limits<float>::min());
 
   Lpc2Cepstrum(opts_.lpc_order, lpc_coeffs_.Data(), raw_cepstrum_.Data());
   feature->Range(1, opts_.num_ceps - 1).CopyFromVec(
       raw_cepstrum_.Range(0, opts_.num_ceps - 1));
   (*feature)(0) = residual_log_energy;
 
   if (opts_.cepstral_lifter != 0.0)
     feature->MulElements(lifter_coeffs_);
 
   if (opts_.cepstral_scale != 1.0)
     feature->Scale(opts_.cepstral_scale);
 
   if (opts_.use_energy) {
     if (opts_.energy_floor > 0.0 && signal_raw_log_energy < log_energy_floor_)
       signal_raw_log_energy = log_energy_floor_;
     (*feature)(0) = signal_raw_log_energy;
   }
 
   if (opts_.htk_compat) {  // reorder the features.
     BaseFloat log_energy = (*feature)(0);
     for (int32 i = 0; i < opts_.num_ceps-1; i++)
       (*feature)(i) = (*feature)(i+1);
     (*feature)(opts_.num_ceps-1)  = log_energy;
   }
 }

◆ Dim()

int32 Dim ( ) const

inline

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

Referenced by PlpComputer::Compute().

111 { return opts_.num_ceps; }

kaldi::PlpOptions::num_ceps

int32 num_ceps

Definition: feature-plp.h:46

kaldi::PlpComputer::opts_

PlpOptions opts_

Definition: feature-plp.h:148

◆ GetEqualLoudness()

const Vector< BaseFloat > * GetEqualLoudness ( BaseFloat vtln_warp )

private

Definition at line 97 of file feature-plp.cc.

References PlpComputer::equal_loudness_, kaldi::GetEqualLoudnessVector(), and PlpComputer::GetMelBanks().

Referenced by PlpComputer::Compute().

                                                                           {
   const MelBanks *this_mel_banks = GetMelBanks(vtln_warp);
   Vector<BaseFloat> *ans = NULL;
   std::map<BaseFloat, Vector<BaseFloat>*>::iterator iter
       = equal_loudness_.find(vtln_warp);
   if (iter == equal_loudness_.end()) {
     ans = new Vector<BaseFloat>;
     GetEqualLoudnessVector(*this_mel_banks, ans);
     equal_loudness_[vtln_warp] = ans;
   } else {
     ans = iter->second;
   }
   return ans;
 }

◆ GetFrameOptions()

const FrameExtractionOptions& GetFrameOptions ( ) const

inline

Definition at line 107 of file feature-plp.h.

                                                         {
     return opts_.frame_opts;
   }

◆ GetMelBanks()

const MelBanks * GetMelBanks ( BaseFloat vtln_warp )

private

Definition at line 83 of file feature-plp.cc.

References PlpOptions::frame_opts, PlpComputer::mel_banks_, PlpOptions::mel_opts, and PlpComputer::opts_.

Referenced by PlpComputer::Compute(), PlpComputer::GetEqualLoudness(), and PlpComputer::PlpComputer().

                                                             {
   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;
 }