#include <online-faster-decoder.h>

Inheritance diagram for OnlineFasterDecoder:

Collaboration diagram for OnlineFasterDecoder:

[legend]

Public Types
enum	DecodeState { kEndFeats = 1, kEndUtt = 2, kEndBatch = 4 }

Public Types inherited from FasterDecoder
typedef fst::StdArc	Arc

typedef Arc::Label	Label

typedef Arc::StateId	StateId

typedef Arc::Weight	Weight

Public Member Functions
	OnlineFasterDecoder (const fst::Fst< fst::StdArc > &fst, const OnlineFasterDecoderOpts &opts, const std::vector< int32 > &sil_phones, const TransitionModel &trans_model)

DecodeState	Decode (DecodableInterface *decodable)

bool	PartialTraceback (fst::MutableFst< LatticeArc > *out_fst)

void	FinishTraceBack (fst::MutableFst< LatticeArc > *fst_out)

bool	EndOfUtterance ()

int32	frame ()

Public Member Functions inherited from FasterDecoder
	FasterDecoder (const fst::Fst< fst::StdArc > &fst, const FasterDecoderOptions &config)

void	SetOptions (const FasterDecoderOptions &config)

	~FasterDecoder ()

void	Decode (DecodableInterface *decodable)

bool	ReachedFinal () const
	Returns true if a final state was active on the last frame. More...

bool	GetBestPath (fst::MutableFst< LatticeArc > *fst_out, bool use_final_probs=true)
	GetBestPath gets the decoding traceback. More...

void	InitDecoding ()
	As a new alternative to Decode(), you can call InitDecoding and then (possibly multiple times) AdvanceDecoding(). More...

void	AdvanceDecoding (DecodableInterface *decodable, int32 max_num_frames=-1)
	This will decode until there are no more frames ready in the decodable object, but if max_num_frames is >= 0 it will decode no more than that many frames. More...

int32	NumFramesDecoded () const
	Returns the number of frames already decoded. More...

Private Member Functions
void	ResetDecoder (bool full)

void	TracebackNFrames (int32 nframes, fst::MutableFst< LatticeArc > *out_fst)

void	MakeLattice (const Token start, const Token end, fst::MutableFst< LatticeArc > *out_fst) const

void	UpdateImmortalToken ()

	KALDI_DISALLOW_COPY_AND_ASSIGN (OnlineFasterDecoder)

Private Attributes
const OnlineFasterDecoderOpts	opts_

const ConstIntegerSet< int32 >	silence_set_

const TransitionModel &	trans_model_

const BaseFloat	max_beam_

BaseFloat &	effective_beam_

DecodeState	state_

int32	frame_

int32	utt_frames_

Token *	immortal_tok_

Token *	prev_immortal_tok_

Additional Inherited Members
Protected Types inherited from FasterDecoder
typedef HashList< StateId, Token * >::Elem	Elem

Protected Member Functions inherited from FasterDecoder
double	GetCutoff (Elem list_head, size_t tok_count, BaseFloat adaptive_beam, Elem *best_elem)
	Gets the weight cutoff. Also counts the active tokens. More...

void	PossiblyResizeHash (size_t num_toks)

double	ProcessEmitting (DecodableInterface *decodable)

void	ProcessNonemitting (double cutoff)

void	ClearToks (Elem *list)

	KALDI_DISALLOW_COPY_AND_ASSIGN (FasterDecoder)

Protected Attributes inherited from FasterDecoder
HashList< StateId, Token * >	toks_

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

FasterDecoderOptions	config_

std::vector< const Elem *>	queue_

std::vector< BaseFloat >	tmp_array_

int32	num_frames_decoded_

Detailed Description

Definition at line 69 of file online-faster-decoder.h.

Member Enumeration Documentation

◆ DecodeState

enum DecodeState

Enumerator
kEndFeats
kEndUtt
kEndBatch

Definition at line 72 of file online-faster-decoder.h.

                    {
     kEndFeats = 1, // No more scores are available from the Decodable
     kEndUtt = 2, // End of utterance, caused by e.g. a sufficiently long silence
     kEndBatch = 4 // End of batch - end of utterance not reached yet
   };

Constructor & Destructor Documentation

◆ OnlineFasterDecoder()

OnlineFasterDecoder	(	const fst::Fst< fst::StdArc > &	fst,
		const OnlineFasterDecoderOpts &	opts,
		const std::vector< int32 > &	sil_phones,
		const TransitionModel &	trans_model
	)

inline

Definition at line 79 of file online-faster-decoder.h.

       : FasterDecoder(fst, opts), opts_(opts),
         silence_set_(sil_phones), trans_model_(trans_model),
         max_beam_(opts.beam), effective_beam_(FasterDecoder::config_.beam),
         state_(kEndFeats), frame_(0), utt_frames_(0) {}

Member Function Documentation

◆ Decode()

OnlineFasterDecoder::DecodeState Decode ( DecodableInterface * decodable )

Definition at line 231 of file online-faster-decoder.cc.

Referenced by main().

                                                          {
   if (state_ == kEndFeats || state_ == kEndUtt) // new utterance
     ResetDecoder(state_ == kEndFeats);
   ProcessNonemitting(std::numeric_limits<float>::max());
   int32 batch_frame = 0;
   Timer timer;
   double64 tstart = timer.Elapsed(), tstart_batch = tstart;
   BaseFloat factor = -1;
   for (; !decodable->IsLastFrame(frame_ - 1) && batch_frame < opts_.batch_size;
        ++frame_, ++utt_frames_, ++batch_frame) {
     if (batch_frame != 0 && (batch_frame % opts_.update_interval) == 0) {
       // adjust the beam if needed
       BaseFloat tend = timer.Elapsed();
       BaseFloat elapsed = (tend - tstart) * 1000;
       // warning: hardcoded 10ms frames assumption!
       factor = elapsed / (opts_.rt_max * opts_.update_interval * 10);
       BaseFloat min_factor = (opts_.rt_min / opts_.rt_max);
       if (factor > 1 || factor < min_factor) {
         BaseFloat update_factor = (factor > 1)?
             -std::min(opts_.beam_update * factor, opts_.max_beam_update):
              std::min(opts_.beam_update / factor, opts_.max_beam_update);
         effective_beam_ += effective_beam_ * update_factor;
         effective_beam_ = std::min(effective_beam_, max_beam_);
       }
       tstart = tend;
     }
     if (batch_frame != 0 && (frame_ % 200) == 0)
       // one log message at every 2 seconds assuming 10ms frames
       KALDI_VLOG(3) << "Beam: " << effective_beam_
           << "; Speed: "
           << ((timer.Elapsed() - tstart_batch) * 1000) / (batch_frame*10)
           << " xRT";
     BaseFloat weight_cutoff = ProcessEmitting(decodable);
     ProcessNonemitting(weight_cutoff);
   }
   if (batch_frame == opts_.batch_size && !decodable->IsLastFrame(frame_ - 1)) {
     if (EndOfUtterance())
       state_ = kEndUtt;
     else
       state_ = kEndBatch;
   } else {
     state_ = kEndFeats;
   }
   return state_;
 }

◆ EndOfUtterance()

bool EndOfUtterance ( )

Definition at line 210 of file online-faster-decoder.cc.

References ConstIntegerSet< I >::count(), fst::GetLinearSymbolSequence(), rnnlm::i, OnlineFasterDecoderOpts::inter_utt_sil, OnlineFasterDecoderOpts::max_utt_len_, OnlineFasterDecoder::opts_, OnlineFasterDecoder::silence_set_, kaldi::SplitToPhones(), OnlineFasterDecoder::TracebackNFrames(), OnlineFasterDecoder::trans_model_, TransitionModel::TransitionIdToPhone(), and OnlineFasterDecoder::utt_frames_.

Referenced by OnlineFasterDecoder::Decode().

                                          {
   fst::VectorFst<LatticeArc> trace;
   int32 sil_frm = opts_.inter_utt_sil / (1 + utt_frames_ / opts_.max_utt_len_);
   TracebackNFrames(sil_frm, &trace);
   std::vector<int32> isymbols;
   fst::GetLinearSymbolSequence(trace, &isymbols,
                                static_cast<std::vector<int32>* >(0),
                                static_cast<LatticeArc::Weight*>(0));
   std::vector<std::vector<int32> > split;
   SplitToPhones(trans_model_, isymbols, &split);
   for (size_t i = 0; i < split.size(); i++) {
     int32 tid = split[i][0];
     int32 phone = trans_model_.TransitionIdToPhone(tid);
     if (silence_set_.count(phone) == 0)
       return false;
   }
   return true;
 }

◆ FinishTraceBack()

void FinishTraceBack ( fst::MutableFst< LatticeArc > * fst_out )

Definition at line 136 of file online-faster-decoder.cc.

References FasterDecoder::fst_, HashList< I, T >::GetList(), OnlineFasterDecoder::immortal_tok_, OnlineFasterDecoder::MakeLattice(), FasterDecoder::ReachedFinal(), HashList< I, T >::Elem::tail, and FasterDecoder::toks_.

Referenced by main().

                                                                        {
   Token *best_tok = NULL;
   bool is_final = ReachedFinal();
   if (!is_final) {
     for (const Elem *e = toks_.GetList(); e != NULL; e = e->tail)
       if (best_tok == NULL || *best_tok < *(e->val) )
         best_tok = e->val;
   } else {
     double best_cost = std::numeric_limits<double>::infinity();
     for (const Elem *e = toks_.GetList(); e != NULL; e = e->tail) {
       double this_cost = e->val->cost_ + fst_.Final(e->key).Value();
       if (this_cost != std::numeric_limits<double>::infinity() &&
           this_cost < best_cost) {
         best_cost = this_cost;
         best_tok = e->val;
       }
     }
   }
   MakeLattice(best_tok, immortal_tok_, out_fst);
 }

◆ frame()

int32 frame ( )

inline

Definition at line 102 of file online-faster-decoder.h.

References kaldi::full.

Referenced by main().

102 { return frame_; }

kaldi::OnlineFasterDecoder::frame_

int32 frame_

Definition: online-faster-decoder.h:125

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( OnlineFasterDecoder )

private

◆ MakeLattice()

void MakeLattice	(	const Token *	start,
		const Token *	end,
		fst::MutableFst< LatticeArc > *	out_fst
	)		const

private

Definition at line 45 of file online-faster-decoder.cc.

References FasterDecoder::Token::arc_, FasterDecoder::Token::cost_, FasterDecoder::fst_, rnnlm::i, LatticeWeightTpl< BaseFloat >::One(), FasterDecoder::Token::prev_, and fst::RemoveEpsLocal().

Referenced by OnlineFasterDecoder::FinishTraceBack(), and OnlineFasterDecoder::PartialTraceback().

                                                                            {
   out_fst->DeleteStates();
   if (start == NULL) return;
   bool is_final = false;
   double this_cost = start->cost_ + fst_.Final(start->arc_.nextstate).Value();
   if (this_cost != std::numeric_limits<double>::infinity())
     is_final = true;
   std::vector<LatticeArc> arcs_reverse;  // arcs in reverse order.
   for (const Token *tok = start; tok != end; tok = tok->prev_) {
     BaseFloat tot_cost = tok->cost_ -
         (tok->prev_ ? tok->prev_->cost_ : 0.0),
         graph_cost = tok->arc_.weight.Value(),
         ac_cost = tot_cost - graph_cost;
     LatticeArc l_arc(tok->arc_.ilabel,
                      tok->arc_.olabel,
                      LatticeWeight(graph_cost, ac_cost),
                      tok->arc_.nextstate);
     arcs_reverse.push_back(l_arc);
   }
   if(arcs_reverse.back().nextstate == fst_.Start()) {
     arcs_reverse.pop_back();  // that was a "fake" token... gives no info.
   }
   StateId cur_state = out_fst->AddState();
   out_fst->SetStart(cur_state);
   for (ssize_t i = static_cast<ssize_t>(arcs_reverse.size())-1; i >= 0; i--) {
     LatticeArc arc = arcs_reverse[i];
     arc.nextstate = out_fst->AddState();
     out_fst->AddArc(cur_state, arc);
     cur_state = arc.nextstate;
   }
   if (is_final) {
     Weight final_weight = fst_.Final(start->arc_.nextstate);
     out_fst->SetFinal(cur_state, LatticeWeight(final_weight.Value(), 0.0));
   } else {
     out_fst->SetFinal(cur_state, LatticeWeight::One());
   }
   RemoveEpsLocal(out_fst);
 }

◆ PartialTraceback()

bool PartialTraceback ( fst::MutableFst< LatticeArc > * out_fst )

Definition at line 126 of file online-faster-decoder.cc.

References OnlineFasterDecoder::immortal_tok_, OnlineFasterDecoder::MakeLattice(), OnlineFasterDecoder::prev_immortal_tok_, and OnlineFasterDecoder::UpdateImmortalToken().

Referenced by main().

                                                                         {
   UpdateImmortalToken();
   if(immortal_tok_ == prev_immortal_tok_)
     return false; //no partial traceback at that point of time
   MakeLattice(immortal_tok_, prev_immortal_tok_, out_fst);
   return true;
 }

◆ ResetDecoder()

void ResetDecoder ( bool full )

private

Definition at line 30 of file online-faster-decoder.cc.

References HashList< I, T >::Clear(), FasterDecoder::ClearToks(), OnlineFasterDecoder::frame_, FasterDecoder::fst_, OnlineFasterDecoder::immortal_tok_, HashList< I, T >::Insert(), KALDI_ASSERT, OnlineFasterDecoder::prev_immortal_tok_, FasterDecoder::toks_, and OnlineFasterDecoder::utt_frames_.

Referenced by OnlineFasterDecoder::Decode().

                                                 {
   ClearToks(toks_.Clear());
   StateId start_state = fst_.Start();
   KALDI_ASSERT(start_state != fst::kNoStateId);
   Arc dummy_arc(0, 0, Weight::One(), start_state);
   Token *dummy_token = new Token(dummy_arc, NULL);
   toks_.Insert(start_state, dummy_token);
   prev_immortal_tok_ = immortal_tok_ = dummy_token;
   utt_frames_ = 0;
   if (full)
     frame_ = 0;
 }

◆ TracebackNFrames()

void TracebackNFrames	(	int32	nframes,
		fst::MutableFst< LatticeArc > *	out_fst
	)

private

Definition at line 159 of file online-faster-decoder.cc.

References FasterDecoder::Token::arc_, FasterDecoder::Token::cost_, FasterDecoder::fst_, HashList< I, T >::GetList(), rnnlm::i, LatticeWeightTpl< BaseFloat >::One(), FasterDecoder::Token::prev_, fst::RemoveEpsLocal(), HashList< I, T >::Elem::tail, and FasterDecoder::toks_.

Referenced by OnlineFasterDecoder::EndOfUtterance().

                                                                           {
   Token *best_tok = NULL;
   for (const Elem *e = toks_.GetList(); e != NULL; e = e->tail)
     if (best_tok == NULL || *best_tok < *(e->val) )
       best_tok = e->val;
   if (best_tok == NULL) {
     out_fst->DeleteStates();
     return;
   }
 
   bool is_final = false;
   double this_cost = best_tok->cost_ +
       fst_.Final(best_tok->arc_.nextstate).Value();
 
   if (this_cost != std::numeric_limits<double>::infinity())
     is_final = true;
   std::vector<LatticeArc> arcs_reverse;  // arcs in reverse order.
   for (Token *tok = best_tok; (tok != NULL) && (nframes > 0); tok = tok->prev_) {
     if (tok->arc_.ilabel != 0) // count only the non-epsilon arcs
       --nframes;
     BaseFloat tot_cost = tok->cost_ -
         (tok->prev_ ? tok->prev_->cost_ : 0.0);
     BaseFloat graph_cost = tok->arc_.weight.Value();
     BaseFloat ac_cost = tot_cost - graph_cost;
     LatticeArc larc(tok->arc_.ilabel,
                      tok->arc_.olabel,
                      LatticeWeight(graph_cost, ac_cost),
                      tok->arc_.nextstate);
     arcs_reverse.push_back(larc);
   }
   if(arcs_reverse.back().nextstate == fst_.Start())
     arcs_reverse.pop_back();  // that was a "fake" token... gives no info.
   StateId cur_state = out_fst->AddState();
   out_fst->SetStart(cur_state);
   for (ssize_t i = static_cast<ssize_t>(arcs_reverse.size())-1; i >= 0; i--) {
     LatticeArc arc = arcs_reverse[i];
     arc.nextstate = out_fst->AddState();
     out_fst->AddArc(cur_state, arc);
     cur_state = arc.nextstate;
   }
   if (is_final) {
     Weight final_weight = fst_.Final(best_tok->arc_.nextstate);
     out_fst->SetFinal(cur_state, LatticeWeight(final_weight.Value(), 0.0));
   } else {
     out_fst->SetFinal(cur_state, LatticeWeight::One());
   }
   RemoveEpsLocal(out_fst);
 }

◆ UpdateImmortalToken()

void UpdateImmortalToken ( )

private

Definition at line 87 of file online-faster-decoder.cc.

References FasterDecoder::Token::arc_, HashList< I, T >::GetList(), OnlineFasterDecoder::immortal_tok_, FasterDecoder::Token::prev_, OnlineFasterDecoder::prev_immortal_tok_, HashList< I, T >::Elem::tail, and FasterDecoder::toks_.

Referenced by OnlineFasterDecoder::PartialTraceback().

                                               {
   unordered_set<Token*> emitting;
   for (const Elem *e = toks_.GetList(); e != NULL; e = e->tail) {
     Token* tok = e->val;
     while (tok != NULL && tok->arc_.ilabel == 0) //deal with non-emitting ones ...
       tok = tok->prev_;
     if (tok != NULL)
       emitting.insert(tok);
   }
   Token* the_one = NULL;
   while (1) {
     if (emitting.size() == 1) {
       the_one = *(emitting.begin());
       break;
     }
     if (emitting.size() == 0)
       break;
     unordered_set<Token*> prev_emitting;
     unordered_set<Token*>::iterator it;
     for (it = emitting.begin(); it != emitting.end(); ++it) {
       Token* tok = *it;
       Token* prev_token = tok->prev_;
       while ((prev_token != NULL) && (prev_token->arc_.ilabel == 0))
         prev_token = prev_token->prev_; //deal with non-emitting ones
       if (prev_token == NULL)
         continue;
       prev_emitting.insert(prev_token);
     } // for
     emitting = prev_emitting;
   } // while
   if (the_one != NULL) {
     prev_immortal_tok_ = immortal_tok_;
     immortal_tok_ = the_one;
     return;
   }
 }