TransitionModel Class Reference

#include <transition-model.h>

Collaboration diagram for TransitionModel:

Classes
struct	Tuple

Public Member Functions
	TransitionModel (const ContextDependencyInterface &ctx_dep, const HmmTopology &hmm_topo)
	Initialize the object [e.g. More...
	TransitionModel ()
	Constructor that takes no arguments: typically used prior to calling Read. More...
void	Read (std::istream &is, bool binary)
void	Write (std::ostream &os, bool binary) const
const HmmTopology &	GetTopo () const
	return reference to HMM-topology object. More...
bool	IsFinal (int32 trans_id) const
bool	IsSelfLoop (int32 trans_id) const
int32	NumTransitionIds () const
	Returns the total number of transition-ids (note, these are one-based). More...
int32	NumTransitionIndices (int32 trans_state) const
	Returns the number of transition-indices for a particular transition-state. More...
int32	NumTransitionStates () const
	Returns the total number of transition-states (note, these are one-based). More...
int32	NumPdfs () const
int32	NumPhones () const
const std::vector< int32 > &	GetPhones () const
	Returns a sorted, unique list of phones. More...
BaseFloat	GetTransitionProb (int32 trans_id) const
BaseFloat	GetTransitionLogProb (int32 trans_id) const
BaseFloat	GetTransitionLogProbIgnoringSelfLoops (int32 trans_id) const
	Returns the log-probability of a particular non-self-loop transition after subtracting the probability mass of the self-loop and renormalizing; will crash if called on a self-loop. More...
BaseFloat	GetNonSelfLoopLogProb (int32 trans_state) const
	Returns the log-prob of the non-self-loop probability mass for this transition state. More...
void	MleUpdate (const Vector< double > &stats, const MleTransitionUpdateConfig &cfg, BaseFloat *objf_impr_out, BaseFloat *count_out)
	Does Maximum Likelihood estimation. More...
void	MapUpdate (const Vector< double > &stats, const MapTransitionUpdateConfig &cfg, BaseFloat *objf_impr_out, BaseFloat *count_out)
	Does Maximum A Posteriori (MAP) estimation. More...
void	Print (std::ostream &os, const std::vector< std::string > &phone_names, const Vector< double > *occs=NULL)
	Print will print the transition model in a human-readable way, for purposes of human inspection. More...
void	InitStats (Vector< double > *stats) const
void	Accumulate (BaseFloat prob, int32 trans_id, Vector< double > *stats) const
bool	Compatible (const TransitionModel &other) const
	returns true if all the integer class members are identical (but does not compare the transition probabilities. More...
Integer mapping functions
int32	TupleToTransitionState (int32 phone, int32 hmm_state, int32 pdf, int32 self_loop_pdf) const
int32	PairToTransitionId (int32 trans_state, int32 trans_index) const
int32	TransitionIdToTransitionState (int32 trans_id) const
int32	TransitionIdToTransitionIndex (int32 trans_id) const
int32	TransitionStateToPhone (int32 trans_state) const
int32	TransitionStateToHmmState (int32 trans_state) const
int32	TransitionStateToForwardPdfClass (int32 trans_state) const
int32	TransitionStateToSelfLoopPdfClass (int32 trans_state) const
int32	TransitionStateToForwardPdf (int32 trans_state) const
int32	TransitionStateToSelfLoopPdf (int32 trans_state) const
int32	SelfLoopOf (int32 trans_state) const
int32	TransitionIdToPdf (int32 trans_id) const
int32	TransitionIdToPdfFast (int32 trans_id) const
int32	TransitionIdToPhone (int32 trans_id) const
int32	TransitionIdToPdfClass (int32 trans_id) const
int32	TransitionIdToHmmState (int32 trans_id) const

Private Member Functions
void	MleUpdateShared (const Vector< double > &stats, const MleTransitionUpdateConfig &cfg, BaseFloat *objf_impr_out, BaseFloat *count_out)
	This version of the Update() function is for if the user specifies –share-for-pdfs=true. More...
void	MapUpdateShared (const Vector< double > &stats, const MapTransitionUpdateConfig &cfg, BaseFloat *objf_impr_out, BaseFloat *count_out)
	This version of the MapUpdate() function is for if the user specifies –share-for-pdfs=true. More...
void	ComputeTuples (const ContextDependencyInterface &ctx_dep)
void	ComputeTuplesIsHmm (const ContextDependencyInterface &ctx_dep)
void	ComputeTuplesNotHmm (const ContextDependencyInterface &ctx_dep)
void	ComputeDerived ()
void	ComputeDerivedOfProbs ()
void	InitializeProbs ()
void	Check () const
bool	IsHmm () const
	KALDI_DISALLOW_COPY_AND_ASSIGN (TransitionModel)

Private Attributes
HmmTopology	topo_
std::vector< Tuple >	tuples_
	Tuples indexed by transition state minus one; the tuples are in sorted order which allows us to do the reverse mapping from tuple to transition state. More...
std::vector< int32 >	state2id_
	Gives the first transition_id of each transition-state; indexed by the transition-state. More...
std::vector< int32 >	id2state_
	For each transition-id, the corresponding transition state (indexed by transition-id). More...
std::vector< int32 >	id2pdf_id_
Vector< BaseFloat >	log_probs_
	For each transition-id, the corresponding log-prob. Indexed by transition-id. More...
Vector< BaseFloat >	non_self_loop_log_probs_
	For each transition-state, the log of (1 - self-loop-prob). More...
int32	num_pdfs_
	This is actually one plus the highest-numbered pdf we ever got back from the tree (but the tree numbers pdfs contiguously from zero so this is the number of pdfs). More...

Detailed Description

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

Constructor & Destructor Documentation

TransitionModel() [1/2]

TransitionModel	(	const ContextDependencyInterface &	ctx_dep,
		const HmmTopology &	hmm_topo
	)

Initialize the object [e.g.

at the start of training]. The class keeps a copy of the HmmTopology object, but not the ContextDependency object.

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

References TransitionModel::Check(), TransitionModel::ComputeDerived(), TransitionModel::ComputeTuples(), and TransitionModel::InitializeProbs().

                                                             : topo_(hmm_topo) {
  // First thing is to get all possible tuples.
  ComputeTuples(ctx_dep);
  ComputeDerived();
  InitializeProbs();
  Check();
}

TransitionModel() [2/2]

TransitionModel ( )

inline

Constructor that takes no arguments: typically used prior to calling Read.

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

: num_pdfs_(0) { }

Member Function Documentation

Accumulate()

void Accumulate ( BaseFloat  prob, int32  trans_id, Vector< double > *  stats  ) const

inline

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

References KALDI_ASSERT.

Referenced by main().

                                                                               {
    KALDI_ASSERT(trans_id <= NumTransitionIds());
    (*stats)(trans_id) += prob;
    // This is trivial and doesn't require class members, but leaves us more open
    // to design changes than doing it manually.
  }

Check()

void Check ( ) const

private

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

References KALDI_ASSERT, TransitionModel::log_probs_, TransitionModel::NumTransitionIds(), TransitionModel::NumTransitionIndices(), TransitionModel::NumTransitionStates(), TransitionModel::PairToTransitionId(), TransitionModel::TransitionIdToTransitionIndex(), TransitionModel::TransitionIdToTransitionState(), TransitionModel::TransitionStateToForwardPdf(), TransitionModel::TransitionStateToHmmState(), TransitionModel::TransitionStateToPhone(), TransitionModel::TransitionStateToSelfLoopPdf(), and TransitionModel::TupleToTransitionState().

Referenced by TransitionModel::Read(), and TransitionModel::TransitionModel().

                                  {
  KALDI_ASSERT(NumTransitionIds() != 0 && NumTransitionStates() != 0);
  {
    int32 sum = 0;
    for (int32 ts = 1; ts <= NumTransitionStates(); ts++) sum += NumTransitionIndices(ts);
    KALDI_ASSERT(sum == NumTransitionIds());
  }
  for (int32 tid = 1; tid <= NumTransitionIds(); tid++) {
    int32 tstate = TransitionIdToTransitionState(tid),
        index = TransitionIdToTransitionIndex(tid);
    KALDI_ASSERT(tstate > 0 && tstate <=NumTransitionStates() && index >= 0);
    KALDI_ASSERT(tid == PairToTransitionId(tstate, index));
    int32 phone = TransitionStateToPhone(tstate),
        hmm_state = TransitionStateToHmmState(tstate),
        forward_pdf = TransitionStateToForwardPdf(tstate),
        self_loop_pdf = TransitionStateToSelfLoopPdf(tstate);
    KALDI_ASSERT(tstate == TupleToTransitionState(phone, hmm_state, forward_pdf, self_loop_pdf));
    KALDI_ASSERT(log_probs_(tid) <= 0.0 && log_probs_(tid) - log_probs_(tid) == 0.0);
    // checking finite and non-positive (and not out-of-bounds).
  }
}

Compatible()

bool Compatible

(

const TransitionModel &

other

)

const

returns true if all the integer class members are identical (but does not compare the transition probabilities.

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

References TransitionModel::id2state_, TransitionModel::num_pdfs_, TransitionModel::state2id_, TransitionModel::topo_, and TransitionModel::tuples_.

Referenced by OnlineGmmDecodingModels::OnlineGmmDecodingModels(), and kaldi::TestTransitionModel().

                                                                   {
  return (topo_ == other.topo_ && tuples_ == other.tuples_ &&
          state2id_ == other.state2id_ && id2state_ == other.id2state_
          && num_pdfs_ == other.num_pdfs_);
}

ComputeDerived()

void ComputeDerived ( )

private

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

References TransitionModel::id2pdf_id_, TransitionModel::id2state_, TransitionModel::IsSelfLoop(), TransitionModel::num_pdfs_, TransitionModel::state2id_, TransitionModel::topo_, HmmTopology::TopologyForPhone(), HmmTopology::HmmState::transitions, and TransitionModel::tuples_.

Referenced by TransitionModel::Read(), and TransitionModel::TransitionModel().

                                     {
  state2id_.resize(tuples_.size()+2);  // indexed by transition-state, which
  // is one based, but also an entry for one past end of list.

  int32 cur_transition_id = 1;
  num_pdfs_ = 0;
  for (int32 tstate = 1;
      tstate <= static_cast<int32>(tuples_.size()+1);  // not a typo.
      tstate++) {
    state2id_[tstate] = cur_transition_id;
    if (static_cast<size_t>(tstate) <= tuples_.size()) {
      int32 phone = tuples_[tstate-1].phone,
          hmm_state = tuples_[tstate-1].hmm_state,
          forward_pdf = tuples_[tstate-1].forward_pdf,
          self_loop_pdf = tuples_[tstate-1].self_loop_pdf;
      num_pdfs_ = std::max(num_pdfs_, 1 + forward_pdf);
      num_pdfs_ = std::max(num_pdfs_, 1 + self_loop_pdf);
      const HmmTopology::HmmState &state = topo_.TopologyForPhone(phone)[hmm_state];
      int32 my_num_ids = static_cast<int32>(state.transitions.size());
      cur_transition_id += my_num_ids;  // # trans out of this state.
    }
  }

  id2state_.resize(cur_transition_id);   // cur_transition_id is #transition-ids+1.
  id2pdf_id_.resize(cur_transition_id);
  for (int32 tstate = 1; tstate <= static_cast<int32>(tuples_.size()); tstate++) {
    for (int32 tid = state2id_[tstate]; tid < state2id_[tstate+1]; tid++) {
      id2state_[tid] = tstate;
      if (IsSelfLoop(tid))
        id2pdf_id_[tid] = tuples_[tstate-1].self_loop_pdf;
      else
        id2pdf_id_[tid] = tuples_[tstate-1].forward_pdf;
    }
  }

  // The following statements put copies a large number in the region of memory
  // past the end of the id2pdf_id_ array, while leaving the array as it was
  // before.  The goal of this is to speed up decoding by disabling a check
  // inside TransitionIdToPdf() that the transition-id was within the correct
  // range.
  int32 num_big_numbers = std::min<int32>(2000, cur_transition_id);
  id2pdf_id_.resize(cur_transition_id + num_big_numbers,
                    std::numeric_limits<int32>::max());
  id2pdf_id_.resize(cur_transition_id);
}

ComputeDerivedOfProbs()

void ComputeDerivedOfProbs ( )

private

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

References kaldi::Exp(), TransitionModel::GetTransitionLogProb(), KALDI_WARN, kaldi::Log(), TransitionModel::non_self_loop_log_probs_, TransitionModel::NumTransitionStates(), and TransitionModel::SelfLoopOf().

Referenced by TransitionModel::InitializeProbs(), TransitionModel::MapUpdate(), TransitionModel::MapUpdateShared(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), and TransitionModel::Read().

                                            {
  non_self_loop_log_probs_.Resize(NumTransitionStates()+1);  // this array indexed
  //  by transition-state with nothing in zeroth element.
  for (int32 tstate = 1; tstate <= NumTransitionStates(); tstate++) {
    int32 tid = SelfLoopOf(tstate);
    if (tid == 0) {  // no self-loop
      non_self_loop_log_probs_(tstate) = 0.0;  // log(1.0)
    } else {
      BaseFloat self_loop_prob = Exp(GetTransitionLogProb(tid)),
          non_self_loop_prob = 1.0 - self_loop_prob;
      if (non_self_loop_prob <= 0.0) {
        KALDI_WARN << "ComputeDerivedOfProbs(): non-self-loop prob is " << non_self_loop_prob;
        non_self_loop_prob = 1.0e-10;  // just so we can continue...
      }
      non_self_loop_log_probs_(tstate) = Log(non_self_loop_prob);  // will be negative.
    }
  }
}

ComputeTuples()

void ComputeTuples ( const ContextDependencyInterface &  ctx_dep )

private

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

References TransitionModel::ComputeTuplesIsHmm(), TransitionModel::ComputeTuplesNotHmm(), TransitionModel::IsHmm(), and TransitionModel::tuples_.

Referenced by TransitionModel::TransitionModel().

                                                                             {
  if (IsHmm())
    ComputeTuplesIsHmm(ctx_dep);
  else
    ComputeTuplesNotHmm(ctx_dep);

  // now tuples_ is populated with all possible tuples of (phone, hmm_state, pdf, self_loop_pdf).
  std::sort(tuples_.begin(), tuples_.end());  // sort to enable reverse lookup.
  // this sorting defines the transition-ids.
}

ComputeTuplesIsHmm()

void ComputeTuplesIsHmm ( const ContextDependencyInterface &  ctx_dep )

private

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

References ContextDependencyInterface::GetPdfInfo(), HmmTopology::GetPhones(), rnnlm::i, rnnlm::j, KALDI_ASSERT, kaldi::kNoPdf, HmmTopology::NumPdfClasses(), TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by TransitionModel::ComputeTuples().

                                                                                  {
  const std::vector<int32> &phones = topo_.GetPhones();
  KALDI_ASSERT(!phones.empty());

  // this is the case for normal models. but not for chain models
  std::vector<std::vector<std::pair<int32, int32> > > pdf_info;
  std::vector<int32> num_pdf_classes( 1 + *std::max_element(phones.begin(), phones.end()), -1);
  for (size_t i = 0; i < phones.size(); i++)
    num_pdf_classes[phones[i]] = topo_.NumPdfClasses(phones[i]);
  ctx_dep.GetPdfInfo(phones, num_pdf_classes, &pdf_info);
  // pdf_info is list indexed by pdf of which (phone, pdf_class) it
  // can correspond to.

  std::map<std::pair<int32, int32>, std::vector<int32> > to_hmm_state_list;
  // to_hmm_state_list is a map from (phone, pdf_class) to the list
  // of hmm-states in the HMM for that phone that that (phone, pdf-class)
  // can correspond to.
  for (size_t i = 0; i < phones.size(); i++) {  // setting up to_hmm_state_list.
    int32 phone = phones[i];
    const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(phone);
    for (int32 j = 0; j < static_cast<int32>(entry.size()); j++) {  // for each state...
      int32 pdf_class = entry[j].forward_pdf_class;
      if (pdf_class != kNoPdf) {
        to_hmm_state_list[std::make_pair(phone, pdf_class)].push_back(j);
      }
    }
  }

  for (int32 pdf = 0; pdf < static_cast<int32>(pdf_info.size()); pdf++) {
    for (size_t j = 0; j < pdf_info[pdf].size(); j++) {
      int32 phone = pdf_info[pdf][j].first,
            pdf_class = pdf_info[pdf][j].second;
      const std::vector<int32> &state_vec = to_hmm_state_list[std::make_pair(phone, pdf_class)];
      KALDI_ASSERT(!state_vec.empty());
      // state_vec is a list of the possible HMM-states that emit this
      // pdf_class.
      for (size_t k = 0; k < state_vec.size(); k++) {
        int32 hmm_state = state_vec[k];
        tuples_.push_back(Tuple(phone, hmm_state, pdf, pdf));
      }
    }
  }
}

ComputeTuplesNotHmm()

void ComputeTuplesNotHmm ( const ContextDependencyInterface &  ctx_dep )

private

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

References ContextDependencyInterface::GetPdfInfo(), HmmTopology::GetPhones(), rnnlm::i, rnnlm::j, KALDI_ASSERT, kaldi::kNoPdf, TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by TransitionModel::ComputeTuples().

                                                                                   {
  const std::vector<int32> &phones = topo_.GetPhones();
  KALDI_ASSERT(!phones.empty());

  // pdf_info is a set of lists indexed by phone. Each list is indexed by
  // (pdf-class, self-loop pdf-class) of each state of that phone, and the element
  // is a list of possible (pdf, self-loop pdf) pairs that (pdf-class, self-loop pdf-class)
  // pair generates.
  std::vector<std::vector<std::vector<std::pair<int32, int32> > > > pdf_info;
  // pdf_class_pairs is a set of lists indexed by phone. Each list stores
  // (pdf-class, self-loop pdf-class) of each state of that phone.
  std::vector<std::vector<std::pair<int32, int32> > > pdf_class_pairs;
  pdf_class_pairs.resize(1 + *std::max_element(phones.begin(), phones.end()));
  for (size_t i = 0; i < phones.size(); i++) {
    int32 phone = phones[i];
    const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(phone);
    for (int32 j = 0; j < static_cast<int32>(entry.size()); j++) {  // for each state...
      int32 forward_pdf_class = entry[j].forward_pdf_class, self_loop_pdf_class = entry[j].self_loop_pdf_class;
      if (forward_pdf_class != kNoPdf)
        pdf_class_pairs[phone].push_back(std::make_pair(forward_pdf_class, self_loop_pdf_class));
    }
  }
  ctx_dep.GetPdfInfo(phones, pdf_class_pairs, &pdf_info);

  std::vector<std::map<std::pair<int32, int32>, std::vector<int32> > > to_hmm_state_list;
  to_hmm_state_list.resize(1 + *std::max_element(phones.begin(), phones.end()));
  // to_hmm_state_list is a phone-indexed set of maps from (pdf-class, self-loop pdf_class) to the list
  // of hmm-states in the HMM for that phone that that (pdf-class, self-loop pdf-class)
  // can correspond to.
  for (size_t i = 0; i < phones.size(); i++) {  // setting up to_hmm_state_list.
    int32 phone = phones[i];
    const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(phone);
    std::map<std::pair<int32, int32>, std::vector<int32> > phone_to_hmm_state_list;
    for (int32 j = 0; j < static_cast<int32>(entry.size()); j++) {  // for each state...
      int32 forward_pdf_class = entry[j].forward_pdf_class, self_loop_pdf_class = entry[j].self_loop_pdf_class;
      if (forward_pdf_class != kNoPdf) {
        phone_to_hmm_state_list[std::make_pair(forward_pdf_class, self_loop_pdf_class)].push_back(j);
      }
    }
    to_hmm_state_list[phone] = phone_to_hmm_state_list;
  }

  for (int32 i = 0; i < phones.size(); i++) {
    int32 phone = phones[i];
    for (int32 j = 0; j < static_cast<int32>(pdf_info[phone].size()); j++) {
      int32 pdf_class = pdf_class_pairs[phone][j].first,
            self_loop_pdf_class = pdf_class_pairs[phone][j].second;
      const std::vector<int32> &state_vec =
              to_hmm_state_list[phone][std::make_pair(pdf_class, self_loop_pdf_class)];
      KALDI_ASSERT(!state_vec.empty());
      for (size_t k = 0; k < state_vec.size(); k++) {
        int32 hmm_state = state_vec[k];
        for (size_t m = 0; m < pdf_info[phone][j].size(); m++) {
          int32 pdf = pdf_info[phone][j][m].first,
            self_loop_pdf = pdf_info[phone][j][m].second;
          tuples_.push_back(Tuple(phone, hmm_state, pdf, self_loop_pdf));
        }
      }
    }
  }
}

GetNonSelfLoopLogProb()

BaseFloat GetNonSelfLoopLogProb

(

int32

trans_state

)

const

Returns the log-prob of the non-self-loop probability mass for this transition state.

(you can get the self-loop prob, if a self-loop exists, by calling GetTransitionLogProb(SelfLoopOf(trans_state)).

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

References KALDI_ASSERT, and TransitionModel::non_self_loop_log_probs_.

Referenced by kaldi::AddSelfLoopsNoReorder(), kaldi::AddSelfLoopsReorder(), kaldi::GetScaledTransitionLogProb(), and TransitionModel::GetTransitionLogProbIgnoringSelfLoops().

                                                                        {
  KALDI_ASSERT(trans_state != 0);
  return non_self_loop_log_probs_(trans_state);
}

GetPhones()

const std::vector<int32>& GetPhones ( ) const

inline

Returns a sorted, unique list of phones.

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

References fst::Print().

Referenced by TrainingGraphCompiler::CompileGraph(), TrainingGraphCompiler::CompileGraphs(), kaldi::GetHTransducer(), main(), kaldi::TestSplitToPhones(), kaldi::TestWordAlignLatticeLexicon(), and TrainingGraphCompiler::TrainingGraphCompiler().

{ return topo_.GetPhones(); }

GetTopo()

const HmmTopology& GetTopo ( ) const

inline

return reference to HMM-topology object.

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

Referenced by kaldi::ConvertAlignmentForPhone(), kaldi::ConvertAlignmentInternal(), kaldi::GenerateRandomAlignment(), kaldi::GetHmmAsFsa(), kaldi::GetHmmAsFsaSimple(), kaldi::GetIlabelMapping(), kaldi::GetRandomAlignmentForPhone(), main(), and kaldi::SplitToPhonesInternal().

{ return topo_; }

GetTransitionLogProb()

BaseFloat GetTransitionLogProb

(

int32

trans_id

)

const

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

References TransitionModel::log_probs_.

Referenced by kaldi::AddSelfLoopsNoReorder(), kaldi::AddSelfLoopsReorder(), TransitionModel::ComputeDerivedOfProbs(), kaldi::GetHmmAsFsaSimple(), and kaldi::GetScaledTransitionLogProb().

                                                                    {
  return log_probs_(trans_id);
}

GetTransitionLogProbIgnoringSelfLoops()

BaseFloat GetTransitionLogProbIgnoringSelfLoops

(

int32

trans_id

)

const

Returns the log-probability of a particular non-self-loop transition after subtracting the probability mass of the self-loop and renormalizing; will crash if called on a self-loop.

Specifically: for non-self-loops it returns the log of (that prob divided by (1 minus self-loop-prob-for-that-state)).

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

References TransitionModel::GetNonSelfLoopLogProb(), TransitionModel::IsSelfLoop(), KALDI_ASSERT, KALDI_PARANOID_ASSERT, TransitionModel::log_probs_, and TransitionModel::TransitionIdToTransitionState().

Referenced by kaldi::GetHmmAsFsa(), and kaldi::GetScaledTransitionLogProb().

                                                                                     {
  KALDI_ASSERT(trans_id != 0);
  KALDI_PARANOID_ASSERT(!IsSelfLoop(trans_id));
  return log_probs_(trans_id) - GetNonSelfLoopLogProb(TransitionIdToTransitionState(trans_id));
}

GetTransitionProb()

BaseFloat GetTransitionProb

(

int32

trans_id

)

const

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

References kaldi::Exp(), and TransitionModel::log_probs_.

Referenced by TransitionModel::MapUpdate(), TransitionModel::MapUpdateShared(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), and TransitionModel::Print().

                                                                 {
  return Exp(log_probs_(trans_id));
}

InitializeProbs()

void InitializeProbs ( )

private

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

References TransitionModel::ComputeDerivedOfProbs(), TransitionModel::Tuple::hmm_state, TransitionModel::id2state_, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, kaldi::Log(), TransitionModel::log_probs_, TransitionModel::NumTransitionIds(), TransitionModel::Tuple::phone, TransitionModel::state2id_, TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by TransitionModel::TransitionModel().

                                      {
  log_probs_.Resize(NumTransitionIds()+1);  // one-based array, zeroth element empty.
  for (int32 trans_id = 1; trans_id <= NumTransitionIds(); trans_id++) {
    int32 trans_state = id2state_[trans_id];
    int32 trans_index = trans_id - state2id_[trans_state];
    const Tuple &tuple = tuples_[trans_state-1];
    const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(tuple.phone);
    KALDI_ASSERT(static_cast<size_t>(tuple.hmm_state) < entry.size());
    BaseFloat prob = entry[tuple.hmm_state].transitions[trans_index].second;
    if (prob <= 0.0)
      KALDI_ERR << "TransitionModel::InitializeProbs, zero "
          "probability [should remove that entry in the topology]";
    if (prob > 1.0)
      KALDI_WARN << "TransitionModel::InitializeProbs, prob greater than one.";
    log_probs_(trans_id) = Log(prob);
  }
  ComputeDerivedOfProbs();
}

InitStats()

void InitStats ( Vector< double > *  stats ) const

inline

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

References Vector< Real >::Resize().

Referenced by main().

{ stats->Resize(NumTransitionIds()+1); }

IsFinal()

bool IsFinal

(

int32

trans_id

)

const

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

References TransitionModel::Tuple::hmm_state, TransitionModel::id2state_, KALDI_ASSERT, TransitionModel::Tuple::phone, TransitionModel::state2id_, TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by kaldi::ConvertCompactLatticeToPhones(), kaldi::IsPlausibleWord(), LatticePhoneAligner::ComputationState::OutputArcForce(), LatticeWordAligner::ComputationState::OutputArcForce(), LatticeWordAligner::ComputationState::OutputNormalWordArc(), LatticeWordAligner::ComputationState::OutputOnePhoneWordArc(), LatticePhoneAligner::ComputationState::OutputPhoneArc(), ArcPosteriorComputer::OutputPosteriors(), LatticeWordAligner::ComputationState::OutputSilenceArc(), kaldi::SplitToPhonesInternal(), WordAlignedLatticeTester::TestArcNormalWord(), WordAlignedLatticeTester::TestArcOnePhoneWord(), and WordAlignedLatticeTester::TestArcSilence().

                                                  {
  KALDI_ASSERT(static_cast<size_t>(trans_id) < id2state_.size());
  int32 trans_state = id2state_[trans_id];
  int32 trans_index = trans_id - state2id_[trans_state];
  const Tuple &tuple = tuples_[trans_state-1];
  const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(tuple.phone);
  KALDI_ASSERT(static_cast<size_t>(tuple.hmm_state) < entry.size());
  KALDI_ASSERT(static_cast<size_t>(tuple.hmm_state) < entry.size());
  KALDI_ASSERT(static_cast<size_t>(trans_index) <
               entry[tuple.hmm_state].transitions.size());
  // return true if the transition goes to the final state of the
  // topology entry.
  return (entry[tuple.hmm_state].transitions[trans_index].first + 1 ==
          static_cast<int32>(entry.size()));
}

IsHmm()

bool IsHmm ( ) const

private

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

References HmmTopology::GetPhones(), rnnlm::i, rnnlm::j, KALDI_ASSERT, TransitionModel::topo_, and HmmTopology::TopologyForPhone().

Referenced by TransitionModel::ComputeTuples(), TransitionModel::MapUpdateShared(), TransitionModel::MleUpdateShared(), TransitionModel::Print(), and TransitionModel::Write().

                                  {
  const std::vector<int32> &phones = topo_.GetPhones();
  KALDI_ASSERT(!phones.empty());
  for (size_t i = 0; i < phones.size(); i++) {
    int32 phone = phones[i];
    const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(phone);
    for (int32 j = 0; j < static_cast<int32>(entry.size()); j++) {  // for each state...
      if (entry[j].forward_pdf_class != entry[j].self_loop_pdf_class)
        return false;
    }
  }
  return true;
}

IsSelfLoop()

bool IsSelfLoop

(

int32

trans_id

)

const

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

References TransitionModel::Tuple::hmm_state, TransitionModel::id2state_, KALDI_ASSERT, TransitionModel::Tuple::phone, TransitionModel::state2id_, TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by kaldi::ChangeReorderingOfAlignment(), TransitionModel::ComputeDerived(), kaldi::ConvertLatticeToPhones(), fst::DeterminizeLatticeInsertPhones(), kaldi::GetScaledTransitionLogProb(), TransitionModel::GetTransitionLogProbIgnoringSelfLoops(), kaldi::IsPlausibleWord(), kaldi::IsReordered(), LatticeWordAligner::ComputationState::OutputArcForce(), LatticeWordAligner::ComputationState::OutputNormalWordArc(), LatticeWordAligner::ComputationState::OutputOnePhoneWordArc(), LatticePhoneAligner::ComputationState::OutputPhoneArc(), LatticeWordAligner::ComputationState::OutputSilenceArc(), TransitionModel::Print(), kaldi::SplitToPhonesInternal(), WordAlignedLatticeTester::TestArcNormalWord(), and TransitionModel::TransitionIdToPdfClass().

                                                     {
  KALDI_ASSERT(static_cast<size_t>(trans_id) < id2state_.size());
  int32 trans_state = id2state_[trans_id];
  int32 trans_index = trans_id - state2id_[trans_state];
  const Tuple &tuple = tuples_[trans_state-1];
  int32 phone = tuple.phone, hmm_state = tuple.hmm_state;
  const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(phone);
  KALDI_ASSERT(static_cast<size_t>(hmm_state) < entry.size());
  return (static_cast<size_t>(trans_index) < entry[hmm_state].transitions.size()
          && entry[hmm_state].transitions[trans_index].first == hmm_state);
}

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( TransitionModel  )

private

MapUpdate()

void MapUpdate	(	const Vector< double > &	stats,
		const MapTransitionUpdateConfig &	cfg,
		BaseFloat *	objf_impr_out,
		BaseFloat *	count_out
	)

Does Maximum A Posteriori (MAP) estimation.

The stats are counts/weights, indexed by transition-id.

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

References TransitionModel::ComputeDerivedOfProbs(), VectorBase< Real >::Dim(), TransitionModel::GetTransitionProb(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kaldi::Log(), TransitionModel::log_probs_, TransitionModel::MapUpdateShared(), rnnlm::n, TransitionModel::NumTransitionIds(), TransitionModel::NumTransitionIndices(), TransitionModel::NumTransitionStates(), TransitionModel::PairToTransitionId(), MapTransitionUpdateConfig::share_for_pdfs, VectorBase< Real >::Sum(), and MapTransitionUpdateConfig::tau.

Referenced by main().

                                                      {
  KALDI_ASSERT(cfg.tau > 0.0);
  if (cfg.share_for_pdfs) {
    MapUpdateShared(stats, cfg, objf_impr_out, count_out);
    return;
  }
  BaseFloat count_sum = 0.0, objf_impr_sum = 0.0;
  KALDI_ASSERT(stats.Dim() == NumTransitionIds()+1);
  for (int32 tstate = 1; tstate <= NumTransitionStates(); tstate++) {
    int32 n = NumTransitionIndices(tstate);
    KALDI_ASSERT(n>=1);
    if (n > 1) {  // no point updating if only one transition...
      Vector<double> counts(n);
      for (int32 tidx = 0; tidx < n; tidx++) {
        int32 tid = PairToTransitionId(tstate, tidx);
        counts(tidx) = stats(tid);
      }
      double tstate_tot = counts.Sum();
      count_sum += tstate_tot;
      Vector<BaseFloat> old_probs(n), new_probs(n);
      for (int32 tidx = 0; tidx < n; tidx++) {
        int32 tid = PairToTransitionId(tstate, tidx);
        old_probs(tidx) = new_probs(tidx) = GetTransitionProb(tid);
      }
      for (int32 tidx = 0; tidx < n; tidx++)
        new_probs(tidx) = (counts(tidx) + cfg.tau * old_probs(tidx)) /
            (cfg.tau + tstate_tot);
      // Compute objf change
      for (int32 tidx = 0; tidx < n; tidx++) {
        double objf_change = counts(tidx) * (Log(new_probs(tidx))
                                             - Log(old_probs(tidx)));
        objf_impr_sum += objf_change;
      }
      // Commit updated values.
      for (int32 tidx = 0; tidx < n; tidx++) {
        int32 tid = PairToTransitionId(tstate, tidx);
        log_probs_(tid) = Log(new_probs(tidx));
        if (log_probs_(tid) - log_probs_(tid) != 0.0)
          KALDI_ERR << "Log probs is inf or NaN: error in update or bad stats?";
      }
    }
  }
  KALDI_LOG << "Objf change is " << (objf_impr_sum / count_sum)
            << " per frame over " << count_sum
            << " frames.";
  if (objf_impr_out) *objf_impr_out = objf_impr_sum;
  if (count_out) *count_out = count_sum;
  ComputeDerivedOfProbs();
}

MapUpdateShared()

void MapUpdateShared ( const Vector< double > &  stats, const MapTransitionUpdateConfig &  cfg, BaseFloat *  objf_impr_out, BaseFloat *  count_out  )

private

This version of the MapUpdate() function is for if the user specifies –share-for-pdfs=true.

We share the transitions for all states that share the same pdf.

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

References TransitionModel::ComputeDerivedOfProbs(), VectorBase< Real >::Dim(), TransitionModel::GetTransitionProb(), TransitionModel::IsHmm(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kaldi::Log(), TransitionModel::log_probs_, rnnlm::n, TransitionModel::NumTransitionIds(), TransitionModel::NumTransitionIndices(), TransitionModel::NumTransitionStates(), TransitionModel::PairToTransitionId(), MapTransitionUpdateConfig::share_for_pdfs, VectorBase< Real >::Sum(), MapTransitionUpdateConfig::tau, TransitionModel::TransitionStateToForwardPdf(), and TransitionModel::TransitionStateToSelfLoopPdf().

Referenced by TransitionModel::MapUpdate().

                                                            {
  KALDI_ASSERT(cfg.share_for_pdfs);

  BaseFloat count_sum = 0.0, objf_impr_sum = 0.0;
  KALDI_ASSERT(stats.Dim() == NumTransitionIds()+1);
  std::map<int32, std::set<int32> > pdf_to_tstate;

  for (int32 tstate = 1; tstate <= NumTransitionStates(); tstate++) {
    int32 pdf = TransitionStateToForwardPdf(tstate);
    pdf_to_tstate[pdf].insert(tstate);
    if (!IsHmm()) {
      pdf = TransitionStateToSelfLoopPdf(tstate);
      pdf_to_tstate[pdf].insert(tstate);
    }
  }
  std::map<int32, std::set<int32> >::iterator map_iter;
  for (map_iter = pdf_to_tstate.begin();
       map_iter != pdf_to_tstate.end();
       ++map_iter) {
    // map_iter->first is pdf-id... not needed.
    const std::set<int32> &tstates = map_iter->second;
    KALDI_ASSERT(!tstates.empty());
    int32 one_tstate = *(tstates.begin());
    int32 n = NumTransitionIndices(one_tstate);
    KALDI_ASSERT(n >= 1);
    if (n > 1) { // Only update if >1 transition...
      Vector<double> counts(n);
      for (std::set<int32>::const_iterator iter = tstates.begin();
           iter != tstates.end();
           ++iter) {
        int32 tstate = *iter;
        if (NumTransitionIndices(tstate) != n)
          KALDI_ERR << "Mismatch in #transition indices: you cannot "
              "use the --share-for-pdfs option with this topology "
              "and sharing scheme.";
        for (int32 tidx = 0; tidx < n; tidx++) {
          int32 tid = PairToTransitionId(tstate, tidx);
          counts(tidx) += stats(tid);
        }
      }
      double pdf_tot = counts.Sum();
      count_sum += pdf_tot;

      // Note: when calculating objf improvement, we
      // assume we previously had the same tying scheme so
      // we can get the params from one_tstate and they're valid
      // for all.
      Vector<BaseFloat> old_probs(n), new_probs(n);
      for (int32 tidx = 0; tidx < n; tidx++) {
        int32 tid = PairToTransitionId(one_tstate, tidx);
        old_probs(tidx) = new_probs(tidx) = GetTransitionProb(tid);
      }
      for (int32 tidx = 0; tidx < n; tidx++)
        new_probs(tidx) = (counts(tidx) + old_probs(tidx) * cfg.tau) /
            (pdf_tot + cfg.tau);
      // Compute objf change
      for (int32 tidx = 0; tidx < n; tidx++) {
        double objf_change = counts(tidx) * (Log(new_probs(tidx))
                                             - Log(old_probs(tidx)));
        objf_impr_sum += objf_change;
      }
      // Commit updated values.
      for (std::set<int32>::const_iterator iter = tstates.begin();
           iter != tstates.end();
           ++iter) {
        int32 tstate = *iter;
        for (int32 tidx = 0; tidx < n; tidx++) {
          int32 tid = PairToTransitionId(tstate, tidx);
          log_probs_(tid) = Log(new_probs(tidx));
          if (log_probs_(tid) - log_probs_(tid) != 0.0)
            KALDI_ERR << "Log probs is inf or NaN: error in update or bad stats?";
        }
      }
    }
  }
  KALDI_LOG << "Objf change is " << (objf_impr_sum / count_sum)
            << " per frame over " << count_sum
            << " frames.";
  if (objf_impr_out) *objf_impr_out = objf_impr_sum;
  if (count_out) *count_out = count_sum;
  ComputeDerivedOfProbs();
}

MleUpdate()

void MleUpdate	(	const Vector< double > &	stats,
		const MleTransitionUpdateConfig &	cfg,
		BaseFloat *	objf_impr_out,
		BaseFloat *	count_out
	)

Does Maximum Likelihood estimation.

The stats are counts/weights, indexed by transition-id. This was previously called Update().

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

References TransitionModel::ComputeDerivedOfProbs(), VectorBase< Real >::Dim(), MleTransitionUpdateConfig::floor, TransitionModel::GetTransitionProb(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kaldi::Log(), TransitionModel::log_probs_, MleTransitionUpdateConfig::mincount, TransitionModel::MleUpdateShared(), rnnlm::n, TransitionModel::NumTransitionIds(), TransitionModel::NumTransitionIndices(), TransitionModel::NumTransitionStates(), TransitionModel::PairToTransitionId(), VectorBase< Real >::Scale(), MleTransitionUpdateConfig::share_for_pdfs, and VectorBase< Real >::Sum().

Referenced by main().

                                                      {
  if (cfg.share_for_pdfs) {
    MleUpdateShared(stats, cfg, objf_impr_out, count_out);
    return;
  }
  BaseFloat count_sum = 0.0, objf_impr_sum = 0.0;
  int32 num_skipped = 0, num_floored = 0;
  KALDI_ASSERT(stats.Dim() == NumTransitionIds()+1);
  for (int32 tstate = 1; tstate <= NumTransitionStates(); tstate++) {
    int32 n = NumTransitionIndices(tstate);
    KALDI_ASSERT(n>=1);
    if (n > 1) {  // no point updating if only one transition...
      Vector<double> counts(n);
      for (int32 tidx = 0; tidx < n; tidx++) {
        int32 tid = PairToTransitionId(tstate, tidx);
        counts(tidx) = stats(tid);
      }
      double tstate_tot = counts.Sum();
      count_sum += tstate_tot;
      if (tstate_tot < cfg.mincount) { num_skipped++; }
      else {
        Vector<BaseFloat> old_probs(n), new_probs(n);
        for (int32 tidx = 0; tidx < n; tidx++) {
          int32 tid = PairToTransitionId(tstate, tidx);
          old_probs(tidx) = new_probs(tidx) = GetTransitionProb(tid);
        }
        for (int32 tidx = 0; tidx < n; tidx++)
          new_probs(tidx) = counts(tidx) / tstate_tot;
        for (int32 i = 0; i < 3; i++) {  // keep flooring+renormalizing for 3 times..
          new_probs.Scale(1.0 / new_probs.Sum());
          for (int32 tidx = 0; tidx < n; tidx++)
            new_probs(tidx) = std::max(new_probs(tidx), cfg.floor);
        }
        // Compute objf change
        for (int32 tidx = 0; tidx < n; tidx++) {
          if (new_probs(tidx) == cfg.floor) num_floored++;
          double objf_change = counts(tidx) * (Log(new_probs(tidx))
                                               - Log(old_probs(tidx)));
          objf_impr_sum += objf_change;
        }
        // Commit updated values.
        for (int32 tidx = 0; tidx < n; tidx++) {
          int32 tid = PairToTransitionId(tstate, tidx);
          log_probs_(tid) = Log(new_probs(tidx));
          if (log_probs_(tid) - log_probs_(tid) != 0.0)
            KALDI_ERR << "Log probs is inf or NaN: error in update or bad stats?";
        }
      }
    }
  }
  KALDI_LOG << "TransitionModel::Update, objf change is "
            << (objf_impr_sum / count_sum) << " per frame over " << count_sum
            << " frames. ";
  KALDI_LOG <<  num_floored << " probabilities floored, " << num_skipped
            << " out of " << NumTransitionStates() << " transition-states "
      "skipped due to insuffient data (it is normal to have some skipped.)";
  if (objf_impr_out) *objf_impr_out = objf_impr_sum;
  if (count_out) *count_out = count_sum;
  ComputeDerivedOfProbs();
}

MleUpdateShared()

void MleUpdateShared ( const Vector< double > &  stats, const MleTransitionUpdateConfig &  cfg, BaseFloat *  objf_impr_out, BaseFloat *  count_out  )

private

This version of the Update() function is for if the user specifies –share-for-pdfs=true.

We share the transitions for all states that share the same pdf.

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

References TransitionModel::ComputeDerivedOfProbs(), VectorBase< Real >::Dim(), MleTransitionUpdateConfig::floor, TransitionModel::GetTransitionProb(), rnnlm::i, TransitionModel::IsHmm(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kaldi::Log(), TransitionModel::log_probs_, MleTransitionUpdateConfig::mincount, rnnlm::n, TransitionModel::NumTransitionIds(), TransitionModel::NumTransitionIndices(), TransitionModel::NumTransitionStates(), TransitionModel::PairToTransitionId(), VectorBase< Real >::Scale(), MleTransitionUpdateConfig::share_for_pdfs, VectorBase< Real >::Sum(), TransitionModel::TransitionStateToForwardPdf(), and TransitionModel::TransitionStateToSelfLoopPdf().

Referenced by TransitionModel::MleUpdate().

                                                            {
  KALDI_ASSERT(cfg.share_for_pdfs);

  BaseFloat count_sum = 0.0, objf_impr_sum = 0.0;
  int32 num_skipped = 0, num_floored = 0;
  KALDI_ASSERT(stats.Dim() == NumTransitionIds()+1);
  std::map<int32, std::set<int32> > pdf_to_tstate;

  for (int32 tstate = 1; tstate <= NumTransitionStates(); tstate++) {
    int32 pdf = TransitionStateToForwardPdf(tstate);
    pdf_to_tstate[pdf].insert(tstate);
    if (!IsHmm()) {
      pdf = TransitionStateToSelfLoopPdf(tstate);
      pdf_to_tstate[pdf].insert(tstate);
    }
  }
  std::map<int32, std::set<int32> >::iterator map_iter;
  for (map_iter = pdf_to_tstate.begin();
       map_iter != pdf_to_tstate.end();
       ++map_iter) {
    // map_iter->first is pdf-id... not needed.
    const std::set<int32> &tstates = map_iter->second;
    KALDI_ASSERT(!tstates.empty());
    int32 one_tstate = *(tstates.begin());
    int32 n = NumTransitionIndices(one_tstate);
    KALDI_ASSERT(n >= 1);
    if (n > 1) { // Only update if >1 transition...
      Vector<double> counts(n);
      for (std::set<int32>::const_iterator iter = tstates.begin();
           iter != tstates.end();
           ++iter) {
        int32 tstate = *iter;
        if (NumTransitionIndices(tstate) != n)
          KALDI_ERR << "Mismatch in #transition indices: you cannot "
              "use the --share-for-pdfs option with this topology "
              "and sharing scheme.";
        for (int32 tidx = 0; tidx < n; tidx++) {
          int32 tid = PairToTransitionId(tstate, tidx);
          counts(tidx) += stats(tid);
        }
      }
      double pdf_tot = counts.Sum();
      count_sum += pdf_tot;
      if (pdf_tot < cfg.mincount) { num_skipped++; }
      else {
        // Note: when calculating objf improvement, we
        // assume we previously had the same tying scheme so
        // we can get the params from one_tstate and they're valid
        // for all.
        Vector<BaseFloat> old_probs(n), new_probs(n);
        for (int32 tidx = 0; tidx < n; tidx++) {
          int32 tid = PairToTransitionId(one_tstate, tidx);
          old_probs(tidx) = new_probs(tidx) = GetTransitionProb(tid);
        }
        for (int32 tidx = 0; tidx < n; tidx++)
          new_probs(tidx) = counts(tidx) / pdf_tot;
        for (int32 i = 0; i < 3; i++) {  // keep flooring+renormalizing for 3 times..
          new_probs.Scale(1.0 / new_probs.Sum());
          for (int32 tidx = 0; tidx < n; tidx++)
            new_probs(tidx) = std::max(new_probs(tidx), cfg.floor);
        }
        // Compute objf change
        for (int32 tidx = 0; tidx < n; tidx++) {
          if (new_probs(tidx) == cfg.floor) num_floored++;
          double objf_change = counts(tidx) * (Log(new_probs(tidx))
                                               - Log(old_probs(tidx)));
          objf_impr_sum += objf_change;
        }
        // Commit updated values.
        for (std::set<int32>::const_iterator iter = tstates.begin();
             iter != tstates.end();
             ++iter) {
          int32 tstate = *iter;
          for (int32 tidx = 0; tidx < n; tidx++) {
            int32 tid = PairToTransitionId(tstate, tidx);
            log_probs_(tid) = Log(new_probs(tidx));
            if (log_probs_(tid) - log_probs_(tid) != 0.0)
              KALDI_ERR << "Log probs is inf or NaN: error in update or bad stats?";
          }
        }
      }
    }
  }
  KALDI_LOG << "Objf change is " << (objf_impr_sum / count_sum)
            << " per frame over " << count_sum << " frames; "
            << num_floored << " probabilities floored, "
            << num_skipped << " pdf-ids skipped due to insuffient data.";
  if (objf_impr_out) *objf_impr_out = objf_impr_sum;
  if (count_out) *count_out = count_sum;
  ComputeDerivedOfProbs();
}

NumPdfs()

int32 NumPdfs ( ) const

inline

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

Referenced by DecodableMatrixMappedOffset::AcceptLoglikes(), DecodableAmNnetParallel::Compute(), DecodableAmNnet::DecodableAmNnet(), DecodableDiagGmmScaledOnline::DecodableDiagGmmScaledOnline(), DecodableMatrixMapped::DecodableMatrixMapped(), DecodableMatrixScaledMapped::DecodableMatrixScaledMapped(), DecodableNnet2Online::DecodableNnet2Online(), kaldi::GetPdfToPhonesMap(), DiscriminativeComputation::LookupNnetOutput(), main(), OnlineDecodableDiagGmmScaled::OnlineDecodableDiagGmmScaled(), kaldi::PosteriorToPdfMatrix(), TransitionModel::Print(), kaldi::nnet3::SetPriors(), kaldi::nnet2::SetPriors(), kaldi::nnet2::UnitTestAmNnet(), kaldi::nnet2::UnitTestNnetDecodable(), and kaldi::nnet2::UpdateHash().

{ return num_pdfs_; }

NumPhones()

int32 NumPhones

(

)

const

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

References rnnlm::i, and TransitionModel::tuples_.

Referenced by main().

                                       {
  int32 num_trans_state = tuples_.size();
  int32 max_phone_id = 0;
  for (int32 i = 0; i < num_trans_state; ++i) {
    if (tuples_[i].phone > max_phone_id)
      max_phone_id = tuples_[i].phone;
  }
  return max_phone_id;
}

NumTransitionIds()

int32 NumTransitionIds ( ) const

inline

Returns the total number of transition-ids (note, these are one-based).

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

Referenced by kaldi::AddTransitionProbs(), TransitionModel::Check(), kaldi::GetHTransducer(), kaldi::GetPdfToPhonesMap(), kaldi::GetPdfToTransitionIdTransducer(), TransitionModel::InitializeProbs(), kaldi::LatticeBoost(), main(), TransitionModel::MapUpdate(), TransitionModel::MapUpdateShared(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), OnlineDecodableDiagGmmScaled::NumIndices(), DecodableDiagGmmScaledOnline::NumIndices(), DecodableAmDiagGmmRegtreeFmllr::NumIndices(), DecodableAmSgmm2::NumIndices(), DecodableMatrixScaledMapped::NumIndices(), DecodableAmNnet::NumIndices(), DecodableAmDiagGmmRegtreeMllr::NumIndices(), DecodableMatrixMapped::NumIndices(), DecodableAmNnetParallel::NumIndices(), DecodableMatrixMappedOffset::NumIndices(), and kaldi::nnet2::UnitTestNnetDecodable().

{ return id2state_.size()-1; }

NumTransitionIndices()

int32 NumTransitionIndices

(

int32

trans_state

)

const

Returns the number of transition-indices for a particular transition-state.

Note: "Indices" is the plural of "index". Index is not the same as "id", here. A transition-index is a zero-based offset into the transitions out of a particular transition state.

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

References KALDI_ASSERT, TransitionModel::state2id_, and TransitionModel::tuples_.

Referenced by TransitionModel::Check(), main(), TransitionModel::MapUpdate(), TransitionModel::MapUpdateShared(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), and TransitionModel::Print().

                                                                   {
  KALDI_ASSERT(static_cast<size_t>(trans_state) <= tuples_.size());
  return static_cast<int32>(state2id_[trans_state+1]-state2id_[trans_state]);
}

NumTransitionStates()

int32 NumTransitionStates ( ) const

inline

Returns the total number of transition-states (note, these are one-based).

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

Referenced by TransitionModel::Check(), TransitionModel::ComputeDerivedOfProbs(), kaldi::GetPdfsForPhones(), kaldi::GetPhonesForPdfs(), main(), TransitionModel::MapUpdate(), TransitionModel::MapUpdateShared(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), and TransitionModel::Print().

{ return tuples_.size(); }

PairToTransitionId()

int32 PairToTransitionId	(	int32	trans_state,
		int32	trans_index
	)		const

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

References KALDI_ASSERT, TransitionModel::state2id_, and TransitionModel::tuples_.

Referenced by TransitionModel::Check(), kaldi::ConvertAlignmentForPhone(), kaldi::GenerateRandomAlignment(), kaldi::GetHmmAsFsa(), kaldi::GetHmmAsFsaSimple(), TransitionModel::MapUpdate(), TransitionModel::MapUpdateShared(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), TransitionModel::Print(), and TransitionModel::SelfLoopOf().

                                                                                    {
  KALDI_ASSERT(static_cast<size_t>(trans_state) <= tuples_.size());
  KALDI_ASSERT(trans_index < state2id_[trans_state+1] - state2id_[trans_state]);
  return state2id_[trans_state] + trans_index;
}

Print()

void Print	(	std::ostream &	os,
		const std::vector< std::string > &	phone_names,
		const Vector< double > *	occs = NULL
	)

Print will print the transition model in a human-readable way, for purposes of human inspection.

The "occs" are optional (they are indexed by pdf-id).

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

References VectorBase< Real >::Dim(), TransitionModel::Tuple::forward_pdf, TransitionModel::GetTransitionProb(), TransitionModel::Tuple::hmm_state, TransitionModel::IsHmm(), TransitionModel::IsSelfLoop(), KALDI_ASSERT, TransitionModel::NumPdfs(), TransitionModel::NumTransitionIndices(), TransitionModel::NumTransitionStates(), TransitionModel::PairToTransitionId(), TransitionModel::Tuple::phone, TransitionModel::Tuple::self_loop_pdf, TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by main().

                                                        {
  if (occs != NULL)
    KALDI_ASSERT(occs->Dim() == NumPdfs());
  bool is_hmm = IsHmm();
  for (int32 tstate = 1; tstate <= NumTransitionStates(); tstate++) {
    const Tuple &tuple = tuples_[tstate-1];
    KALDI_ASSERT(static_cast<size_t>(tuple.phone) < phone_names.size());
    std::string phone_name = phone_names[tuple.phone];

    os << "Transition-state " << tstate << ": phone = " << phone_name
       << " hmm-state = " << tuple.hmm_state;
    if (is_hmm)
      os << " pdf = " << tuple.forward_pdf << '\n';
    else
      os << " forward-pdf = " << tuple.forward_pdf << " self-loop-pdf = "
         << tuple.self_loop_pdf << '\n';
    for (int32 tidx = 0; tidx < NumTransitionIndices(tstate); tidx++) {
      int32 tid = PairToTransitionId(tstate, tidx);
      BaseFloat p = GetTransitionProb(tid);
      os << " Transition-id = " << tid << " p = " << p;
      if (occs != NULL) {
        if (IsSelfLoop(tid))
          os << " count of pdf = " << (*occs)(tuple.self_loop_pdf);
        else
          os << " count of pdf = " << (*occs)(tuple.forward_pdf);
      }
      // now describe what it's a transition to.
      if (IsSelfLoop(tid)) os << " [self-loop]\n";
      else {
        int32 hmm_state = tuple.hmm_state;
        const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(tuple.phone);
        KALDI_ASSERT(static_cast<size_t>(hmm_state) < entry.size());
        int32 next_hmm_state = entry[hmm_state].transitions[tidx].first;
        KALDI_ASSERT(next_hmm_state != hmm_state);
        os << " [" << hmm_state << " -> " << next_hmm_state << "]\n";
      }
    }
  }
}

Read()

void Read	(	std::istream &	is,
		bool	binary
	)

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

References TransitionModel::Check(), TransitionModel::ComputeDerived(), TransitionModel::ComputeDerivedOfProbs(), kaldi::ExpectToken(), rnnlm::i, KALDI_ASSERT, TransitionModel::log_probs_, HmmTopology::Read(), kaldi::ReadBasicType(), kaldi::ReadToken(), TransitionModel::topo_, and TransitionModel::tuples_.

Referenced by kaldi::InitAmGmmFromOld(), main(), OnlineGmmDecodingModels::OnlineGmmDecodingModels(), Nnet::Read(), and kaldi::TestTransitionModel().

                                                      {
  ExpectToken(is, binary, "<TransitionModel>");
  topo_.Read(is, binary);
  std::string token;
  ReadToken(is, binary, &token);
  int32 size;
  ReadBasicType(is, binary, &size);
  tuples_.resize(size);
  for (int32 i = 0; i < size; i++) {
    ReadBasicType(is, binary, &(tuples_[i].phone));
    ReadBasicType(is, binary, &(tuples_[i].hmm_state));
    ReadBasicType(is, binary, &(tuples_[i].forward_pdf));
    if (token == "<Tuples>")
      ReadBasicType(is, binary, &(tuples_[i].self_loop_pdf));
    else if (token == "<Triples>")
      tuples_[i].self_loop_pdf = tuples_[i].forward_pdf;
  }
  ReadToken(is, binary, &token);
  KALDI_ASSERT(token == "</Triples>" || token == "</Tuples>");
  ComputeDerived();
  ExpectToken(is, binary, "<LogProbs>");
  log_probs_.Read(is, binary);
  ExpectToken(is, binary, "</LogProbs>");
  ExpectToken(is, binary, "</TransitionModel>");
  ComputeDerivedOfProbs();
  Check();
}

SelfLoopOf()

int32 SelfLoopOf

(

int32

trans_state

)

const

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

References KALDI_ASSERT, TransitionModel::PairToTransitionId(), TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by kaldi::AddSelfLoopsNoReorder(), kaldi::AddSelfLoopsReorder(), and TransitionModel::ComputeDerivedOfProbs().

                                                         {  // returns the self-loop transition-id,
  KALDI_ASSERT(static_cast<size_t>(trans_state-1) < tuples_.size());
  const Tuple &tuple = tuples_[trans_state-1];
  // or zero if does not exist.
  int32 phone = tuple.phone, hmm_state = tuple.hmm_state;
  const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(phone);
  KALDI_ASSERT(static_cast<size_t>(hmm_state) < entry.size());
  for (int32 trans_index = 0;
      trans_index < static_cast<int32>(entry[hmm_state].transitions.size());
      trans_index++)
    if (entry[hmm_state].transitions[trans_index].first == hmm_state)
      return PairToTransitionId(trans_state, trans_index);
  return 0;  // invalid transition id.
}

TransitionIdToHmmState()

int32 TransitionIdToHmmState

(

int32

trans_id

)

const

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

References TransitionModel::Tuple::hmm_state, TransitionModel::id2state_, KALDI_ASSERT, and TransitionModel::tuples_.

Referenced by kaldi::ConvertAlignmentForPhone(), kaldi::ConvertLatticeToPhones(), and fst::DeterminizeLatticeInsertPhones().

                                                                  {
  KALDI_ASSERT(trans_id != 0 && static_cast<size_t>(trans_id) < id2state_.size());
  int32 trans_state = id2state_[trans_id];
  const Tuple &t = tuples_[trans_state-1];
  return t.hmm_state;
}

TransitionIdToPdfClass()

int32 TransitionIdToPdfClass

(

int32

trans_id

)

const

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

References TransitionModel::Tuple::hmm_state, TransitionModel::id2state_, TransitionModel::IsSelfLoop(), KALDI_ASSERT, TransitionModel::Tuple::phone, TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by kaldi::AccumulateTreeStats().

                                                                  {
  KALDI_ASSERT(trans_id != 0 && static_cast<size_t>(trans_id) < id2state_.size());
  int32 trans_state = id2state_[trans_id];

  const Tuple &t = tuples_[trans_state-1];
  const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(t.phone);
  KALDI_ASSERT(static_cast<size_t>(t.hmm_state) < entry.size());
  if (IsSelfLoop(trans_id))
    return entry[t.hmm_state].self_loop_pdf_class;
  else
    return entry[t.hmm_state].forward_pdf_class;
}

TransitionIdToPhone()

int32 TransitionIdToPhone

(

int32

trans_id

)

const

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

References TransitionModel::id2state_, KALDI_ASSERT, and TransitionModel::tuples_.

Referenced by kaldi::AccumulateTreeStats(), LatticeLexiconWordAligner::ComputationState::Advance(), kaldi::CompactLatticeToWordProns(), kaldi::ConvertAlignmentForPhone(), kaldi::ConvertAlignmentInternal(), kaldi::ConvertCompactLatticeToPhones(), kaldi::ConvertLatticeToPhones(), kaldi::ConvertPosteriorToPhones(), fst::DeterminizeLatticeInsertPhones(), OnlineFasterDecoder::EndOfUtterance(), OnlineSilenceWeighting::GetDeltaWeights(), kaldi::GetPdfToPhonesMap(), kaldi::IsPlausibleWord(), kaldi::LatticeActivePhones(), kaldi::LatticeBoost(), kaldi::LatticeForwardBackwardMpeVariants(), main(), LatticePhoneAligner::ComputationState::OutputArcForce(), LatticeWordAligner::ComputationState::OutputArcForce(), LatticeWordAligner::ComputationState::OutputNormalWordArc(), LatticeWordAligner::ComputationState::OutputOnePhoneWordArc(), LatticePhoneAligner::ComputationState::OutputPhoneArc(), ArcPosteriorComputer::OutputPosteriors(), LatticeWordAligner::ComputationState::OutputSilenceArc(), WordAlignedLatticeTester::TestArcNormalWord(), WordAlignedLatticeTester::TestArcOnePhoneWord(), WordAlignedLatticeTester::TestArcSilence(), kaldi::TestConvertAlignment(), kaldi::TestSplitToPhones(), kaldi::TrailingSilenceLength(), kaldi::WeightSilencePost(), and kaldi::WeightSilencePostDistributed().

                                                               {
  KALDI_ASSERT(trans_id != 0 && static_cast<size_t>(trans_id) < id2state_.size());
  int32 trans_state = id2state_[trans_id];
  return tuples_[trans_state-1].phone;
}

TransitionIdToTransitionIndex()

int32 TransitionIdToTransitionIndex

(

int32

trans_id

)

const

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

References TransitionModel::id2state_, KALDI_ASSERT, and TransitionModel::state2id_.

Referenced by TransitionModel::Check(), and kaldi::ConvertAlignmentForPhone().

                                                                         {
  KALDI_ASSERT(trans_id != 0 && static_cast<size_t>(trans_id) < id2state_.size());
  return trans_id - state2id_[id2state_[trans_id]];
}

TransitionIdToTransitionState()

int32 TransitionIdToTransitionState

(

int32

trans_id

)

const

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

References TransitionModel::id2state_, and KALDI_ASSERT.

Referenced by kaldi::ChangeReorderingOfAlignment(), TransitionModel::Check(), kaldi::ConvertAlignmentForPhone(), kaldi::GetScaledTransitionLogProb(), TransitionModel::GetTransitionLogProbIgnoringSelfLoops(), kaldi::IsReordered(), main(), kaldi::SplitToPhonesInternal(), WordAlignedLatticeTester::TestArcNormalWord(), WordAlignedLatticeTester::TestArcOnePhoneWord(), and WordAlignedLatticeTester::TestArcSilence().

                                                                         {
  KALDI_ASSERT(trans_id != 0 &&  static_cast<size_t>(trans_id) < id2state_.size());
  return id2state_[trans_id];
}

TransitionStateToForwardPdf()

int32 TransitionStateToForwardPdf

(

int32

trans_state

)

const

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

References KALDI_ASSERT, and TransitionModel::tuples_.

Referenced by TransitionModel::Check(), kaldi::GetPdfsForPhones(), kaldi::GetPhonesForPdfs(), TransitionModel::MapUpdateShared(), and TransitionModel::MleUpdateShared().

                                                                          {
  KALDI_ASSERT(static_cast<size_t>(trans_state) <= tuples_.size());
  return tuples_[trans_state-1].forward_pdf;
}

TransitionStateToForwardPdfClass()

int32 TransitionStateToForwardPdfClass

(

int32

trans_state

)

const

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

References KALDI_ASSERT, TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by kaldi::ConvertAlignmentForPhone().

                             {
  KALDI_ASSERT(static_cast<size_t>(trans_state) <= tuples_.size());
  const Tuple &t = tuples_[trans_state-1];
  const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(t.phone);
  KALDI_ASSERT(static_cast<size_t>(t.hmm_state) < entry.size());
  return entry[t.hmm_state].forward_pdf_class;
}

TransitionStateToHmmState()

int32 TransitionStateToHmmState

(

int32

trans_state

)

const

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

References KALDI_ASSERT, and TransitionModel::tuples_.

Referenced by TransitionModel::Check(), and kaldi::SplitToPhonesInternal().

                                                                        {
  KALDI_ASSERT(static_cast<size_t>(trans_state) <= tuples_.size());
  return tuples_[trans_state-1].hmm_state;
}

TransitionStateToPhone()

int32 TransitionStateToPhone

(

int32

trans_state

)

const

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

References KALDI_ASSERT, and TransitionModel::tuples_.

Referenced by TransitionModel::Check(), kaldi::GetPdfsForPhones(), kaldi::GetPhonesForPdfs(), main(), and kaldi::SplitToPhonesInternal().

                                                                     {
  KALDI_ASSERT(static_cast<size_t>(trans_state) <= tuples_.size());
  return tuples_[trans_state-1].phone;
}

TransitionStateToSelfLoopPdf()

int32 TransitionStateToSelfLoopPdf

(

int32

trans_state

)

const

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

References KALDI_ASSERT, and TransitionModel::tuples_.

Referenced by TransitionModel::Check(), kaldi::GetPdfsForPhones(), kaldi::GetPhonesForPdfs(), TransitionModel::MapUpdateShared(), and TransitionModel::MleUpdateShared().

                                                                           {
  KALDI_ASSERT(static_cast<size_t>(trans_state) <= tuples_.size());
  return tuples_[trans_state-1].self_loop_pdf;
}

TransitionStateToSelfLoopPdfClass()

int32 TransitionStateToSelfLoopPdfClass

(

int32

trans_state

)

const

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

References KALDI_ASSERT, TransitionModel::topo_, HmmTopology::TopologyForPhone(), and TransitionModel::tuples_.

Referenced by kaldi::ConvertAlignmentForPhone().

                             {
  KALDI_ASSERT(static_cast<size_t>(trans_state) <= tuples_.size());
  const Tuple &t = tuples_[trans_state-1];
  const HmmTopology::TopologyEntry &entry = topo_.TopologyForPhone(t.phone);
  KALDI_ASSERT(static_cast<size_t>(t.hmm_state) < entry.size());
  return entry[t.hmm_state].self_loop_pdf_class;
}

TupleToTransitionState()

int32 TupleToTransitionState	(	int32	phone,
		int32	hmm_state,
		int32	pdf,
		int32	self_loop_pdf
	)		const

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

References KALDI_ERR, and TransitionModel::tuples_.

Referenced by TransitionModel::Check(), kaldi::ConvertAlignmentForPhone(), kaldi::GenerateRandomAlignment(), kaldi::GetHmmAsFsa(), and kaldi::GetHmmAsFsaSimple().

                                                                                                                {
  Tuple tuple(phone, hmm_state, pdf, self_loop_pdf);
  // Note: if this ever gets too expensive, which is unlikely, we can refactor
  // this code to sort first on pdf, and then index on pdf, so those
  // that have the same pdf are in a contiguous range.
  std::vector<Tuple>::const_iterator iter =
      std::lower_bound(tuples_.begin(), tuples_.end(), tuple);
  if (iter == tuples_.end() || !(*iter == tuple)) {
    KALDI_ERR << "TransitionModel::TupleToTransitionState, tuple not found."
              << " (incompatible tree and model?)";
  }
  // tuples_ is indexed by transition_state-1, so add one.
  return static_cast<int32>((iter - tuples_.begin())) + 1;
}

Write()

void Write	(	std::ostream &	os,
		bool	binary
	)		const

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

References rnnlm::i, TransitionModel::IsHmm(), TransitionModel::log_probs_, TransitionModel::topo_, TransitionModel::tuples_, HmmTopology::Write(), kaldi::WriteBasicType(), and kaldi::WriteToken().

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

                                                             {
  bool is_hmm = IsHmm();
  WriteToken(os, binary, "<TransitionModel>");
  if (!binary) os << "\n";
  topo_.Write(os, binary);
  if (is_hmm)
    WriteToken(os, binary, "<Triples>");
  else
    WriteToken(os, binary, "<Tuples>");
  WriteBasicType(os, binary, static_cast<int32>(tuples_.size()));
  if (!binary) os << "\n";
  for (int32 i = 0; i < static_cast<int32> (tuples_.size()); i++) {
    WriteBasicType(os, binary, tuples_[i].phone);
    WriteBasicType(os, binary, tuples_[i].hmm_state);
    WriteBasicType(os, binary, tuples_[i].forward_pdf);
    if (!is_hmm)
      WriteBasicType(os, binary, tuples_[i].self_loop_pdf);
    if (!binary) os << "\n";
  }
  if (is_hmm)
    WriteToken(os, binary, "</Triples>");
  else
    WriteToken(os, binary, "</Tuples>");
  if (!binary) os << "\n";
  WriteToken(os, binary, "<LogProbs>");
  if (!binary) os << "\n";
  log_probs_.Write(os, binary);
  WriteToken(os, binary, "</LogProbs>");
  if (!binary) os << "\n";
  WriteToken(os, binary, "</TransitionModel>");
  if (!binary) os << "\n";
}

Member Data Documentation

id2pdf_id_

std::vector<int32> id2pdf_id_

private

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

Referenced by TransitionModel::ComputeDerived().

id2state_

std::vector<int32> id2state_

private

For each transition-id, the corresponding transition state (indexed by transition-id).

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

Referenced by TransitionModel::Compatible(), TransitionModel::ComputeDerived(), TransitionModel::InitializeProbs(), TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), TransitionModel::TransitionIdToHmmState(), TransitionModel::TransitionIdToPdfClass(), TransitionModel::TransitionIdToPhone(), TransitionModel::TransitionIdToTransitionIndex(), and TransitionModel::TransitionIdToTransitionState().

log_probs_

Vector<BaseFloat> log_probs_

private

For each transition-id, the corresponding log-prob. Indexed by transition-id.

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

Referenced by TransitionModel::Check(), TransitionModel::GetTransitionLogProb(), TransitionModel::GetTransitionLogProbIgnoringSelfLoops(), TransitionModel::GetTransitionProb(), TransitionModel::InitializeProbs(), TransitionModel::MapUpdate(), TransitionModel::MapUpdateShared(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), TransitionModel::Read(), and TransitionModel::Write().

non_self_loop_log_probs_

Vector<BaseFloat> non_self_loop_log_probs_

private

For each transition-state, the log of (1 - self-loop-prob).

Indexed by transition-state.

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

Referenced by TransitionModel::ComputeDerivedOfProbs(), and TransitionModel::GetNonSelfLoopLogProb().

num_pdfs_

int32 num_pdfs_

private

This is actually one plus the highest-numbered pdf we ever got back from the tree (but the tree numbers pdfs contiguously from zero so this is the number of pdfs).

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

Referenced by TransitionModel::Compatible(), and TransitionModel::ComputeDerived().

state2id_

std::vector<int32> state2id_

private

Gives the first transition_id of each transition-state; indexed by the transition-state.

Array indexed 1..num-transition-states+1 (the last one is needed so we can know the num-transitions of the last transition-state.

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

Referenced by TransitionModel::Compatible(), TransitionModel::ComputeDerived(), TransitionModel::InitializeProbs(), TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), TransitionModel::NumTransitionIndices(), TransitionModel::PairToTransitionId(), and TransitionModel::TransitionIdToTransitionIndex().

topo_

HmmTopology topo_

private

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

Referenced by TransitionModel::Compatible(), TransitionModel::ComputeDerived(), TransitionModel::ComputeTuplesIsHmm(), TransitionModel::ComputeTuplesNotHmm(), TransitionModel::InitializeProbs(), TransitionModel::IsFinal(), TransitionModel::IsHmm(), TransitionModel::IsSelfLoop(), TransitionModel::Print(), TransitionModel::Read(), TransitionModel::SelfLoopOf(), TransitionModel::TransitionIdToPdfClass(), TransitionModel::TransitionStateToForwardPdfClass(), TransitionModel::TransitionStateToSelfLoopPdfClass(), and TransitionModel::Write().

tuples_

std::vector<Tuple> tuples_

private

Tuples indexed by transition state minus one; the tuples are in sorted order which allows us to do the reverse mapping from tuple to transition state.

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

Referenced by TransitionModel::Compatible(), TransitionModel::ComputeDerived(), TransitionModel::ComputeTuples(), TransitionModel::ComputeTuplesIsHmm(), TransitionModel::ComputeTuplesNotHmm(), TransitionModel::InitializeProbs(), TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), TransitionModel::NumPhones(), TransitionModel::NumTransitionIndices(), TransitionModel::PairToTransitionId(), TransitionModel::Print(), TransitionModel::Read(), TransitionModel::SelfLoopOf(), TransitionModel::TransitionIdToHmmState(), TransitionModel::TransitionIdToPdfClass(), TransitionModel::TransitionIdToPhone(), TransitionModel::TransitionStateToForwardPdf(), TransitionModel::TransitionStateToForwardPdfClass(), TransitionModel::TransitionStateToHmmState(), TransitionModel::TransitionStateToPhone(), TransitionModel::TransitionStateToSelfLoopPdf(), TransitionModel::TransitionStateToSelfLoopPdfClass(), TransitionModel::TupleToTransitionState(), and TransitionModel::Write().

---

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

• hmm/transition-model.h
• hmm/transition-model.cc