#include <nnet-am-decodable-simple.h>

Collaboration diagram for DecodableNnetSimple:

[legend]

Public Member Functions
	DecodableNnetSimple (const NnetSimpleComputationOptions &opts, const Nnet &nnet, const VectorBase< BaseFloat > &priors, const MatrixBase< BaseFloat > &feats, CachingOptimizingCompiler compiler, 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 frame, VectorBase< BaseFloat > *output)

BaseFloat	GetOutput (int32 subsampled_frame, int32 pdf_id)

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (DecodableNnetSimple)

void	EnsureFrameIsComputed (int32 subsampled_frame)

void	DoNnetComputation (int32 input_t_start, const MatrixBase< BaseFloat > &input_feats, const VectorBase< BaseFloat > &ivector, int32 output_t_start, int32 num_subsampled_frames)

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

void	CheckAndFixConfigs ()

int32	GetIvectorDim () const

Private Attributes
NnetSimpleComputationOptions	opts_

const Nnet &	nnet_

int32	nnet_left_context_

int32	nnet_right_context_

int32	output_dim_

CuVector< BaseFloat >	log_priors_

const MatrixBase< BaseFloat > &	feats_

int32	num_subsampled_frames_

const VectorBase< BaseFloat > *	ivector_

const MatrixBase< BaseFloat > *	online_ivector_feats_

int32	online_ivector_period_

CachingOptimizingCompiler &	compiler_

Matrix< BaseFloat >	current_log_post_

int32	current_log_post_subsampled_offset_

Detailed Description

Definition at line 148 of file nnet-am-decodable-simple.h.

Constructor & Destructor Documentation

◆ DecodableNnetSimple()

DecodableNnetSimple	(	const NnetSimpleComputationOptions &	opts,
		const Nnet &	nnet,
		const VectorBase< BaseFloat > &	priors,
		const MatrixBase< BaseFloat > &	feats,
		CachingOptimizingCompiler *	compiler,
		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]	opts	The options class. Warning: it includes an acoustic weight, whose default is 0.1; you may sometimes want to change this to 1.0.
[in]	nnet	The neural net that we're going to do the computation with
[in]	priors	Vector of priors– if supplied and nonempty, we subtract the log of these priors from the nnet output.
[in]	feats	The input feature matrix.
[in]	compiler	A pointer to the compiler object to use– this enables the user to maintain a common object in the calling code that will cache computations across decodes. Note: the compiler code has no locking mechanism (and it would be tricky to design one, as we'd need to lock the individual computations also), so the calling code has to make sure that if there are multiple threads, they do not share the same compiler object.
[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 27 of file nnet-am-decodable-simple.cc.

References DecodableNnetSimple::CheckAndFixConfigs(), DecodableNnetSimple::compiler_, DecodableNnetSimple::feats_, NnetSimpleComputationOptions::frame_subsampling_factor, CachingOptimizingCompiler::GetSimpleNnetContext(), kaldi::nnet3::IsSimpleNnet(), KALDI_ASSERT, DecodableNnetSimple::log_priors_, DecodableNnetSimple::nnet_left_context_, DecodableNnetSimple::nnet_right_context_, DecodableNnetSimple::num_subsampled_frames_, and DecodableNnetSimple::opts_.

                                 :
     opts_(opts),
     nnet_(nnet),
     output_dim_(nnet_.OutputDim("output")),
     log_priors_(priors),
     feats_(feats),
     ivector_(ivector), online_ivector_feats_(online_ivectors),
     online_ivector_period_(online_ivector_period),
     compiler_(*compiler),
     current_log_post_subsampled_offset_(0) {
   num_subsampled_frames_ =
       (feats_.NumRows() + opts_.frame_subsampling_factor - 1) /
       opts_.frame_subsampling_factor;
   KALDI_ASSERT(IsSimpleNnet(nnet));
   compiler_.GetSimpleNnetContext(&nnet_left_context_, &nnet_right_context_);
   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!"));
   log_priors_.ApplyLog();
   CheckAndFixConfigs();
 }

Member Function Documentation

◆ CheckAndFixConfigs()

void CheckAndFixConfigs ( )

private

Definition at line 278 of file nnet-am-decodable-simple.cc.

References KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kaldi::Lcm(), and rnnlm::n.

Referenced by DecodableNnetSimple::DecodableNnetSimple().

                                              {
   static bool warned_frames_per_chunk = false;
   int32 nnet_modulus = nnet_.Modulus();
   if (opts_.frame_subsampling_factor < 1 ||
       opts_.frames_per_chunk < 1)
     KALDI_ERR << "--frame-subsampling-factor and --frames-per-chunk must be > 0";
   KALDI_ASSERT(nnet_modulus > 0);
   int32 n = Lcm(opts_.frame_subsampling_factor, nnet_modulus);
 
   if (opts_.frames_per_chunk % n != 0) {
     // round up to the nearest multiple of n.
     int32 frames_per_chunk = n * ((opts_.frames_per_chunk + n - 1) / n);
     if (!warned_frames_per_chunk) {
       warned_frames_per_chunk = true;
       if (nnet_modulus == 1) {
         // simpler error message.
         KALDI_LOG << "Increasing --frames-per-chunk from "
                   << opts_.frames_per_chunk << " to "
                   << frames_per_chunk << " to make it a multiple of "
                   << "--frame-subsampling-factor="
                   << opts_.frame_subsampling_factor;
       } else {
         KALDI_LOG << "Increasing --frames-per-chunk from "
                   << opts_.frames_per_chunk << " to "
                   << frames_per_chunk << " due to "
                   << "--frame-subsampling-factor="
                   << opts_.frame_subsampling_factor << " and "
                   << "nnet shift-invariance modulus = " << nnet_modulus;
       }
     }
     opts_.frames_per_chunk = frames_per_chunk;
   }
 }

◆ DoNnetComputation()

void DoNnetComputation	(	int32	input_t_start,
		const MatrixBase< BaseFloat > &	input_feats,
		const VectorBase< BaseFloat > &	ivector,
		int32	output_t_start,
		int32	num_subsampled_frames
	)

private

Definition at line 215 of file nnet-am-decodable-simple.cc.

References NnetComputer::AcceptInput(), CuMatrixBase< Real >::AddVecToRows(), CachingOptimizingCompiler::Compile(), DecodableAmNnetSimple::compiler_, VectorBase< Real >::Dim(), NnetComputer::GetOutputDestructive(), IoSpecification::has_deriv, rnnlm::i, IoSpecification::indexes, ComputationRequest::inputs, IoSpecification::name, ComputationRequest::need_model_derivative, MatrixBase< Real >::NumRows(), ComputationRequest::outputs, CuMatrix< Real >::Resize(), CuMatrixBase< Real >::Row(), NnetComputer::Run(), CuMatrixBase< Real >::Scale(), ComputationRequest::store_component_stats, and CuMatrix< Real >::Swap().

                                  {
   ComputationRequest request;
   request.need_model_derivative = false;
   request.store_component_stats = false;
 
   bool shift_time = true; // shift the 'input' and 'output' to a consistent
   // time, to take advantage of caching in the compiler.
   // An optimization.
   int32 time_offset = (shift_time ? -output_t_start : 0);
 
   // First add the regular features-- named "input".
   request.inputs.reserve(2);
   request.inputs.push_back(
       IoSpecification("input", time_offset + input_t_start,
                       time_offset + input_t_start + input_feats.NumRows()));
   if (ivector.Dim() != 0) {
     std::vector<Index> indexes;
     indexes.push_back(Index(0, 0, 0));
     request.inputs.push_back(IoSpecification("ivector", indexes));
   }
   IoSpecification output_spec;
   output_spec.name = "output";
   output_spec.has_deriv = false;
   int32 subsample = opts_.frame_subsampling_factor;
   output_spec.indexes.resize(num_subsampled_frames);
   // leave n and x values at 0 (the constructor sets these).
   for (int32 i = 0; i < num_subsampled_frames; i++)
     output_spec.indexes[i].t = time_offset + output_t_start + i * subsample;
   request.outputs.resize(1);
   request.outputs[0].Swap(&output_spec);
 
   std::shared_ptr<const NnetComputation> computation = compiler_.Compile(request);
   Nnet *nnet_to_update = NULL;  // we're not doing any update.
   NnetComputer computer(opts_.compute_config, *computation,
                         nnet_, nnet_to_update);
 
   CuMatrix<BaseFloat> input_feats_cu(input_feats);
   computer.AcceptInput("input", &input_feats_cu);
   CuMatrix<BaseFloat> ivector_feats_cu;
   if (ivector.Dim() > 0) {
     ivector_feats_cu.Resize(1, ivector.Dim());
     ivector_feats_cu.Row(0).CopyFromVec(ivector);
     computer.AcceptInput("ivector", &ivector_feats_cu);
   }
   computer.Run();
   CuMatrix<BaseFloat> cu_output;
   computer.GetOutputDestructive("output", &cu_output);
   // subtract log-prior (divide by prior)
   if (log_priors_.Dim() != 0)
     cu_output.AddVecToRows(-1.0, log_priors_);
   // apply the acoustic scale
   cu_output.Scale(opts_.acoustic_scale);
   current_log_post_.Resize(0, 0);
   // the following statement just swaps the pointers if we're not using a GPU.
   cu_output.Swap(&current_log_post_);
   current_log_post_subsampled_offset_ = output_t_start / subsample;
 }

◆ EnsureFrameIsComputed()

void EnsureFrameIsComputed ( int32 subsampled_frame )

private

Definition at line 93 of file nnet-am-decodable-simple.cc.

References VectorBase< Real >::CopyFromVec(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, and MatrixBase< Real >::NumRows().

                                                                       {
   KALDI_ASSERT(subsampled_frame >= 0 &&
                subsampled_frame < num_subsampled_frames_);
   int32 feature_dim = feats_.NumCols(),
       ivector_dim = GetIvectorDim(),
       nnet_input_dim = nnet_.InputDim("input"),
       nnet_ivector_dim = std::max<int32>(0, nnet_.InputDim("ivector"));
   if (feature_dim != nnet_input_dim)
     KALDI_ERR << "Neural net expects 'input' features with dimension "
               << nnet_input_dim << " but you provided "
               << feature_dim;
   if (ivector_dim != std::max<int32>(0, nnet_.InputDim("ivector")))
     KALDI_ERR << "Neural net expects 'ivector' features with dimension "
               << nnet_ivector_dim << " but you provided " << ivector_dim;
 
   int32 current_subsampled_frames_computed = current_log_post_.NumRows(),
       current_subsampled_offset = current_log_post_subsampled_offset_;
   KALDI_ASSERT(subsampled_frame < current_subsampled_offset ||
                subsampled_frame >= current_subsampled_offset +
                current_subsampled_frames_computed);
 
   // all subsampled frames pertain to the output of the network,
   // they are output frames divided by opts_.frame_subsampling_factor.
   int32 subsampling_factor = opts_.frame_subsampling_factor,
       subsampled_frames_per_chunk = opts_.frames_per_chunk / subsampling_factor,
       start_subsampled_frame = subsampled_frame,
       num_subsampled_frames = std::min<int32>(num_subsampled_frames_ -
                                               start_subsampled_frame,
                                               subsampled_frames_per_chunk),
       last_subsampled_frame = start_subsampled_frame + num_subsampled_frames - 1;
   KALDI_ASSERT(num_subsampled_frames > 0);
   // the output-frame numbers are the subsampled-frame numbers
   int32 first_output_frame = start_subsampled_frame * subsampling_factor,
       last_output_frame = last_subsampled_frame * subsampling_factor;
 
   KALDI_ASSERT(opts_.extra_left_context >= 0 && opts_.extra_right_context >= 0);
   int32 extra_left_context = opts_.extra_left_context,
       extra_right_context = opts_.extra_right_context;
   if (first_output_frame == 0 && opts_.extra_left_context_initial >= 0)
     extra_left_context = opts_.extra_left_context_initial;
   if (last_subsampled_frame == num_subsampled_frames_ - 1 &&
       opts_.extra_right_context_final >= 0)
     extra_right_context = opts_.extra_right_context_final;
   int32 left_context = nnet_left_context_ + extra_left_context,
       right_context = nnet_right_context_ + extra_right_context;
   int32 first_input_frame = first_output_frame - left_context,
       last_input_frame = last_output_frame + right_context,
       num_input_frames = last_input_frame + 1 - first_input_frame;
   Vector<BaseFloat> ivector;
   GetCurrentIvector(first_output_frame,
                     last_output_frame - first_output_frame,
                     &ivector);
 
   Matrix<BaseFloat> input_feats;
   if (first_input_frame >= 0 &&
       last_input_frame < feats_.NumRows()) {
     SubMatrix<BaseFloat> input_feats(feats_.RowRange(first_input_frame,
                                                      num_input_frames));
     DoNnetComputation(first_input_frame, input_feats, ivector,
                       first_output_frame, num_subsampled_frames);
   } else {
     Matrix<BaseFloat> feats_block(num_input_frames, feats_.NumCols());
     int32 tot_input_feats = feats_.NumRows();
     for (int32 i = 0; i < num_input_frames; i++) {
       SubVector<BaseFloat> dest(feats_block, i);
       int32 t = i + first_input_frame;
       if (t < 0) t = 0;
       if (t >= tot_input_feats) t = tot_input_feats - 1;
       const SubVector<BaseFloat> src(feats_, t);
       dest.CopyFromVec(src);
     }
     DoNnetComputation(first_input_frame, feats_block, ivector,
                       first_output_frame, num_subsampled_frames);
   }
 }

◆ GetCurrentIvector()

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

private

Definition at line 181 of file nnet-am-decodable-simple.cc.

References KALDI_ASSERT, and KALDI_ERR.

                                                                         {
   if (ivector_ != NULL) {
     *ivector = *ivector_;
     return;
   } else if (online_ivector_feats_ == NULL) {
     return;
   }
   KALDI_ASSERT(online_ivector_period_ > 0);
   // frame_to_search is the frame that we want to get the most recent iVector
   // for.  We choose a point near the middle of the current window, the concept
   // being that this is the fairest comparison to nnet2.   Obviously we could do
   // better by always taking the last frame's iVector, but decoding with
   // 'online' ivectors is only really a mechanism to simulate online operation.
   int32 frame_to_search = output_t_start + num_output_frames / 2;
   int32 ivector_frame = frame_to_search / online_ivector_period_;
   KALDI_ASSERT(ivector_frame >= 0);
   if (ivector_frame >= online_ivector_feats_->NumRows()) {
     int32 margin = ivector_frame - (online_ivector_feats_->NumRows() - 1);
     if (margin * online_ivector_period_ > 50) {
       // Half a second seems like too long to be explainable as edge effects.
       KALDI_ERR << "Could not get iVector for frame " << frame_to_search
                 << ", only available till frame "
                 << online_ivector_feats_->NumRows()
                 << " * ivector-period=" << online_ivector_period_
                 << " (mismatched --online-ivector-period?)";
     }
     ivector_frame = online_ivector_feats_->NumRows() - 1;
   }
   *ivector = online_ivector_feats_->Row(ivector_frame);
 }

◆ GetIvectorDim()

int32 GetIvectorDim ( ) const

private

Definition at line 84 of file nnet-am-decodable-simple.cc.

                                                {
   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 205 of file nnet-am-decodable-simple.h.

References NnetSimpleComputationOptions::CheckAndFixConfigs(), and KALDI_DISALLOW_COPY_AND_ASSIGN.

Referenced by DecodableAmNnetSimple::LogLikelihood(), and DecodableAmNnetSimpleParallel::LogLikelihood().

                                                                    {
     if (subsampled_frame < current_log_post_subsampled_offset_ ||
         subsampled_frame >= current_log_post_subsampled_offset_ +
                             current_log_post_.NumRows())
       EnsureFrameIsComputed(subsampled_frame);
     return current_log_post_(subsampled_frame -
                              current_log_post_subsampled_offset_,
                              pdf_id);
   }

◆ GetOutputForFrame()

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

Definition at line 171 of file nnet-am-decodable-simple.cc.

References VectorBase< Real >::CopyFromVec().

Referenced by main(), and kaldi::nnet3::TestNnetDecodable().

                                                                            {
   if (subsampled_frame < current_log_post_subsampled_offset_ ||
       subsampled_frame >= current_log_post_subsampled_offset_ +
       current_log_post_.NumRows())
     EnsureFrameIsComputed(subsampled_frame);
   output->CopyFromVec(current_log_post_.Row(
       subsampled_frame - current_log_post_subsampled_offset_));
 }