#include <decodable-simple-looped.h>

Collaboration diagram for DecodableNnetSimpleLooped:

[legend]

Public Member Functions
	DecodableNnetSimpleLooped (const DecodableNnetSimpleLoopedInfo &info, const MatrixBase< BaseFloat > &feats, const VectorBase< BaseFloat > ivector=NULL, const MatrixBase< BaseFloat > online_ivectors=NULL, int32 online_ivector_period=1)
	This constructor takes features as input, and you can either supply a single iVector input, estimated in batch-mode ('ivector'), or 'online' iVectors ('online_ivectors' and 'online_ivector_period', or none at all. More...

int32	NumFrames () const

int32	OutputDim () const

void	GetOutputForFrame (int32 subsampled_frame, VectorBase< BaseFloat > *output)

BaseFloat	GetOutput (int32 subsampled_frame, int32 pdf_id)

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (DecodableNnetSimpleLooped)

void	AdvanceChunk ()

void	AdvanceChunkInternal (const MatrixBase< BaseFloat > &input_feats, const VectorBase< BaseFloat > &ivector)

void	GetCurrentIvector (int32 input_frame, Vector< BaseFloat > *ivector)

int32	GetIvectorDim () const

Private Attributes
const DecodableNnetSimpleLoopedInfo &	info_

NnetComputer	computer_

const MatrixBase< BaseFloat > &	feats_

int32	num_subsampled_frames_

const VectorBase< BaseFloat > *	ivector_

const MatrixBase< BaseFloat > *	online_ivector_feats_

int32	online_ivector_period_

Matrix< BaseFloat >	current_log_post_

int32	num_chunks_computed_

int32	current_log_post_subsampled_offset_

Detailed Description

Definition at line 161 of file decodable-simple-looped.h.

Constructor & Destructor Documentation

◆ DecodableNnetSimpleLooped()

DecodableNnetSimpleLooped	(	const DecodableNnetSimpleLoopedInfo &	info,
		const MatrixBase< BaseFloat > &	feats,
		const VectorBase< BaseFloat > *	ivector = `NULL`,
		const MatrixBase< BaseFloat > *	online_ivectors = `NULL`,
		int32	online_ivector_period = `1`
	)

This constructor takes features as input, and you can either supply a single iVector input, estimated in batch-mode ('ivector'), or 'online' iVectors ('online_ivectors' and 'online_ivector_period', or none at all.

Note: it stores references to all arguments to the constructor, so don't delete them till this goes out of scope.

Parameters

[in]	info	This helper class contains all the static pre-computed information this class needs, and contains a pointer to the neural net.
[in]	feats	The input feature matrix.
[in]	ivector	If you are using iVectors estimated in batch mode, a pointer to the iVector, else NULL.
[in]	ivector	If you are using iVectors estimated in batch mode, a pointer to the iVector, else NULL.
[in]	online_ivectors	If you are using iVectors estimated 'online' a pointer to the iVectors, else NULL.
[in]	online_ivector_period	If you are using iVectors estimated 'online' (i.e. if online_ivectors != NULL) gives the periodicity (in frames) with which the iVectors are estimated.

Definition at line 93 of file decodable-simple-looped.cc.

References DecodableNnetSimpleLooped::feats_, NnetSimpleLoopedComputationOptions::frame_subsampling_factor, DecodableNnetSimpleLooped::info_, KALDI_ASSERT, DecodableNnetSimpleLooped::num_subsampled_frames_, and DecodableNnetSimpleLoopedInfo::opts.

                                 :
     info_(info),
     computer_(info_.opts.compute_config, info_.computation,
               info_.nnet, NULL),  // NULL is 'nnet_to_update'
     feats_(feats),
     ivector_(ivector), online_ivector_feats_(online_ivectors),
     online_ivector_period_(online_ivector_period),
     num_chunks_computed_(0),
     current_log_post_subsampled_offset_(-1) {
   num_subsampled_frames_ =
       (feats_.NumRows() + info_.opts.frame_subsampling_factor - 1) /
       info_.opts.frame_subsampling_factor;
   KALDI_ASSERT(!(ivector != NULL && online_ivectors != NULL));
   KALDI_ASSERT(!(online_ivectors != NULL && online_ivector_period <= 0 &&
                  "You need to set the --online-ivector-period option!"));
 }

Member Function Documentation

◆ AdvanceChunk()

void AdvanceChunk ( )

private

Definition at line 137 of file decodable-simple-looped.cc.

Referenced by DecodableNnetSimpleLooped::GetOutputForFrame().

                                              {
   int32 begin_input_frame, end_input_frame;
   if (num_chunks_computed_ == 0) {
     begin_input_frame = -info_.frames_left_context;
     // note: end is last plus one.
     end_input_frame = info_.frames_per_chunk + info_.frames_right_context;
   } else {
     begin_input_frame = num_chunks_computed_ * info_.frames_per_chunk +
         info_.frames_right_context;
     end_input_frame = begin_input_frame + info_.frames_per_chunk;
   }
   CuMatrix<BaseFloat> feats_chunk(end_input_frame - begin_input_frame,
                                   feats_.NumCols(), kUndefined);
 
   int32 num_features = feats_.NumRows();
   if (begin_input_frame >= 0 && end_input_frame <= num_features) {
     SubMatrix<BaseFloat> this_feats(feats_,
                                     begin_input_frame,
                                     end_input_frame - begin_input_frame,
                                     0, feats_.NumCols());
     feats_chunk.CopyFromMat(this_feats);
   } else {
     Matrix<BaseFloat> this_feats(end_input_frame - begin_input_frame,
                                  feats_.NumCols());
     for (int32 r = begin_input_frame; r < end_input_frame; r++) {
       int32 input_frame = r;
       if (input_frame < 0) input_frame = 0;
       if (input_frame >= num_features) input_frame = num_features - 1;
       this_feats.Row(r - begin_input_frame).CopyFromVec(
           feats_.Row(input_frame));
     }
     feats_chunk.CopyFromMat(this_feats);
   }
   computer_.AcceptInput("input", &feats_chunk);
 
   if (info_.has_ivectors) {
     KALDI_ASSERT(info_.request1.inputs.size() == 2);
     // all but the 1st chunk should have 1 iVector, but no need
     // to assume this.
     int32 num_ivectors = (num_chunks_computed_ == 0 ?
                           info_.request1.inputs[1].indexes.size() :
                           info_.request2.inputs[1].indexes.size());
     KALDI_ASSERT(num_ivectors > 0);
 
     Vector<BaseFloat> ivector;
     // we just get the iVector from the last input frame we needed...
     // we don't bother trying to be 'accurate' in getting the iVectors
     // for their 'correct' frames, because in general using the
     // iVector from as large 't' as possible will be better.
     GetCurrentIvector(end_input_frame, &ivector);
     Matrix<BaseFloat> ivectors(num_ivectors,
                                ivector.Dim());
     ivectors.CopyRowsFromVec(ivector);
     CuMatrix<BaseFloat> cu_ivectors(ivectors);
     computer_.AcceptInput("ivector", &cu_ivectors);
   }
   computer_.Run();
 
   {
     // Note: it's possible in theory that if you had weird recurrence that went
     // directly from the output, the call to GetOutputDestructive() would cause
     // a crash on the next chunk.  If that happens, GetOutput() should be used
     // instead of GetOutputDestructive().  But we don't anticipate this will
     // happen in practice.
     CuMatrix<BaseFloat> output;
     computer_.GetOutputDestructive("output", &output);
 
     if (info_.log_priors.Dim() != 0) {
       // subtract log-prior (divide by prior)
       output.AddVecToRows(-1.0, info_.log_priors);
     }
     // apply the acoustic scale
     output.Scale(info_.opts.acoustic_scale);
     current_log_post_.Resize(0, 0);
     current_log_post_.Swap(&output);
   }
   KALDI_ASSERT(current_log_post_.NumRows() == info_.frames_per_chunk /
                info_.opts.frame_subsampling_factor &&
                current_log_post_.NumCols() == info_.output_dim);
 
   num_chunks_computed_++;
 
   current_log_post_subsampled_offset_ =
       (num_chunks_computed_ - 1) *
       (info_.frames_per_chunk / info_.opts.frame_subsampling_factor);
 }

◆ AdvanceChunkInternal()

void AdvanceChunkInternal	(	const MatrixBase< BaseFloat > &	input_feats,
		const VectorBase< BaseFloat > &	ivector
	)

private

◆ GetCurrentIvector()

void GetCurrentIvector	(	int32	input_frame,
		Vector< BaseFloat > *	ivector
	)

private

Definition at line 225 of file decodable-simple-looped.cc.

References DecodableNnetSimpleLoopedInfo::has_ivectors, DecodableNnetSimpleLooped::info_, DecodableNnetSimpleLooped::ivector_, KALDI_ASSERT, KALDI_ERR, DecodableNnetSimpleLooped::online_ivector_feats_, and DecodableNnetSimpleLooped::online_ivector_period_.

Referenced by DecodableNnetSimpleLooped::AdvanceChunk().

                                                                               {
   if (!info_.has_ivectors)
     return;
   if (ivector_ != NULL) {
     *ivector = *ivector_;
     return;
   } else if (online_ivector_feats_ == NULL) {
     KALDI_ERR << "Neural net expects iVectors but none provided.";
   }
   KALDI_ASSERT(online_ivector_period_ > 0);
   int32 ivector_frame = input_frame / online_ivector_period_;
   KALDI_ASSERT(ivector_frame >= 0);
   if (ivector_frame >= online_ivector_feats_->NumRows())
     ivector_frame = online_ivector_feats_->NumRows() - 1;
   KALDI_ASSERT(ivector_frame >= 0 && "ivector matrix cannot be empty.");
   *ivector = online_ivector_feats_->Row(ivector_frame);
 }

◆ GetIvectorDim()

int32 GetIvectorDim ( ) const

private

Definition at line 127 of file decodable-simple-looped.cc.

References DecodableNnetSimpleLooped::ivector_, and DecodableNnetSimpleLooped::online_ivector_feats_.

                                                      {
   if (ivector_ != NULL)
     return ivector_->Dim();
   else if (online_ivector_feats_ != NULL)
     return online_ivector_feats_->NumCols();
   else
     return 0;
 }

◆ GetOutput()

BaseFloat GetOutput	(	int32	subsampled_frame,
		int32	pdf_id
	)

inline

Definition at line 208 of file decodable-simple-looped.h.

References KALDI_ASSERT, and KALDI_DISALLOW_COPY_AND_ASSIGN.

Referenced by DecodableAmNnetSimpleLooped::LogLikelihood().

                                                                    {
     KALDI_ASSERT(subsampled_frame >= current_log_post_subsampled_offset_ &&
                  "Frames must be accessed in order.");
     while (subsampled_frame >= current_log_post_subsampled_offset_ +
                             current_log_post_.NumRows())
       AdvanceChunk();
     return current_log_post_(subsampled_frame -
                              current_log_post_subsampled_offset_,
                              pdf_id);
   }

◆ GetOutputForFrame()

void GetOutputForFrame	(	int32	subsampled_frame,
		VectorBase< BaseFloat > *	output
	)

Definition at line 116 of file decodable-simple-looped.cc.

References DecodableNnetSimpleLooped::AdvanceChunk(), VectorBase< Real >::CopyFromVec(), DecodableNnetSimpleLooped::current_log_post_, DecodableNnetSimpleLooped::current_log_post_subsampled_offset_, KALDI_ASSERT, MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

Referenced by kaldi::nnet3::TestNnetDecodable().

                                                            {
     KALDI_ASSERT(subsampled_frame >= current_log_post_subsampled_offset_ &&
                  "Frames must be accessed in order.");
     while (subsampled_frame >= current_log_post_subsampled_offset_ +
                             current_log_post_.NumRows())
       AdvanceChunk();
     output->CopyFromVec(current_log_post_.Row(
         subsampled_frame - current_log_post_subsampled_offset_));
 }