LatticeWordAligner::ComputationState Class Reference

Collaboration diagram for LatticeWordAligner::ComputationState:

Public Member Functions
void	Advance (const CompactLatticeArc &arc, LatticeWeight *weight)
	The state of the computation in which,. More...
bool	OutputArc (const WordBoundaryInfo &info, const TransitionModel &tmodel, CompactLatticeArc *arc_out, bool *error)
	If it can output a whole word, it will do so, will put it in arc_out, and return true; else it will return false. More...
bool	OutputSilenceArc (const WordBoundaryInfo &info, const TransitionModel &tmodel, CompactLatticeArc *arc_out, bool *error)
bool	OutputOnePhoneWordArc (const WordBoundaryInfo &info, const TransitionModel &tmodel, CompactLatticeArc *arc_out, bool *error)
bool	OutputNormalWordArc (const WordBoundaryInfo &info, const TransitionModel &tmodel, CompactLatticeArc *arc_out, bool *error)
	This function tries to see if it can output a normal word arc– one with at least two phones in 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 WordBoundaryInfo &info, const TransitionModel &tmodel, 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 32 of file word-align-lattice.cc.

Constructor & Destructor Documentation

ComputationState() [1/2]

ComputationState ( )

inline

Definition at line 125 of file word-align-lattice.cc.

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

ComputationState() [2/2]

ComputationState ( const ComputationState &  other )

inline

Definition at line 126 of file word-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, LatticeWeight *  weight  )

inline

The state of the computation in which,.

along a single path in the lattice, we work out the word boundaries and output aligned arcs. Advance the computation state by adding the symbols and weights from this arc. We'll put the weight on the output arc; this helps keep the state-space smaller.

Definition at line 40 of file word-align-lattice.cc.

References LatticeWeightTpl< BaseFloat >::One(), fst::Times(), LatticeWordAligner::ComputationState::transition_ids_, LatticeWordAligner::ComputationState::weight_, and LatticeWordAligner::ComputationState::word_labels_.

Referenced by LatticeWordAligner::ProcessQueueElement().

                                                                      {
      const std::vector<int32> &string = arc.weight.String();
      transition_ids_.insert(transition_ids_.end(),
                             string.begin(), string.end());
      if (arc.ilabel != 0) // 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 89 of file word-align-lattice.cc.

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

Referenced by LatticeWordAligner::ProcessFinal().

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

Hash()

size_t Hash ( ) const

inline

Definition at line 108 of file word-align-lattice.cc.

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

Referenced by LatticeWordAligner::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 84 of file word-align-lattice.cc.

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

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

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

operator==()

bool operator== ( const ComputationState &  other ) const

inline

Definition at line 119 of file word-align-lattice.cc.

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

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

OutputArc()

bool OutputArc ( const WordBoundaryInfo &  info, const TransitionModel &  tmodel, CompactLatticeArc *  arc_out, bool *  error  )

inline

If it can output a whole word, 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 may or may not [output an arc and return true], depending on what we think is most likely the right thing to do. 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 59 of file word-align-lattice.cc.

References LatticeWordAligner::ComputationState::OutputNormalWordArc(), LatticeWordAligner::ComputationState::OutputOnePhoneWordArc(), and LatticeWordAligner::ComputationState::OutputSilenceArc().

                                {
      // order of this ||-expression doesn't matter for
      // function behavior, only for efficiency, since the
      // cases are disjoint.
      return OutputNormalWordArc(info, tmodel, arc_out, error) ||
          OutputSilenceArc(info, tmodel, arc_out, error) ||
          OutputOnePhoneWordArc(info, tmodel, arc_out, error);
    }

OutputArcForce()

void OutputArcForce	(	const WordBoundaryInfo &	info,
		const TransitionModel &	tmodel,
		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 565 of file word-align-lattice.cc.

References rnnlm::i, LatticeWordAligner::ComputationState::IsEmpty(), TransitionModel::IsFinal(), kaldi::IsPlausibleWord(), TransitionModel::IsSelfLoop(), KALDI_ASSERT, KALDI_ERR, KALDI_WARN, WordBoundaryInfo::kNonWordPhone, LatticeWeightTpl< BaseFloat >::One(), WordBoundaryInfo::partial_word_label, WordBoundaryInfo::reorder, WordBoundaryInfo::silence_label, LatticeWordAligner::ComputationState::transition_ids_, TransitionModel::TransitionIdToPhone(), WordBoundaryInfo::TypeOfPhone(), LatticeWordAligner::ComputationState::weight_, and LatticeWordAligner::ComputationState::word_labels_.

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

                                              {

  KALDI_ASSERT(!IsEmpty());
  if (!word_labels_.empty()
      && !transition_ids_.empty()) { // We have at least one word to
    // output, and some transition-ids.  We assume that the normal OutputArc was called
    // and failed, so this means we didn't see the end of that
    // word.
    int32 word = word_labels_[0];
    if (! *error && !IsPlausibleWord(info, tmodel, transition_ids_)) {
      *error = true;
      KALDI_WARN << "Invalid word at end of lattice [partial lattice, forced out?]";
    }
    CompactLatticeWeight cw(weight_, transition_ids_);
    *arc_out = CompactLatticeArc(word, word, cw, fst::kNoStateId);
    weight_ = LatticeWeight::One();
    transition_ids_.clear();
    word_labels_.erase(word_labels_.begin(), word_labels_.begin()+1);
  } else if (!word_labels_.empty() && transition_ids_.empty()) {
    // We won't create arcs with these word labels on, as most likely
    // this will cause errors down the road.  This is an error
    // condition anyway, in some sense.
    if (! *error) {
      *error = true;
      KALDI_WARN << "Discarding word-ids at the end of a sentence, "
          "that don't have alignments.";
    }
    CompactLatticeWeight cw(weight_, transition_ids_);
    // This creates an epsilon arc with a weight on it, but
    // no transition-ids since the vector is empty.
    // The word labels are discarded.
    *arc_out = CompactLatticeArc(0, 0, cw, fst::kNoStateId);
    weight_ = LatticeWeight::One();
    word_labels_.clear();
  } else if (!transition_ids_.empty() && word_labels_.empty()) {
    // Transition-ids but no word label-- either silence or partial word.
    int32 first_phone = tmodel.TransitionIdToPhone(transition_ids_[0]);
    if (info.TypeOfPhone(first_phone) == WordBoundaryInfo::kNonWordPhone) {
      // first phone is silence...
      if (first_phone != tmodel.TransitionIdToPhone(transition_ids_.back())
          && ! *error) {
        *error = true;
        // Phone changed-- this is a code error, because the regular OutputArc
        // should have output an arc (a silence arc) if that phone finished.
        // So we make it fatal.
        KALDI_ERR << "Broken silence arc at end of utterance (the phone "
            "changed); code error";
      }
      if (!*error) { // Check that it ends at the end state of silence; error otherwise.
        int32 i = transition_ids_.size() - 1;
        if (info.reorder)
          while (tmodel.IsSelfLoop(transition_ids_[i]) && i > 0)
            i--;
        if (!tmodel.IsFinal(transition_ids_[i])) {
          *error = true;
          KALDI_WARN << "Broken silence arc at end of utterance (does not "
              "reach end of silence)";
        }
      }
      CompactLatticeWeight cw(weight_, transition_ids_);
      *arc_out = CompactLatticeArc(info.silence_label, info.silence_label,
                                   cw, fst::kNoStateId);
    } else {
      // Not silence phone -- treat as partial word (with no word label).
      // This is in itself an error condition, i.e. the lattice was maybe
      // forced out.
      if (! *error) {
        *error = true;
        KALDI_WARN << "Partial word detected at end of utterance";
      }
      CompactLatticeWeight cw(weight_, transition_ids_);
      *arc_out = CompactLatticeArc(info.partial_word_label, info.partial_word_label,
                                   cw, fst::kNoStateId);
    }
    transition_ids_.clear();
    weight_ = LatticeWeight::One();
  } else {
    KALDI_ERR << "Code error, word-aligning lattice"; // this shouldn't
    // be able to happen; we don't call this function of they're both empty.
  }
}

OutputNormalWordArc()

bool OutputNormalWordArc	(	const WordBoundaryInfo &	info,
		const TransitionModel &	tmodel,
		CompactLatticeArc *	arc_out,
		bool *	error
	)

This function tries to see if it can output a normal word arc– one with at least two phones in it.

Definition at line 450 of file word-align-lattice.cc.

References rnnlm::i, TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), KALDI_WARN, WordBoundaryInfo::kWordBeginPhone, WordBoundaryInfo::kWordEndPhone, WordBoundaryInfo::kWordInternalPhone, LatticeWeightTpl< BaseFloat >::One(), WordBoundaryInfo::reorder, LatticeWordAligner::ComputationState::transition_ids_, TransitionModel::TransitionIdToPhone(), WordBoundaryInfo::TypeOfPhone(), LatticeWordAligner::ComputationState::weight_, and LatticeWordAligner::ComputationState::word_labels_.

Referenced by LatticeWordAligner::ComputationState::OutputArc().

                                              {
  if (transition_ids_.empty()) return false;
  if (word_labels_.empty()) return false;
  int32 begin_phone = tmodel.TransitionIdToPhone(transition_ids_[0]);
  if (info.TypeOfPhone(begin_phone) != WordBoundaryInfo::kWordBeginPhone)
    return false;
  // we assume the start of transition_ids_ is the start of the phone.
  // this is a precondition.
  size_t len = transition_ids_.size(), i;

  // Eat up the transition-ids of this word-begin phone until we get to the
  // "final" transition-id.  [there may be self-loops following this though,
  // if reorder==true]
  for (i = 0; i < len && !tmodel.IsFinal(transition_ids_[i]); i++);
  if (i == len) return false;
  i++; // Skip over this final-transition.
  if (info.reorder) // Skip over any reordered self-loops for this final-transition
    for (; i < len && tmodel.IsSelfLoop(transition_ids_[i]); i++);
  if (i == len) return false;
  if (tmodel.TransitionIdToPhone(transition_ids_[i-1]) != begin_phone
      && ! *error) { // another check.
    KALDI_WARN << "Phone changed unexpectedly in lattice "
        "[broken lattice or mismatched model?]";
    *error = true;
  }
  // Now keep going till we hit a word-ending phone.
  // Note: we don't expect anything except word-internal phones
  // here, but we'll just print a warning if we get something
  // else.
  for (; i < len; i++) {
    int32 this_phone = tmodel.TransitionIdToPhone(transition_ids_[i]);
    if (info.TypeOfPhone(this_phone) == WordBoundaryInfo::kWordEndPhone)
      break;
    if (info.TypeOfPhone(this_phone) != WordBoundaryInfo::kWordInternalPhone
        && !*error) {
      KALDI_WARN << "Unexpected phone " << this_phone
                 << " found inside a word.";
      *error = true;
    }
  }
  if (i == len) return false;

  // OK, we hit a word-ending phone.  Continue till we get to
  // a "final-transition".

  // this variable just used for checks.
  int32 final_phone = tmodel.TransitionIdToPhone(transition_ids_[i]);
  for (; i < len; i++) {
    int32 this_phone = tmodel.TransitionIdToPhone(transition_ids_[i]);
    if (this_phone != final_phone && ! *error) {
      *error = true;
      KALDI_WARN << "Phone changed before final transition-id found "
          "[broken lattice or mismatched model or wrong --reorder option?]";
    }
    if (tmodel.IsFinal(transition_ids_[i])) break;
  }
  if (i == len) return false;
  i++;
  // We got to the final-transition of the final phone;
  // if reorder==true, continue eating up the self-loop.
  if (info.reorder == true)
    while (i < len && tmodel.IsSelfLoop(transition_ids_[i])) i++;
  if (i == len) return false;
  if (tmodel.TransitionIdToPhone(transition_ids_[i-1]) != final_phone
      && ! *error) {
    *error = true;
    KALDI_WARN << "Phone changed while following final self-loop "
        "[broken lattice or mismatched model or wrong --reorder option?]";
  }

  // OK, we're ready to output the word.
  // Interpret i as the number of transition-ids to consume.
  std::vector<int32> tids_out(transition_ids_.begin(),
                              transition_ids_.begin() + i);

  // consumed transition ids from our internal state.
  int32 word = word_labels_[0];
  *arc_out = CompactLatticeArc(word, word,
                               CompactLatticeWeight(weight_, tids_out),
                               fst::kNoStateId);
  transition_ids_.erase(transition_ids_.begin(),
                        transition_ids_.begin() + i); // delete these
  // Remove the word that we just output.
  word_labels_.erase(word_labels_.begin(),
                     word_labels_.begin() + 1);
  weight_ = LatticeWeight::One(); // we just output the weight.
  return true;
}

OutputOnePhoneWordArc()

bool OutputOnePhoneWordArc	(	const WordBoundaryInfo &	info,
		const TransitionModel &	tmodel,
		CompactLatticeArc *	arc_out,
		bool *	error
	)

Definition at line 396 of file word-align-lattice.cc.

References rnnlm::i, TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), KALDI_WARN, WordBoundaryInfo::kWordBeginAndEndPhone, LatticeWeightTpl< BaseFloat >::One(), WordBoundaryInfo::reorder, LatticeWordAligner::ComputationState::transition_ids_, TransitionModel::TransitionIdToPhone(), WordBoundaryInfo::TypeOfPhone(), LatticeWordAligner::ComputationState::weight_, and LatticeWordAligner::ComputationState::word_labels_.

Referenced by LatticeWordAligner::ComputationState::OutputArc().

                                              {
  if (transition_ids_.empty()) return false;
  if (word_labels_.empty()) return false;
  int32 phone = tmodel.TransitionIdToPhone(transition_ids_[0]);
  if (info.TypeOfPhone(phone) != WordBoundaryInfo::kWordBeginAndEndPhone)
    return false;
  // we assume the start of transition_ids_ is the start of the phone.
  // this is a precondition.
  size_t len = transition_ids_.size(), i;
  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.
      KALDI_WARN << "Phone changed before final transition-id found "
          "[broken lattice or mismatched model or wrong --reorder option?]";
      // just continue, ignoring this-- we'll probably output something...
    }
    if (tmodel.IsFinal(tid))
      break;
  }
  if (i == len) return false; // fell off loop.
  i++; // go past the one for which IsFinal returned true.
  if (info.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.

  if (tmodel.TransitionIdToPhone(transition_ids_[i-1]) != phone
      && ! *error) { // another check.
    KALDI_WARN << "Phone changed unexpectedly in lattice "
        "[broken lattice or mismatched model?]";
    *error = true;
  }

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

  // consumed transition ids from our internal state.
  int32 word = word_labels_[0];
  *arc_out = CompactLatticeArc(word, word,
                               CompactLatticeWeight(weight_, tids_out), fst::kNoStateId);
  transition_ids_.erase(transition_ids_.begin(),
                        transition_ids_.begin() + i); // delete these
  // Remove the word that we just output.
  word_labels_.erase(word_labels_.begin(), word_labels_.begin() + 1);
  weight_ = LatticeWeight::One(); // we just output the weight.
  return true;
}

OutputSilenceArc()

bool OutputSilenceArc	(	const WordBoundaryInfo &	info,
		const TransitionModel &	tmodel,
		CompactLatticeArc *	arc_out,
		bool *	error
	)

Definition at line 350 of file word-align-lattice.cc.

References rnnlm::i, TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), KALDI_WARN, WordBoundaryInfo::kNonWordPhone, LatticeWeightTpl< BaseFloat >::One(), WordBoundaryInfo::reorder, WordBoundaryInfo::silence_label, LatticeWordAligner::ComputationState::transition_ids_, TransitionModel::TransitionIdToPhone(), WordBoundaryInfo::TypeOfPhone(), and LatticeWordAligner::ComputationState::weight_.

Referenced by LatticeWordAligner::ComputationState::OutputArc().

                                              {
  if (transition_ids_.empty()) return false;
  int32 phone = tmodel.TransitionIdToPhone(transition_ids_[0]);
  if (info.TypeOfPhone(phone) != WordBoundaryInfo::kNonWordPhone) return false;

  // we assume the start of transition_ids_ is the start of the phone [silence];
  // 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 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 (info.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.

  if (tmodel.TransitionIdToPhone(transition_ids_[i-1]) != phone
      && ! *error) { // another check.
    KALDI_WARN << "Phone changed unexpectedly in lattice "
        "[broken lattice or mismatched model?]";
  }
  // interpret i as the number of transition-ids to consume.
  std::vector<int32> tids_out(transition_ids_.begin(), transition_ids_.begin()+i);

  // consumed transition ids from our internal state.
  *arc_out = CompactLatticeArc(info.silence_label, info.silence_label,
                               CompactLatticeWeight(weight_, tids_out), fst::kNoStateId);
  transition_ids_.erase(transition_ids_.begin(), transition_ids_.begin()+i); // delete these
  weight_ = LatticeWeight::One(); // we just output the weight.
  return true;
}

Member Data Documentation

transition_ids_

std::vector<int32> transition_ids_

private

Definition at line 130 of file word-align-lattice.cc.

Referenced by LatticeWordAligner::ComputationState::Advance(), LatticeWordAligner::ComputationState::Hash(), LatticeWordAligner::ComputationState::IsEmpty(), LatticeWordAligner::ComputationState::operator==(), LatticeWordAligner::ComputationState::OutputArcForce(), LatticeWordAligner::ComputationState::OutputNormalWordArc(), LatticeWordAligner::ComputationState::OutputOnePhoneWordArc(), and LatticeWordAligner::ComputationState::OutputSilenceArc().

weight_

LatticeWeight weight_

private

Definition at line 132 of file word-align-lattice.cc.

Referenced by LatticeWordAligner::ComputationState::Advance(), LatticeWordAligner::ComputationState::FinalWeight(), LatticeWordAligner::ComputationState::operator==(), LatticeWordAligner::ComputationState::OutputArcForce(), LatticeWordAligner::ComputationState::OutputNormalWordArc(), LatticeWordAligner::ComputationState::OutputOnePhoneWordArc(), and LatticeWordAligner::ComputationState::OutputSilenceArc().

word_labels_

std::vector<int32> word_labels_

private

Definition at line 131 of file word-align-lattice.cc.

Referenced by LatticeWordAligner::ComputationState::Advance(), LatticeWordAligner::ComputationState::Hash(), LatticeWordAligner::ComputationState::IsEmpty(), LatticeWordAligner::ComputationState::operator==(), LatticeWordAligner::ComputationState::OutputArcForce(), LatticeWordAligner::ComputationState::OutputNormalWordArc(), and LatticeWordAligner::ComputationState::OutputOnePhoneWordArc().

---

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

• lat/word-align-lattice.cc