Decoder object that uses multiple CPU threads for the graph search, plus a GPU for the neural net inference (that's done by a separate NnetBatchComputer object). More...

#include <nnet-batch-compute.h>

Collaboration diagram for NnetBatchDecoder:

[legend]

Classes
struct	UtteranceInput

struct	UtteranceOutput

Public Member Functions
	NnetBatchDecoder (const fst::Fst< fst::StdArc > &fst, const LatticeFasterDecoderConfig &decoder_config, const TransitionModel &trans_model, const fst::SymbolTable word_syms, bool allow_partial, int32 num_threads, NnetBatchComputer computer)
	Constructor. More...

void	AcceptInput (const std::string &utterance_id, const Matrix< BaseFloat > &input, const Vector< BaseFloat > ivector, const Matrix< BaseFloat > online_ivectors, int32 online_ivector_period)
	The user should call this one by one for the utterances that it needs to compute (interspersed with calls to GetOutput()). More...

void	UtteranceFailed ()

int32	Finished ()

bool	GetOutput (std::string utterance_id, CompactLattice clat, std::string *sentence)
	The user should call this to obtain output (This version should only be called if config.determinize_lattice == true (w.r.t. More...

bool	GetOutput (std::string utterance_id, Lattice lat, std::string *sentence)

	~NnetBatchDecoder ()

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (NnetBatchDecoder)

void	Decode ()

void	Compute ()

void	SetPriorities (std::vector< NnetInferenceTask > *tasks)

void	UpdatePriorityOffset (double priority)

void	ProcessOutputUtterance (UtteranceOutput *output)

Static Private Member Functions
static void	DecodeFunc (NnetBatchDecoder *object)

static void	ComputeFunc (NnetBatchDecoder *object)

Private Attributes
const fst::Fst< fst::StdArc > &	fst_

const LatticeFasterDecoderConfig &	decoder_opts_

const TransitionModel &	trans_model_

const fst::SymbolTable *	word_syms_

bool	allow_partial_

NnetBatchComputer *	computer_

std::vector< std::thread * >	decode_threads_

std::thread	compute_thread_

UtteranceInput	input_utterance_

Semaphore	input_ready_semaphore_

Semaphore	input_consumed_semaphore_

Semaphore	tasks_ready_semaphore_

bool	is_finished_

bool	tasks_finished_

std::list< UtteranceOutput * >	pending_utts_

double	priority_offset_

double	tot_like_

int64	frame_count_

int32	num_success_

int32	num_fail_

int32	num_partial_

std::mutex	stats_mutex_

Timer	timer_

Detailed Description

Decoder object that uses multiple CPU threads for the graph search, plus a GPU for the neural net inference (that's done by a separate NnetBatchComputer object).

The interface of this object should accessed from only one thread, though– presumably the main thread of the program.

Definition at line 613 of file nnet-batch-compute.h.

Constructor & Destructor Documentation

◆ NnetBatchDecoder()

NnetBatchDecoder	(	const fst::Fst< fst::StdArc > &	fst,
		const LatticeFasterDecoderConfig &	decoder_config,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		bool	allow_partial,
		int32	num_threads,
		NnetBatchComputer *	computer
	)

Constructor.

Parameters

[in]	fst	FST that we are decoding with, will be shared between all decoder threads.
[in]	decoder_config	Configuration object for the decoders.
[in]	trans_model	The transition model– needed to construct the decoders, and for determinization.
[in]	word_syms	A pointer to a symbol table of words, used for printing the decoded words to stderr. If NULL, the word-level output will not be logged.
[in]	allow_partial	If true, in cases where no final-state was reached on the final frame of the decoding, we still output a lattice; it just may contain partial words (words that are cut off in the middle). If false, we just won't output anything for those lattices.
[in]	num_threads	The number of decoder threads to use. It will use two more threads on top of this: the main thread, for I/O, and a thread for possibly-GPU-based inference.
[in]	computer	The NnetBatchComputer object, through which the neural net will be evaluated.

Definition at line 1188 of file nnet-batch-compute.cc.

References NnetBatchDecoder::compute_thread_, NnetBatchDecoder::ComputeFunc(), NnetBatchDecoder::decode_threads_, NnetBatchDecoder::DecodeFunc(), rnnlm::i, and KALDI_ASSERT.

                                 :
   fst_(fst), decoder_opts_(decoder_opts),
   trans_model_(trans_model), word_syms_(word_syms),
   allow_partial_(allow_partial),  computer_(computer),
   is_finished_(false), tasks_finished_(false), priority_offset_(0.0),
   tot_like_(0.0), frame_count_(0), num_success_(0), num_fail_(0),
   num_partial_(0) {
   KALDI_ASSERT(num_threads > 0);
   for (int32 i = 0; i < num_threads; i++)
     decode_threads_.push_back(new std::thread(DecodeFunc, this));
   compute_thread_ = std::thread(ComputeFunc, this);
 }

◆ ~NnetBatchDecoder()

~NnetBatchDecoder ( )

Definition at line 1497 of file nnet-batch-compute.cc.

References NnetBatchDecoder::computer_, NnetBatchDecoder::decode_threads_, Timer::Elapsed(), NnetBatchDecoder::frame_count_, NnetSimpleComputationOptions::frame_subsampling_factor, NnetBatchComputer::GetOptions(), NnetBatchDecoder::is_finished_, KALDI_ERR, KALDI_LOG, NnetBatchDecoder::num_fail_, NnetBatchDecoder::num_partial_, NnetBatchDecoder::num_success_, NnetBatchDecoder::pending_utts_, NnetBatchDecoder::timer_, and NnetBatchDecoder::tot_like_.

                                     {
   if (!is_finished_ || !pending_utts_.empty()) {
     // At this point the application is bound to fail so raising another
     // exception is not a big problem.
     KALDI_ERR << "Destroying NnetBatchDecoder object without calling "
         "Finished() and consuming the remaining output";
   }
   // Print diagnostics.
 
   kaldi::int64 input_frame_count =
       frame_count_ * computer_->GetOptions().frame_subsampling_factor;
   int32 num_threads = static_cast<int32>(decode_threads_.size());
 
   KALDI_LOG << "Overall likelihood per frame was "
             << tot_like_ / std::max<int64>(1, frame_count_)
             << " over " << frame_count_ << " frames.";
 
   double elapsed = timer_.Elapsed();
   // the +1 below is just to avoid division-by-zero errors.
   KALDI_LOG << "Time taken "<< elapsed
             << "s: real-time factor assuming 100 frames/sec is "
             << (num_threads * elapsed * 100.0 /
                 std::max<int64>(input_frame_count, 1))
             << " (per thread; with " << num_threads << " threads).";
   KALDI_LOG << "Done " << num_success_ << " utterances ("
             << num_partial_ << " forced out); failed for "
             << num_fail_;
 }

Member Function Documentation

◆ AcceptInput()

void AcceptInput	(	const std::string &	utterance_id,
		const Matrix< BaseFloat > &	input,
		const Vector< BaseFloat > *	ivector,
		const Matrix< BaseFloat > *	online_ivectors,
		int32	online_ivector_period
	)

The user should call this one by one for the utterances that it needs to compute (interspersed with calls to GetOutput()).

This call will block when no threads are ready to start processing this utterance.

Parameters

[in]	utterance_id	The string representing the utterance-id; it will be provided back to the user when GetOutput() is called.
[in]	input	The input features (e.g. MFCCs)
[in]	ivector	If non-NULL, this is expected to be the i-vector for this utterance (and 'online_ivectors' should be NULL).
[in]	online_ivector_period	Only relevant if 'online_ivector' is non-NULL, this says how many frames of 'input' is covered by each row of 'online_ivectors'.

Definition at line 1224 of file nnet-batch-compute.cc.

References NnetBatchDecoder::UtteranceInput::input, NnetBatchDecoder::input_consumed_semaphore_, NnetBatchDecoder::input_ready_semaphore_, NnetBatchDecoder::input_utterance_, NnetBatchDecoder::UtteranceInput::ivector, NnetBatchDecoder::UtteranceInput::online_ivector_period, NnetBatchDecoder::UtteranceInput::online_ivectors, NnetBatchDecoder::pending_utts_, Semaphore::Signal(), NnetBatchDecoder::UtteranceInput::utterance_id, NnetBatchDecoder::UtteranceOutput::utterance_id, and Semaphore::Wait().

                                 {
   // This function basically does a handshake with one of the decoder threads.
   // It may have to wait till one of the decoder threads becomes ready.
   input_utterance_.utterance_id = utterance_id;
   input_utterance_.input = &input;
   input_utterance_.ivector = ivector;
   input_utterance_.online_ivectors = online_ivectors;
   input_utterance_.online_ivector_period = online_ivector_period;
 
 
   UtteranceOutput *this_output = new UtteranceOutput();
   this_output->utterance_id = utterance_id;
   pending_utts_.push_back(this_output);
 
   input_ready_semaphore_.Signal();
   input_consumed_semaphore_.Wait();
 }

◆ Compute()

void Compute ( )

private

Definition at line 1329 of file nnet-batch-compute.cc.

References NnetBatchComputer::Compute(), NnetBatchDecoder::computer_, NnetBatchDecoder::tasks_finished_, NnetBatchDecoder::tasks_ready_semaphore_, and Semaphore::Wait().

                                {
   while (!tasks_finished_) {
     tasks_ready_semaphore_.Wait();
     bool allow_partial_minibatch = true;
     while (computer_->Compute(allow_partial_minibatch));
   }
 }

◆ ComputeFunc()

static void ComputeFunc ( NnetBatchDecoder * object )

inlinestaticprivate

Definition at line 760 of file nnet-batch-compute.h.

References NnetInferenceTask::priority.

Referenced by NnetBatchDecoder::NnetBatchDecoder().

760 { object->Compute(); }

◆ Decode()

void Decode ( )

private

Definition at line 1337 of file nnet-batch-compute.cc.

                               {
   while (true) {
     input_ready_semaphore_.Wait();
     if (is_finished_)
       return;
 
     std::vector<NnetInferenceTask> tasks;
     std::string utterance_id;
     // we can be confident that the last element of 'pending_utts_' is the one
     // for this utterance, as we know exactly at what point in the code the main
     // thread will be in AcceptInput().
     UtteranceOutput *output_utterance = pending_utts_.back();
     {
       UtteranceInput input_utterance(input_utterance_);
       utterance_id = input_utterance.utterance_id;
       bool output_to_cpu = true;
       computer_->SplitUtteranceIntoTasks(output_to_cpu,
                                          *(input_utterance.input),
                                          input_utterance.ivector,
                                          input_utterance.online_ivectors,
                                          input_utterance.online_ivector_period,
                                          &tasks);
       KALDI_ASSERT(output_utterance->utterance_id == utterance_id);
       input_consumed_semaphore_.Signal();
       // Now let input_utterance go out of scope; it's no longer valid as it may
       // be overwritten by something else.
     }
 
     SetPriorities(&tasks);
     for (size_t i = 0; i < tasks.size(); i++)
       computer_->AcceptTask(&(tasks[i]));
     tasks_ready_semaphore_.Signal();
 
     {
       int32 frame_offset = 0;
       LatticeFasterDecoder decoder(fst_, decoder_opts_);
       decoder.InitDecoding();
 
 
       for (size_t i = 0; i < tasks.size(); i++) {
         NnetInferenceTask &task = tasks[i];
         task.semaphore.Wait();
         UpdatePriorityOffset(task.priority);
 
         SubMatrix<BaseFloat> post(task.output_cpu,
                                   task.num_initial_unused_output_frames,
                                   task.num_used_output_frames,
                                   0, task.output_cpu.NumCols());
         DecodableMatrixMapped decodable(trans_model_, post, frame_offset);
         frame_offset += post.NumRows();
         decoder.AdvanceDecoding(&decodable);
         task.output.Resize(0, 0);  // Free some memory.
       }
 
       bool use_final_probs = true;
       if (!decoder.ReachedFinal()) {
         if (allow_partial_) {
           KALDI_WARN << "Outputting partial output for utterance "
                      << utterance_id << " since no final-state reached\n";
           use_final_probs = false;
           std::unique_lock<std::mutex> lock(stats_mutex_);
           num_partial_++;
         } else {
           KALDI_WARN << "Not producing output for utterance " << utterance_id
                      << " since no final-state reached and "
                      << "--allow-partial=false.\n";
           std::unique_lock<std::mutex> lock(stats_mutex_);
           num_fail_++;
           continue;
         }
       }
       // if we reached this point, we are getting a lattice.
       decoder.GetRawLattice(&output_utterance->lat, use_final_probs);
       // Let the decoder and the decodable object go out of scope, to save
       // memory.
     }
     ProcessOutputUtterance(output_utterance);
   }
 }

◆ DecodeFunc()

static void DecodeFunc ( NnetBatchDecoder * object )

inlinestaticprivate

Definition at line 755 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::NnetBatchDecoder().

755 { object->Decode(); }

◆ Finished()

int32 Finished ( )

Definition at line 1247 of file nnet-batch-compute.cc.

References NnetBatchDecoder::compute_thread_, NnetBatchDecoder::decode_threads_, rnnlm::i, NnetBatchDecoder::input_ready_semaphore_, NnetBatchDecoder::is_finished_, NnetBatchDecoder::num_success_, Semaphore::Signal(), NnetBatchDecoder::tasks_finished_, and NnetBatchDecoder::tasks_ready_semaphore_.

                                  {
   is_finished_ = true;
   for (size_t i = 0; i < decode_threads_.size(); i++)
     input_ready_semaphore_.Signal();
   for (size_t i = 0; i < decode_threads_.size(); i++) {
     decode_threads_[i]->join();
     delete decode_threads_[i];
     decode_threads_[i] = NULL;
   }
   // don't clear decode_threads_, since its size is needed in the destructor to
   // compute timing.
 
   tasks_finished_ = true;
   tasks_ready_semaphore_.Signal();
   compute_thread_.join();
   return num_success_;
 }

◆ GetOutput() [1/2]

bool GetOutput	(	std::string *	utterance_id,
		CompactLattice *	clat,
		std::string *	sentence
	)

The user should call this to obtain output (This version should only be called if config.determinize_lattice == true (w.r.t.

the config provided to the constructor). The output is guaranteed to be in the same order as the input was provided, but it may be delayed, *and* some outputs may be missing, for example because of search failures (allow_partial will affect this).

The acoustic scores in the output lattice will already be divided by the acoustic scale we decoded with.

This call does not block (i.e. does not wait on any semaphores). It returns true if it actually got any output; if none was ready it will return false.

Parameters

[out]	utterance_id	If an output was ready, its utterance-id is written to here.
[out]	clat	If an output was ready, it compact lattice will be written to here.
[out]	sentence	If an output was ready and a nonempty symbol table was provided to the constructor of this class, contains the word-sequence decoded as a string. Otherwise will be empty.

Returns: Returns true if a decoded output was ready. (These appear asynchronously as the decoding is done in background threads).

Definition at line 1266 of file nnet-batch-compute.cc.

References NnetBatchDecoder::UtteranceOutput::compact_lat, NnetBatchDecoder::decoder_opts_, LatticeFasterDecoderConfig::determinize_lattice, KALDI_ERR, NnetBatchDecoder::pending_utts_, NnetBatchDecoder::UtteranceOutput::sentence, and NnetBatchDecoder::UtteranceOutput::utterance_id.

Referenced by kaldi::HandleOutput().

                          {
   if (!decoder_opts_.determinize_lattice)
     KALDI_ERR << "Don't call this version of GetOutput if you are "
         "not determinizing.";
   while (true) {
     if (pending_utts_.empty())
       return false;
     if (!pending_utts_.front()->finished)
       return false;
     UtteranceOutput *this_output = pending_utts_.front();
     pending_utts_.pop_front();
     if (this_output->compact_lat.NumStates() == 0) {
       delete this_output;
       // ... and continue round the loop, without returning any output to the
       // user for this utterance.  Something went wrong in decoding: for
       // example, the user specified allow_partial == false and no final-states
       // were active on the last frame, or something more unexpected.  A warning
       // would have been printed in the decoder thread.
     } else {
       *clat = this_output->compact_lat;
       utterance_id->swap(this_output->utterance_id);
       sentence->swap(this_output->sentence);
       delete this_output;
       return true;
     }
   }
 }

◆ GetOutput() [2/2]

bool GetOutput	(	std::string *	utterance_id,
		Lattice *	lat,
		std::string *	sentence
	)

Definition at line 1298 of file nnet-batch-compute.cc.

References NnetBatchDecoder::decoder_opts_, LatticeFasterDecoderConfig::determinize_lattice, KALDI_ERR, NnetBatchDecoder::UtteranceOutput::lat, NnetBatchDecoder::pending_utts_, NnetBatchDecoder::UtteranceOutput::sentence, and NnetBatchDecoder::UtteranceOutput::utterance_id.

                          {
   if (decoder_opts_.determinize_lattice)
     KALDI_ERR << "Don't call this version of GetOutput if you are "
         "determinizing.";
   while (true) {
     if (pending_utts_.empty())
       return false;
     if (!pending_utts_.front()->finished)
       return false;
     UtteranceOutput *this_output = pending_utts_.front();
     pending_utts_.pop_front();
     if (this_output->lat.NumStates() == 0) {
       delete this_output;
       // ... and continue round the loop, without returning any output to the
       // user for this utterance.  Something went wrong in decoding: for
       // example, the user specified allow_partial == false and no final-states
       // were active on the last frame, or something more unexpected.  A warning
       // would have been printed in the decoder thread.
     } else {
       *lat = this_output->lat;  // OpenFST has shallow copy so no need to swap.
       utterance_id->swap(this_output->utterance_id);
       sentence->swap(this_output->sentence);
       delete this_output;
       return true;
     }
   }
 }

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( NnetBatchDecoder )

private

◆ ProcessOutputUtterance()

void ProcessOutputUtterance ( UtteranceOutput * output )

private

Definition at line 1423 of file nnet-batch-compute.cc.

References NnetSimpleComputationOptions::acoustic_scale, fst::AcousticLatticeScale(), NnetBatchDecoder::UtteranceOutput::compact_lat, NnetBatchDecoder::computer_, NnetBatchDecoder::decoder_opts_, LatticeFasterDecoderConfig::det_opts, LatticeFasterDecoderConfig::determinize_lattice, fst::DeterminizeLatticePhonePrunedWrapper(), NnetBatchDecoder::UtteranceOutput::finished, NnetBatchDecoder::frame_count_, fst::GetLinearSymbolSequence(), NnetBatchComputer::GetOptions(), rnnlm::i, KALDI_ERR, KALDI_LOG, KALDI_VLOG, KALDI_WARN, NnetBatchDecoder::UtteranceOutput::lat, LatticeFasterDecoderConfig::lattice_beam, NnetBatchDecoder::num_fail_, NnetBatchDecoder::num_success_, fst::ScaleLattice(), NnetBatchDecoder::UtteranceOutput::sentence, NnetBatchDecoder::stats_mutex_, NnetBatchDecoder::tot_like_, NnetBatchDecoder::trans_model_, NnetBatchDecoder::UtteranceOutput::utterance_id, LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), NnetBatchDecoder::word_syms_, and words.

Referenced by NnetBatchDecoder::Decode().

                                                                      {
   fst::Connect(&(output->lat));
   if (output->lat.NumStates() == 0) {
     KALDI_WARN << "Unexpected problem getting lattice for utterance "
                << output->utterance_id;
     std::unique_lock<std::mutex> lock(stats_mutex_);
     num_fail_++;
     return;
   }
 
   { // This block accumulates diagnostics, prints log messages, and sets
     // output->sentence.
     Lattice best_path;
     LatticeWeight weight;
     ShortestPath(output->lat, &best_path);
     std::vector<int32> alignment;
     std::vector<int32> words;
     GetLinearSymbolSequence(best_path, &alignment, &words, &weight);
     int32 num_frames = alignment.size();
     if (word_syms_ != NULL) {
       std::ostringstream os;
       for (size_t i = 0; i < words.size(); i++) {
         std::string s = word_syms_->Find(words[i]);
         if (s == "")
           KALDI_ERR << "Word-id " << words[i] << " not in symbol table.";
         os << s << ' ';
       }
       output->sentence = os.str();
     }
     double likelihood = -(weight.Value1() + weight.Value2());
     // Note: these logging messages will be out-of-order w.r.t. the transcripts
     // that are printed to cerr; we keep those transcripts in the same order
     // that the utterances were in, but these logging messages may be out of
     // order (due to multiple threads).
     KALDI_LOG << "Log-like per frame for utterance " << output->utterance_id
               << " is " << (likelihood / num_frames) << " over "
               << num_frames << " frames.";
     KALDI_VLOG(2) << "Cost for utterance " << output->utterance_id << " is "
                   << weight.Value1() << " + " << weight.Value2();
 
     std::unique_lock<std::mutex> lock(stats_mutex_);
     tot_like_ += likelihood;
     frame_count_ += num_frames;
     num_success_ += 1;
   }
 
   if (decoder_opts_.determinize_lattice) {
     if (!DeterminizeLatticePhonePrunedWrapper(
             trans_model_,
             &output->lat,
             decoder_opts_.lattice_beam,
             &(output->compact_lat),
             decoder_opts_.det_opts))
       KALDI_WARN << "Determinization finished earlier than the beam for "
                  << "utterance " << output->utterance_id;
     output->lat.DeleteStates();  // Save memory.
   }
 
   // We'll write the lattice without acoustic scaling, so we need to reverse
   // the scale that we applied when decoding.
   BaseFloat acoustic_scale = computer_->GetOptions().acoustic_scale;
   if (acoustic_scale != 0.0) {
     if (decoder_opts_.determinize_lattice)
       fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale),
                         &(output->compact_lat));
     else
       fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale),
                         &(output->lat));
   }
   output->finished = true;
 }

◆ SetPriorities()

void SetPriorities ( std::vector< NnetInferenceTask > * tasks )

private

Definition at line 1208 of file nnet-batch-compute.cc.

References rnnlm::i, and NnetBatchDecoder::priority_offset_.

Referenced by NnetBatchDecoder::Decode().

                                                                         {
   size_t num_tasks = tasks->size();
   double priority_offset = priority_offset_;
   for (size_t i = 0; i < num_tasks; i++)
     (*tasks)[i].priority = priority_offset - (double)i;
 }

◆ UpdatePriorityOffset()

void UpdatePriorityOffset ( double priority )

private

Definition at line 1215 of file nnet-batch-compute.cc.

References NnetBatchDecoder::decode_threads_, and NnetBatchDecoder::priority_offset_.

Referenced by NnetBatchDecoder::Decode().

                                                            {
   size_t num_tasks = decode_threads_.size(),
       new_weight = 1.0 / num_tasks,
       old_weight = 1.0 - new_weight;
   // The next line is vulnerable to a race condition but if it happened it
   // wouldn't matter.
   priority_offset_ = priority_offset_ * old_weight + priority * new_weight;
 }

◆ UtteranceFailed()

void UtteranceFailed ( )

Definition at line 1418 of file nnet-batch-compute.cc.

References NnetBatchDecoder::num_fail_, and NnetBatchDecoder::stats_mutex_.

                                        {
   std::unique_lock<std::mutex> lock(stats_mutex_);
   num_fail_++;
 }

Member Data Documentation

◆ allow_partial_

bool allow_partial_

private

Definition at line 780 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Decode().

◆ compute_thread_

std::thread compute_thread_

private

Definition at line 783 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Finished(), and NnetBatchDecoder::NnetBatchDecoder().

◆ computer_

NnetBatchComputer* computer_

private

Definition at line 781 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Compute(), NnetBatchDecoder::Decode(), NnetBatchDecoder::ProcessOutputUtterance(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ decode_threads_

std::vector<std::thread*> decode_threads_

private

Definition at line 782 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Finished(), NnetBatchDecoder::NnetBatchDecoder(), NnetBatchDecoder::UpdatePriorityOffset(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ decoder_opts_

const LatticeFasterDecoderConfig& decoder_opts_

private

Definition at line 777 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Decode(), NnetBatchDecoder::GetOutput(), and NnetBatchDecoder::ProcessOutputUtterance().

◆ frame_count_

int64 frame_count_

private

Definition at line 831 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::ProcessOutputUtterance(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ fst_

const fst::Fst<fst::StdArc>& fst_

private

Definition at line 776 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Decode().

◆ input_consumed_semaphore_

Semaphore input_consumed_semaphore_

private

Definition at line 796 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::AcceptInput(), and NnetBatchDecoder::Decode().

◆ input_ready_semaphore_

Semaphore input_ready_semaphore_

private

Definition at line 791 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::AcceptInput(), NnetBatchDecoder::Decode(), and NnetBatchDecoder::Finished().

◆ input_utterance_

UtteranceInput input_utterance_

private

Definition at line 790 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::AcceptInput(), and NnetBatchDecoder::Decode().

◆ is_finished_

bool is_finished_

private

Definition at line 806 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Decode(), NnetBatchDecoder::Finished(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ num_fail_

int32 num_fail_

private

Definition at line 833 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Decode(), NnetBatchDecoder::ProcessOutputUtterance(), NnetBatchDecoder::UtteranceFailed(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ num_partial_

int32 num_partial_

private

Definition at line 834 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Decode(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ num_success_

int32 num_success_

private

Definition at line 832 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Finished(), NnetBatchDecoder::ProcessOutputUtterance(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ pending_utts_

std::list<UtteranceOutput*> pending_utts_

private

Definition at line 819 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::AcceptInput(), NnetBatchDecoder::Decode(), NnetBatchDecoder::GetOutput(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ priority_offset_

double priority_offset_

private

Definition at line 826 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::SetPriorities(), and NnetBatchDecoder::UpdatePriorityOffset().

◆ stats_mutex_

std::mutex stats_mutex_

private

Definition at line 837 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Decode(), NnetBatchDecoder::ProcessOutputUtterance(), and NnetBatchDecoder::UtteranceFailed().

◆ tasks_finished_

bool tasks_finished_

private

Definition at line 810 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Compute(), and NnetBatchDecoder::Finished().

◆ tasks_ready_semaphore_

Semaphore tasks_ready_semaphore_

private

Definition at line 803 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Compute(), NnetBatchDecoder::Decode(), and NnetBatchDecoder::Finished().

◆ timer_

Timer timer_

private

Definition at line 839 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::~NnetBatchDecoder().

◆ tot_like_

double tot_like_

private

Definition at line 829 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::ProcessOutputUtterance(), and NnetBatchDecoder::~NnetBatchDecoder().

◆ trans_model_

const TransitionModel& trans_model_

private

Definition at line 778 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::Decode(), and NnetBatchDecoder::ProcessOutputUtterance().

◆ word_syms_

const fst::SymbolTable* word_syms_

private

Definition at line 779 of file nnet-batch-compute.h.

Referenced by NnetBatchDecoder::ProcessOutputUtterance().

The documentation for this class was generated from the following files:

nnet3/nnet-batch-compute.h
nnet3/nnet-batch-compute.cc

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ NnetBatchDecoder()

◆ ~NnetBatchDecoder()

Member Function Documentation

◆ AcceptInput()

◆ Compute()

◆ ComputeFunc()

◆ Decode()

◆ DecodeFunc()

◆ Finished()

◆ GetOutput() [1/2]

◆ GetOutput() [2/2]

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

◆ ProcessOutputUtterance()

◆ SetPriorities()

◆ UpdatePriorityOffset()

◆ UtteranceFailed()

Member Data Documentation

◆ allow_partial_

◆ compute_thread_

◆ computer_

◆ decode_threads_

◆ decoder_opts_

◆ frame_count_

◆ fst_

◆ input_consumed_semaphore_

◆ input_ready_semaphore_

◆ input_utterance_

◆ is_finished_

◆ num_fail_

◆ num_partial_

◆ num_success_

◆ pending_utts_

◆ priority_offset_

◆ stats_mutex_

◆ tasks_finished_

◆ tasks_ready_semaphore_

◆ timer_

◆ tot_like_

◆ trans_model_

◆ word_syms_