LatticePhoneAligner::ComputationState Class Reference

Collaboration diagram for LatticePhoneAligner::ComputationState:

Public Member Functions
void	Advance (const CompactLatticeArc &arc, const PhoneAlignLatticeOptions &opts, LatticeWeight *weight)
	The state of the computation in which,. More...
bool	OutputPhoneArc (const TransitionModel &tmodel, const PhoneAlignLatticeOptions &opts, CompactLatticeArc *arc_out, bool *error)
	If it can output a whole phone, it will do so, will put it in arc_out, and return true; else it will return false. More...
bool	OutputWordArc (const TransitionModel &tmodel, const PhoneAlignLatticeOptions &opts, CompactLatticeArc *arc_out, bool *error)
	This will succeed (and output the arc) if we have >1 word in words_; the arc won't have any transition-ids on it. More...
bool	IsEmpty ()
LatticeWeight	FinalWeight ()
	FinalWeight() will return "weight" if both transition_ids and word_labels are empty, otherwise it will return Weight::Zero(). More...
void	OutputArcForce (const TransitionModel &tmodel, const PhoneAlignLatticeOptions &opts, CompactLatticeArc *arc_out, bool *error)
	This function may be called when you reach the end of the lattice and this structure hasn't voluntarily output words using "OutputArc". More...
size_t	Hash () const
bool	operator== (const ComputationState &other) const
	ComputationState ()
	ComputationState (const ComputationState &other)

Private Attributes
std::vector< int32 >	transition_ids_
std::vector< int32 >	word_labels_
LatticeWeight	weight_

Detailed Description

Definition at line 33 of file phone-align-lattice.cc.

Constructor & Destructor Documentation

ComputationState() [1/2]

ComputationState ( )

inline

Definition at line 116 of file phone-align-lattice.cc.

: weight_(LatticeWeight::One()) { } // initial state.

ComputationState() [2/2]

ComputationState ( const ComputationState &  other )

inline

Definition at line 117 of file phone-align-lattice.cc.

                                                   :
        transition_ids_(other.transition_ids_), word_labels_(other.word_labels_),
        weight_(other.weight_) { }

Member Function Documentation

Advance()

void Advance ( const CompactLatticeArc &  arc, const PhoneAlignLatticeOptions &  opts, LatticeWeight *  weight  )

inline

The state of the computation in which,.

along a single path in the lattice, we work out the phone boundaries and output phone-aligned arcs. [These may or may not have words on them; the word symbols are not aligned with anything. Advance the computation state by adding the symbols and weights from this arc. Gets rid of the weight and puts it in "weight" which will be put on the output arc; this keeps the state-space small.

Definition at line 42 of file phone-align-lattice.cc.

References LatticeWeightTpl< BaseFloat >::One(), LatticePhoneAligner::ComputationState::OutputPhoneArc(), LatticePhoneAligner::ComputationState::OutputWordArc(), PhoneAlignLatticeOptions::replace_output_symbols, fst::Times(), LatticePhoneAligner::ComputationState::transition_ids_, LatticePhoneAligner::ComputationState::weight_, and LatticePhoneAligner::ComputationState::word_labels_.

Referenced by LatticePhoneAligner::ProcessQueueElement().

                                        {
      const std::vector<int32> &string = arc.weight.String();
      transition_ids_.insert(transition_ids_.end(),
                             string.begin(), string.end());
      if (arc.ilabel != 0 && !opts.replace_output_symbols) // note: arc.ilabel==arc.olabel (acceptor)
        word_labels_.push_back(arc.ilabel);
      *weight = Times(weight_, arc.weight.Weight());
      weight_ = LatticeWeight::One();
    }

FinalWeight()

LatticeWeight FinalWeight ( )

inline

FinalWeight() will return "weight" if both transition_ids and word_labels are empty, otherwise it will return Weight::Zero().

Definition at line 80 of file phone-align-lattice.cc.

References LatticePhoneAligner::ComputationState::IsEmpty(), LatticePhoneAligner::ComputationState::OutputArcForce(), LatticePhoneAligner::ComputationState::weight_, and LatticeWeightTpl< BaseFloat >::Zero().

Referenced by LatticePhoneAligner::ProcessFinal().

{ return (IsEmpty() ? weight_ : LatticeWeight::Zero()); }

Hash()

size_t Hash ( ) const

inline

Definition at line 99 of file phone-align-lattice.cc.

References LatticePhoneAligner::ComputationState::transition_ids_, and LatticePhoneAligner::ComputationState::word_labels_.

Referenced by LatticePhoneAligner::TupleHash::operator()().

                        {
      VectorHasher<int32> vh;
      return vh(transition_ids_) + 90647 * vh(word_labels_);
      // 90647 is an arbitrary largish prime number.
      // We don't bother including the weight in the hash--
      // we don't really expect duplicates with the same vectors
      // but different weights, and anyway, this is only an
      // efficiency issue.
    }

IsEmpty()

bool IsEmpty ( )

inline

Definition at line 75 of file phone-align-lattice.cc.

References LatticePhoneAligner::ComputationState::transition_ids_, and LatticePhoneAligner::ComputationState::word_labels_.

Referenced by LatticePhoneAligner::ComputationState::FinalWeight(), LatticePhoneAligner::ComputationState::OutputArcForce(), and LatticePhoneAligner::ProcessFinal().

{ return (transition_ids_.empty() && word_labels_.empty()); }

operator==()

bool operator== ( const ComputationState &  other ) const

inline

Definition at line 110 of file phone-align-lattice.cc.

References LatticePhoneAligner::ComputationState::transition_ids_, LatticePhoneAligner::ComputationState::weight_, and LatticePhoneAligner::ComputationState::word_labels_.

                                                           {
      return (transition_ids_ == other.transition_ids_
              && word_labels_ == other.word_labels_
              && weight_ == other.weight_);
    }

OutputArcForce()

void OutputArcForce	(	const TransitionModel &	tmodel,
		const PhoneAlignLatticeOptions &	opts,
		CompactLatticeArc *	arc_out,
		bool *	error
	)

This function may be called when you reach the end of the lattice and this structure hasn't voluntarily output words using "OutputArc".

If IsEmpty() == false, then you can call this function and it will output an arc. The only non-error state in which this happens, is when a word (or silence) has ended, but we don't know that it's ended because we haven't seen the first transition-id from the next word. Otherwise (error state), the output will consist of partial words, and this will only happen for lattices that were somehow broken, i.e. had not reached the final state.

Definition at line 364 of file phone-align-lattice.cc.

References rnnlm::i, LatticePhoneAligner::ComputationState::IsEmpty(), TransitionModel::IsFinal(), KALDI_ASSERT, KALDI_WARN, LatticeWeightTpl< BaseFloat >::One(), PhoneAlignLatticeOptions::replace_output_symbols, LatticePhoneAligner::ComputationState::transition_ids_, TransitionModel::TransitionIdToPhone(), LatticePhoneAligner::ComputationState::weight_, and LatticePhoneAligner::ComputationState::word_labels_.

Referenced by LatticePhoneAligner::ComputationState::FinalWeight(), and LatticePhoneAligner::ProcessFinal().

                 {
  KALDI_ASSERT(!IsEmpty());

  int32 phone = -1; // This value -1 will never be used,
  // although it might not be obvious from superficially checking
  // the code.  IsEmpty() would be true if we had transition_ids_.empty()
  // and opts.replace_output_symbols, so we would already die by assertion;
  // in fact, this function would never be called.

  if (!transition_ids_.empty()) { // Do some checking here.
    int32 tid = transition_ids_[0];
    phone = tmodel.TransitionIdToPhone(tid);
    int32 num_final = 0;
    for (int32 i = 0; i < transition_ids_.size(); i++) { // A check.
      int32 this_tid = transition_ids_[i];
      int32 this_phone = tmodel.TransitionIdToPhone(this_tid);
      bool is_final = tmodel.IsFinal(this_tid); // should be exactly one.
      if (is_final) num_final++;
      if (this_phone != phone && ! *error) {
        KALDI_WARN << "Mismatch in phone: error in lattice or mismatched transition model?";
        *error = true;
      }
    }
    if (num_final != 1 && ! *error) {
      KALDI_WARN << "Problem phone-aligning lattice: saw " << num_final
                 << " final-states in last phone in lattice (forced out?) "
                 << "Producing partial lattice.";
      *error = true;
    }
  }

  Label output_label = 0;
  if (!word_labels_.empty()) {
    output_label = word_labels_[0];
    word_labels_.erase(word_labels_.begin(), word_labels_.begin()+1);
  }
  if (opts.replace_output_symbols)
    output_label = phone;
  *arc_out = CompactLatticeArc(output_label, output_label,
                               CompactLatticeWeight(weight_, transition_ids_),
                               fst::kNoStateId);
  transition_ids_.clear();
  weight_ = LatticeWeight::One(); // we just output the weight.
}

OutputPhoneArc()

bool OutputPhoneArc	(	const TransitionModel &	tmodel,
		const PhoneAlignLatticeOptions &	opts,
		CompactLatticeArc *	arc_out,
		bool *	error
	)

If it can output a whole phone, it will do so, will put it in arc_out, and return true; else it will return false.

If it detects an error condition and *error = false, it will set *error to true and print a warning. In this case it will still output phone arcs, they will just be inaccurate. Of course once *error is set, something has gone wrong so don't trust the output too fully. Note: the "next_state" of the arc will not be set, you have to do that yourself.

Definition at line 295 of file phone-align-lattice.cc.

References rnnlm::i, TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), KALDI_WARN, LatticeWeightTpl< BaseFloat >::One(), PhoneAlignLatticeOptions::reorder, PhoneAlignLatticeOptions::replace_output_symbols, LatticePhoneAligner::ComputationState::transition_ids_, TransitionModel::TransitionIdToPhone(), LatticePhoneAligner::ComputationState::weight_, and LatticePhoneAligner::ComputationState::word_labels_.

Referenced by LatticePhoneAligner::ComputationState::Advance().

                 {
  if (transition_ids_.empty()) return false;
  int32 phone = tmodel.TransitionIdToPhone(transition_ids_[0]);
  // we assume the start of transition_ids_ is the start of the phone;
  // this is a precondition.
  size_t len = transition_ids_.size(), i;
  // Keep going till we reach a "final" transition-id; note, if
  // reorder==true, we have to go a bit further after this.
  for (i = 0; i < len; i++) {
    int32 tid = transition_ids_[i];
    int32 this_phone = tmodel.TransitionIdToPhone(tid);
    if (this_phone != phone && ! *error) { // error condition: should have
                                           // reached final transition-id first.
      *error = true;
      KALDI_WARN << phone << " -> " << this_phone;
      KALDI_WARN << "Phone changed before final transition-id found "
          "[broken lattice or mismatched model or wrong --reorder option?]";
    }
    if (tmodel.IsFinal(tid))
      break;
  }
  if (i == len) return false; // fell off loop.
  i++; // go past the one for which IsFinal returned true.
  if (opts.reorder) // we have to consume the following self-loop transition-ids.
    while (i < len && tmodel.IsSelfLoop(transition_ids_[i])) i++;
  if (i == len) return false; // we don't know if it ends here... so can't output arc.

  // interpret i as the number of transition-ids to consume.
  std::vector<int32> tids_out(transition_ids_.begin(),
                              transition_ids_.begin()+i);

  Label output_label = 0;
  if (!word_labels_.empty()) {
    output_label = word_labels_[0];
    word_labels_.erase(word_labels_.begin(), word_labels_.begin()+1);
  }
  if (opts.replace_output_symbols)
    output_label = phone;
  *arc_out = CompactLatticeArc(output_label, output_label,
                               CompactLatticeWeight(weight_, tids_out),
                               fst::kNoStateId);
  transition_ids_.erase(transition_ids_.begin(), transition_ids_.begin()+i);
  weight_ = LatticeWeight::One(); // we just output the weight.
  return true;
}

OutputWordArc()

bool OutputWordArc	(	const TransitionModel &	tmodel,
		const PhoneAlignLatticeOptions &	opts,
		CompactLatticeArc *	arc_out,
		bool *	error
	)

This will succeed (and output the arc) if we have >1 word in words_; the arc won't have any transition-ids on it.

This is intended to fix a particular pathology where too many words were pending and we had blowup.

Definition at line 345 of file phone-align-lattice.cc.

References LatticeWeightTpl< BaseFloat >::One(), LatticePhoneAligner::ComputationState::weight_, and LatticePhoneAligner::ComputationState::word_labels_.

Referenced by LatticePhoneAligner::ComputationState::Advance().

                 {
  // output a word but no phones.
  if (word_labels_.size() < 2) return false;

  int32 output_label = word_labels_[0];
  word_labels_.erase(word_labels_.begin(), word_labels_.begin()+1);

  *arc_out = CompactLatticeArc(output_label, output_label,
                               CompactLatticeWeight(weight_, std::vector<int32>()),
                               fst::kNoStateId);
  weight_ = LatticeWeight::One(); // we just output the weight, so set it to one.
  return true;
}

Member Data Documentation

transition_ids_

std::vector<int32> transition_ids_

private

Definition at line 121 of file phone-align-lattice.cc.

Referenced by LatticePhoneAligner::ComputationState::Advance(), LatticePhoneAligner::ComputationState::Hash(), LatticePhoneAligner::ComputationState::IsEmpty(), LatticePhoneAligner::ComputationState::operator==(), LatticePhoneAligner::ComputationState::OutputArcForce(), and LatticePhoneAligner::ComputationState::OutputPhoneArc().

weight_

LatticeWeight weight_

private

Definition at line 123 of file phone-align-lattice.cc.

Referenced by LatticePhoneAligner::ComputationState::Advance(), LatticePhoneAligner::ComputationState::FinalWeight(), LatticePhoneAligner::ComputationState::operator==(), LatticePhoneAligner::ComputationState::OutputArcForce(), LatticePhoneAligner::ComputationState::OutputPhoneArc(), and LatticePhoneAligner::ComputationState::OutputWordArc().

word_labels_

std::vector<int32> word_labels_

private

Definition at line 122 of file phone-align-lattice.cc.

Referenced by LatticePhoneAligner::ComputationState::Advance(), LatticePhoneAligner::ComputationState::Hash(), LatticePhoneAligner::ComputationState::IsEmpty(), LatticePhoneAligner::ComputationState::operator==(), LatticePhoneAligner::ComputationState::OutputArcForce(), LatticePhoneAligner::ComputationState::OutputPhoneArc(), and LatticePhoneAligner::ComputationState::OutputWordArc().

---

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

• lat/phone-align-lattice.cc