Collaboration diagram for Classes and functions related to HMM topology and transition modeling:

Modules
	Classes and functions for creating FSTs from HMMs

Classes
class	HmmTopology
	A class for storing topology information for phones. More...

struct	MleTransitionUpdateConfig

struct	MapTransitionUpdateConfig

class	TransitionModel

Functions
bool	SplitToPhones (const TransitionModel &trans_model, const std::vector< int32 > &alignment, std::vector< std::vector< int32 > > *split_alignment)
	SplitToPhones splits up the TransitionIds in "alignment" into their individual phones (one vector per instance of a phone). More...

bool	ConvertAlignment (const TransitionModel &old_trans_model, const TransitionModel &new_trans_model, const ContextDependencyInterface &new_ctx_dep, const std::vector< int32 > &old_alignment, int32 subsample_factor, bool repeat_frames, bool reorder, const std::vector< int32 > phone_map, std::vector< int32 > new_alignment)
	ConvertAlignment converts an alignment that was created using one model, to another model. More...

bool	ConvertPhnxToProns (const std::vector< int32 > &phnx, const std::vector< int32 > &words, int32 word_start_sym, int32 word_end_sym, std::vector< std::vector< int32 > > *prons)

void	GetRandomAlignmentForPhone (const ContextDependencyInterface &ctx_dep, const TransitionModel &trans_model, const std::vector< int32 > &phone_window, std::vector< int32 > *alignment)

void	ChangeReorderingOfAlignment (const TransitionModel &trans_model, std::vector< int32 > *alignment)

void	GetPdfToPhonesMap (const TransitionModel &trans_model, std::vector< std::set< int32 > > *pdf2phones)

bool	GetPdfsForPhones (const TransitionModel &trans_model, const std::vector< int32 > &phones, std::vector< int32 > *pdfs)
	Works out which pdfs might correspond to the given phones. More...

bool	GetPhonesForPdfs (const TransitionModel &trans_model, const std::vector< int32 > &pdfs, std::vector< int32 > *phones)
	Works out which phones might correspond to the given pdfs. More...

Variables
static const int32	kNoPdf = -1
	A constant used in the HmmTopology class as the pdf-class kNoPdf, which is used when a HMM-state is nonemitting (has no associated PDF). More...

Integer mapping functions
int32	TransitionIdToPdf (int32 trans_id) const

int32	TransitionIdToPdfFast (int32 trans_id) const

Detailed Description

Function Documentation

◆ ChangeReorderingOfAlignment()

void ChangeReorderingOfAlignment	(	const TransitionModel &	trans_model,
		std::vector< int32 > *	alignment
	)

Definition at line 1260 of file hmm-utils.cc.

References TransitionModel::IsSelfLoop(), kaldi::swap(), and TransitionModel::TransitionIdToTransitionState().

Referenced by kaldi::ConvertAlignmentForPhone().

                                                               {
   int32 start_pos = 0, size = alignment->size();
   while (start_pos != size) {
     int32 start_tid = (*alignment)[start_pos];
     int32 cur_tstate = trans_model.TransitionIdToTransitionState(start_tid);
     bool start_is_self_loop = trans_model.IsSelfLoop(start_tid) ? 0 : 1;
     int32 end_pos = start_pos + 1;
     // If the first instance of this transition-state was a self-loop, then eat
     // only non-self-loops of this state; if it was a non-self-loop, then eat
     // only self-loops of this state.  Imposing this condition on self-loops
     // would only actually matter in the rare circumstances that phones can
     // have length 1.
     while (end_pos != size &&
            trans_model.TransitionIdToTransitionState((*alignment)[end_pos]) ==
            cur_tstate) {
       bool this_is_self_loop = trans_model.IsSelfLoop((*alignment)[end_pos]);
       if (!this_is_self_loop) {
         if (start_is_self_loop) {
           break;  // stop before including this transition-id.
         } else {
           end_pos++;
           break;  // stop after including this transition-id.
         }
       }
       end_pos++;
     }
     std::swap((*alignment)[start_pos], (*alignment)[end_pos - 1]);
     start_pos = end_pos;
   }
 }

◆ ConvertAlignment()

bool ConvertAlignment	(	const TransitionModel &	old_trans_model,
		const TransitionModel &	new_trans_model,
		const ContextDependencyInterface &	new_ctx_dep,
		const std::vector< int32 > &	old_alignment,
		int32	subsample_factor,
		bool	repeat_frames,
		bool	reorder,
		const std::vector< int32 > *	phone_map,
		std::vector< int32 > *	new_alignment
	)

ConvertAlignment converts an alignment that was created using one model, to another model.

Returns false if it could not be split to phones (e.g. because the alignment was partial), or because some other error happened, such as we couldn't convert the alignment because there were too few frames for the new topology.

Parameters

old_trans_model	[in] The transition model that the original alignment used.
new_trans_model	[in] The transition model that we want to use for the new alignment.
new_ctx_dep	[in] The new tree
old_alignment	[in] The alignment we want to convert
subsample_factor	[in] The frame subsampling factor... normally 1, but might be > 1 if we're converting to a reduced-frame-rate system.
repeat_frames	[in] Only relevant when subsample_factor != 1 If true, repeat frames of alignment by 'subsample_factor' after alignment conversion, to keep the alignment the same length as the input alignment. [note: we actually do this by interpolating 'subsample_factor' separately generated alignments, to keep the phone boundaries the same as the input where possible.]
reorder	[in] True if you want the pdf-ids on the new alignment to be 'reordered'. (vs. the way they appear in the HmmTopology object)
phone_map	[in] If non-NULL, map from old to new phones.
new_alignment	[out] The converted alignment.

Definition at line 1013 of file hmm-utils.cc.

References kaldi::ConvertAlignmentInternal(), rnnlm::i, and KALDI_ASSERT.

Referenced by main(), and kaldi::TestConvertAlignment().

                                                        {
   if (!repeat_frames || subsample_factor == 1) {
     return ConvertAlignmentInternal(old_trans_model,
                                     new_trans_model,
                                     new_ctx_dep,
                                     old_alignment,
                                     subsample_factor - 1,
                                     subsample_factor,
                                     new_is_reordered,
                                     phone_map,
                                     new_alignment);
    // The value "subsample_factor - 1" for conversion_shift above ensures the
    // alignments have the same length as the output of 'subsample-feats'
   } else {
     std::vector<std::vector<int32> > shifted_alignments(subsample_factor);
     for (int32 conversion_shift = subsample_factor - 1;
          conversion_shift >= 0; conversion_shift--) {
       if (!ConvertAlignmentInternal(old_trans_model,
                                     new_trans_model,
                                     new_ctx_dep,
                                     old_alignment,
                                     conversion_shift,
                                     subsample_factor,
                                     new_is_reordered,
                                     phone_map,
                                     &shifted_alignments[conversion_shift]))
         return false;
     }
     KALDI_ASSERT(new_alignment != NULL);
     new_alignment->clear();
     new_alignment->reserve(old_alignment.size());
     int32 max_shifted_ali_length = (old_alignment.size() / subsample_factor)
                                    + (old_alignment.size() % subsample_factor);
     for (int32 i = 0; i < max_shifted_ali_length; i++)
       for (int32 conversion_shift = subsample_factor - 1;
            conversion_shift >= 0; conversion_shift--)
         if (i < static_cast<int32>(shifted_alignments[conversion_shift].size()))
           new_alignment->push_back(shifted_alignments[conversion_shift][i]);
   }
   KALDI_ASSERT(new_alignment->size() == old_alignment.size());
   return true;
 }

◆ ConvertPhnxToProns()

bool ConvertPhnxToProns	(	const std::vector< int32 > &	phnx,
		const std::vector< int32 > &	words,
		int32	word_start_sym,
		int32	word_end_sym,
		std::vector< std::vector< int32 > > *	prons
	)

Definition at line 1161 of file hmm-utils.cc.

References rnnlm::i, and rnnlm::j.

Referenced by main(), and kaldi::TestConvertPhnxToProns().

                                                              {
   size_t i = 0, j = 0;
 
   while (i < phnx.size()) {
     if (phnx[i] == 0) return false; // zeros not valid here.
     if (phnx[i] == word_start_sym) { // start a word...
       std::vector<int32> pron;
       if (j >= words.size()) return false; // no word left..
       if (words[j] == 0) return false; // zero word disallowed.
       pron.push_back(words[j++]);
       i++;
       while (i < phnx.size()) {
         if (phnx[i] == 0) return false;
         if (phnx[i] == word_start_sym) return false; // error.
         if (phnx[i] == word_end_sym) { i++; break; }
         pron.push_back(phnx[i]);
         i++;
       }
       // check we did see the word-end symbol.
       if (!(i > 0 && phnx[i-1] == word_end_sym))
         return false;
       prons->push_back(pron);
     } else if (phnx[i] == word_end_sym) {
       return false;  // error.
     } else {
       // start a non-word sequence of phones (e.g. opt-sil).
       std::vector<int32> pron;
       pron.push_back(0); // 0 serves as the word-id.
       while (i < phnx.size()) {
         if (phnx[i] == 0) return false;
         if (phnx[i] == word_start_sym) break;
         if (phnx[i] == word_end_sym) return false; // error.
         pron.push_back(phnx[i]);
         i++;
       }
       prons->push_back(pron);
     }
   }
   return (j == words.size());
 }

◆ GetPdfsForPhones()

bool GetPdfsForPhones	(	const TransitionModel &	trans_model,
		const std::vector< int32 > &	phones,
		std::vector< int32 > *	pdfs
	)

Works out which pdfs might correspond to the given phones.

Will return true if these pdfs correspond *just* to these phones, false if these pdfs are also used by other phones.

Parameters

trans_model	[in] Transition-model used to work out this information
phones	[in] A sorted, uniq vector that represents a set of phones
pdfs	[out] Will be set to a sorted, uniq list of pdf-ids that correspond to one of this set of phones.

Returns: Returns true if all of the pdfs output to "pdfs" correspond to phones from just this set (false if they may be shared with phones outside this set).

Definition at line 854 of file transition-model.cc.

References kaldi::IsSortedAndUniq(), KALDI_ASSERT, TransitionModel::NumTransitionStates(), kaldi::SortAndUniq(), TransitionModel::TransitionStateToForwardPdf(), TransitionModel::TransitionStateToPhone(), and TransitionModel::TransitionStateToSelfLoopPdf().

Referenced by main(), and TransitionModel::TransitionIdToPdfFast().

                                               {
   KALDI_ASSERT(IsSortedAndUniq(phones));
   KALDI_ASSERT(pdfs != NULL);
   pdfs->clear();
   for (int32 tstate = 1; tstate <= trans_model.NumTransitionStates(); tstate++) {
     if (std::binary_search(phones.begin(), phones.end(),
              trans_model.TransitionStateToPhone(tstate))) {
       pdfs->push_back(trans_model.TransitionStateToForwardPdf(tstate));
       pdfs->push_back(trans_model.TransitionStateToSelfLoopPdf(tstate));
     }
   }
   SortAndUniq(pdfs);
 
   for (int32 tstate = 1; tstate <= trans_model.NumTransitionStates(); tstate++)
     if ((std::binary_search(pdfs->begin(), pdfs->end(),
                           trans_model.TransitionStateToForwardPdf(tstate)) ||
          std::binary_search(pdfs->begin(), pdfs->end(),
                           trans_model.TransitionStateToSelfLoopPdf(tstate)))
        && !std::binary_search(phones.begin(), phones.end(),
                               trans_model.TransitionStateToPhone(tstate)))
       return false;
   return true;
 }

◆ GetPdfToPhonesMap()

void GetPdfToPhonesMap	(	const TransitionModel &	trans_model,
		std::vector< std::set< int32 > > *	pdf2phones
	)

Definition at line 1292 of file hmm-utils.cc.

References rnnlm::i, TransitionModel::NumPdfs(), TransitionModel::NumTransitionIds(), TransitionModel::TransitionIdToPdf(), and TransitionModel::TransitionIdToPhone().

Referenced by main().

                                                               {
   pdf2phones->clear();
   pdf2phones->resize(trans_model.NumPdfs());
   for (int32 i = 0; i < trans_model.NumTransitionIds(); i++) {
     int32 trans_id = i + 1;
     int32 pdf_id = trans_model.TransitionIdToPdf(trans_id);
     int32 phone = trans_model.TransitionIdToPhone(trans_id);
     (*pdf2phones)[pdf_id].insert(phone);
   }
 }

◆ GetPhonesForPdfs()

bool GetPhonesForPdfs	(	const TransitionModel &	trans_model,
		const std::vector< int32 > &	pdfs,
		std::vector< int32 > *	phones
	)

Works out which phones might correspond to the given pdfs.

Similar to the above GetPdfsForPhones(, ,)

Definition at line 880 of file transition-model.cc.

References kaldi::IsSortedAndUniq(), KALDI_ASSERT, TransitionModel::NumTransitionStates(), kaldi::SortAndUniq(), TransitionModel::TransitionStateToForwardPdf(), TransitionModel::TransitionStateToPhone(), and TransitionModel::TransitionStateToSelfLoopPdf().

Referenced by kaldi::InitAmGmm(), and TransitionModel::TransitionIdToPdfFast().

                                                {
   KALDI_ASSERT(IsSortedAndUniq(pdfs));
   KALDI_ASSERT(phones != NULL);
   phones->clear();
   for (int32 tstate = 1; tstate <= trans_model.NumTransitionStates(); tstate++) {
     if (std::binary_search(pdfs.begin(), pdfs.end(),
                            trans_model.TransitionStateToForwardPdf(tstate)) ||
         std::binary_search(pdfs.begin(), pdfs.end(),
                            trans_model.TransitionStateToSelfLoopPdf(tstate)))
       phones->push_back(trans_model.TransitionStateToPhone(tstate));
   }
   SortAndUniq(phones);
 
   for (int32 tstate = 1; tstate <= trans_model.NumTransitionStates(); tstate++)
     if (std::binary_search(phones->begin(), phones->end(),
                            trans_model.TransitionStateToPhone(tstate))
         && !(std::binary_search(pdfs.begin(), pdfs.end(),
                                trans_model.TransitionStateToForwardPdf(tstate)) &&
              std::binary_search(pdfs.begin(), pdfs.end(),
                                trans_model.TransitionStateToSelfLoopPdf(tstate))) )
       return false;
   return true;
 }

◆ GetRandomAlignmentForPhone()

void GetRandomAlignmentForPhone	(	const ContextDependencyInterface &	ctx_dep,
		const TransitionModel &	trans_model,
		const std::vector< int32 > &	phone_window,
		std::vector< int32 > *	alignment
	)

Definition at line 1207 of file hmm-utils.cc.

References ContextDependencyInterface::CentralPosition(), kaldi::GetHmmAsFsaSimple(), fst::GetInputSymbols(), TransitionModel::GetTopo(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_ERR, and HmmTopology::MinLength().

Referenced by kaldi::ConvertAlignmentForPhone().

                                                              {
   typedef fst::StdArc Arc;
   int32 length = alignment->size();
   BaseFloat prob_scale = 0.0;
   fst::VectorFst<Arc> *fst = GetHmmAsFsaSimple(phone_window, ctx_dep,
                                                trans_model, prob_scale);
   fst::RmEpsilon(fst);
 
   fst::VectorFst<Arc> length_constraint_fst;
   {  // set up length_constraint_fst.
     std::vector<int32> symbols;
     bool include_epsilon = false;
     // note: 'fst' is an acceptor so ilabels == olabels.
     GetInputSymbols(*fst, include_epsilon, &symbols);
     int32 cur_state = length_constraint_fst.AddState();
     length_constraint_fst.SetStart(cur_state);
     for (int32 i = 0; i < length; i++) {
       int32 next_state = length_constraint_fst.AddState();
       for (size_t j = 0; j < symbols.size(); j++) {
         length_constraint_fst.AddArc(cur_state,
                                      Arc(symbols[j], symbols[j],
                                          fst::TropicalWeight::One(),
                                          next_state));
       }
       cur_state = next_state;
     }
     length_constraint_fst.SetFinal(cur_state, fst::TropicalWeight::One());
   }
   fst::VectorFst<Arc> composed_fst;
   fst::Compose(*fst, length_constraint_fst, &composed_fst);
   fst::VectorFst<Arc> single_path_fst;
   {  // randomly generate a single path.
     fst::UniformArcSelector<Arc> selector;
     fst::RandGenOptions<fst::UniformArcSelector<Arc> > randgen_opts(selector);
     fst::RandGen(composed_fst, &single_path_fst, randgen_opts);
   }
   if (single_path_fst.NumStates() == 0) {
     KALDI_ERR << "Error generating random alignment (wrong length?): "
               << "requested length is " << length << " versus min-length "
               << trans_model.GetTopo().MinLength(
                   phone_window[ctx_dep.CentralPosition()]);
   }
   std::vector<int32> symbol_sequence;
   bool ans = fst::GetLinearSymbolSequence<Arc, int32>(
       single_path_fst, &symbol_sequence, NULL, NULL);
   KALDI_ASSERT(ans && symbol_sequence.size() == length);
   symbol_sequence.swap(*alignment);
   delete fst;
 }

◆ SplitToPhones()

bool SplitToPhones	(	const TransitionModel &	trans_model,
		const std::vector< int32 > &	alignment,
		std::vector< std::vector< int32 > > *	split_alignment
	)

SplitToPhones splits up the TransitionIds in "alignment" into their individual phones (one vector per instance of a phone).

At output, the sum of the sizes of the vectors in split_alignment will be the same as the corresponding sum for "alignment". The function returns true on success. If the alignment appears to be incomplete, e.g. not ending at the end-state of a phone, it will still break it up into phones but it will return false. For more serious errors it will die or throw an exception. This function works out by itself whether the graph was created with "reordering", and just does the right thing.

Definition at line 723 of file hmm-utils.cc.

References kaldi::IsReordered(), KALDI_ASSERT, and kaldi::SplitToPhonesInternal().

Referenced by kaldi::AccumulateTreeStats(), kaldi::CompactLatticeToWordProns(), kaldi::ConvertAlignmentInternal(), OnlineFasterDecoder::EndOfUtterance(), kaldi::IsPlausibleWord(), main(), kaldi::TestConvertAlignment(), and kaldi::TestSplitToPhones().

                                                                   {
   KALDI_ASSERT(split_alignment != NULL);
   split_alignment->clear();
 
   bool is_reordered = IsReordered(trans_model, alignment);
   return SplitToPhonesInternal(trans_model, alignment,
                                is_reordered, split_alignment);
 }

◆ TransitionIdToPdf()

int32 TransitionIdToPdf ( int32 trans_id ) const

inline

Definition at line 327 of file transition-model.h.

References KALDI_ASSERT.

Referenced by kaldi::AccumulateForUtterance(), DiscriminativeExampleSplitter::CollapseTransitionIds(), DiscriminativeSupervisionSplitter::CollapseTransitionIds(), kaldi::ComputeAmGmmFeatureDeriv(), DiscriminativeExampleSplitter::ComputeFrameInfo(), kaldi::ConvertPosteriorToPdfs(), kaldi::GetPdfToPhonesMap(), kaldi::GetPdfToTransitionIdTransducer(), kaldi::LatticeAcousticRescore(), kaldi::nnet1::LatticeAcousticRescore(), NnetDiscriminativeUpdater::LatticeComputations(), kaldi::LatticeForwardBackwardMpeVariants(), OnlineDecodableDiagGmmScaled::LogLikelihood(), DecodableDiagGmmScaledOnline::LogLikelihood(), DecodableNnet2Online::LogLikelihood(), DiscriminativeComputation::LookupNnetOutput(), main(), ComparePosteriorByPdfs::operator()(), kaldi::PosteriorToPdfMatrix(), kaldi::RescoreCompactLatticeInternal(), kaldi::nnet3::SetPriors(), and kaldi::nnet2::SetPriors().

                                                                     {
   KALDI_ASSERT(
       static_cast<size_t>(trans_id) < id2pdf_id_.size() &&
       "Likely graph/model mismatch (graph built from wrong model?)");
   return id2pdf_id_[trans_id];
 }

◆ TransitionIdToPdfFast()

int32 TransitionIdToPdfFast ( int32 trans_id ) const

inline

Definition at line 334 of file transition-model.h.

References kaldi::GetPdfsForPhones(), kaldi::GetPhonesForPdfs(), and KALDI_PARANOID_ASSERT.

                                                                         {
   // Note: it's a little dangerous to assert this only in paranoid mode.
   // However, this function is called in the inner loop of decoders and
   // the assertion likely takes a significant amount of time.  We make
   // sure that past the end of the id2pdf_id_ array there are big
   // numbers, which will make the calling code more likely to segfault
   // (rather than silently die) if this is called for out-of-range values.
   KALDI_PARANOID_ASSERT(
       static_cast<size_t>(trans_id) < id2pdf_id_.size() &&
       "Likely graph/model mismatch (graph built from wrong model?)");
   return id2pdf_id_[trans_id];
 }

Variable Documentation

◆ kNoPdf

const int32 kNoPdf = -1

static

A constant used in the HmmTopology class as the pdf-class kNoPdf, which is used when a HMM-state is nonemitting (has no associated PDF).

Definition at line 86 of file hmm-topology.h.

Referenced by HmmTopology::Check(), TransitionModel::ComputeTuplesIsHmm(), TransitionModel::ComputeTuplesNotHmm(), kaldi::GetHmmAsFsa(), kaldi::GetHmmAsFsaSimple(), HmmTopology::Read(), kaldi::SplitToPhonesInternal(), and HmmTopology::Write().

Modules

Classes

Functions

Variables

Integer mapping functions