Collaboration diagram for LatticeWordAligner:

[legend]

Classes
class	ComputationState

struct	Tuple

struct	TupleEqual

struct	TupleHash

Public Types
typedef CompactLatticeArc::StateId	StateId

typedef CompactLatticeArc::Label	Label

typedef unordered_map< Tuple, StateId, TupleHash, TupleEqual >	MapType

Public Member Functions
StateId	GetStateForTuple (const Tuple &tuple, bool add_to_queue)

void	ProcessFinal (Tuple tuple, StateId output_state)

void	ProcessQueueElement ()

	LatticeWordAligner (const CompactLattice &lat, const TransitionModel &tmodel, const WordBoundaryInfo &info, int32 max_states, CompactLattice *lat_out)

void	RemoveEpsilonsFromLattice ()

bool	AlignLattice ()

Public Attributes
CompactLattice	lat_

const TransitionModel &	tmodel_

const WordBoundaryInfo &	info_in_

WordBoundaryInfo	info_

int32	max_states_

CompactLattice *	lat_out_

std::vector< std::pair< Tuple, StateId > >	queue_

MapType	map_

bool	error_

Detailed Description

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

Member Typedef Documentation

◆ Label

typedef CompactLatticeArc::Label Label

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

◆ MapType

typedef unordered_map<Tuple, StateId, TupleHash, TupleEqual> MapType

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

◆ StateId

typedef CompactLatticeArc::StateId StateId

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

Constructor & Destructor Documentation

◆ LatticeWordAligner()

LatticeWordAligner	(	const CompactLattice &	lat,
		const TransitionModel &	tmodel,
		const WordBoundaryInfo &	info,
		int32	max_states,
		CompactLattice *	lat_out
	)

inline

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

References fst::CreateSuperFinal(), fst::HighestNumberedOutputSymbol(), LatticeWordAligner::info_, KALDI_ASSERT, KALDI_WARN, LatticeWordAligner::lat_, WordBoundaryInfo::partial_word_label, and WordBoundaryInfo::silence_label.

                                              :
       lat_(lat), tmodel_(tmodel), info_in_(info), info_(info),
       max_states_(max_states), lat_out_(lat_out),
       error_(false) {
     bool test = true;
     uint64 props = lat_.Properties(fst::kIDeterministic|fst::kIEpsilons, test);
     if (props != fst::kIDeterministic) {
       KALDI_WARN << "[Lattice has input epsilons and/or is not input-deterministic "
                  << "(in Mohri sense)]-- i.e. lattice is not deterministic.  "
                  << "Word-alignment may be slow and-or blow up in memory.";
     }
     fst::CreateSuperFinal(&lat_); // Creates a super-final state, so the
     // only final-probs are One().
 
     // Inside this class, we don't want to use zero for the silence
     // or partial-word labels, as this will interfere with the RmEpsilon
     // stage, where we don't want the arcs corresponding to silence or
     // partial words to be removed-- only the arcs with nothing at all
     // on them.
     if (info_.partial_word_label == 0 || info_.silence_label == 0) {
       int32 unused_label = 1 + HighestNumberedOutputSymbol(lat);
       if (info_.partial_word_label >= unused_label)
         unused_label = info_.partial_word_label + 1;
       if (info_.silence_label >= unused_label)
         unused_label = info_.silence_label + 1;
       KALDI_ASSERT(unused_label > 0);
       if (info_.partial_word_label == 0)
         info_.partial_word_label = unused_label++;
       if (info_.silence_label == 0)
         info_.silence_label = unused_label;
     }
   }

Member Function Documentation

◆ AlignLattice()

bool AlignLattice ( )

inline

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

References LatticeWordAligner::error_, LatticeWordAligner::GetStateForTuple(), KALDI_WARN, LatticeWordAligner::lat_, LatticeWordAligner::lat_out_, LatticeWordAligner::max_states_, LatticeWordAligner::ProcessQueueElement(), LatticeWordAligner::queue_, and LatticeWordAligner::RemoveEpsilonsFromLattice().

Referenced by kaldi::WordAlignLattice().

                       {
     lat_out_->DeleteStates();
     if (lat_.Start() == fst::kNoStateId) {
       KALDI_WARN << "Trying to word-align empty lattice.";
       return false;
     }
     ComputationState initial_comp_state;
     Tuple initial_tuple(lat_.Start(), initial_comp_state);
     StateId start_state = GetStateForTuple(initial_tuple, true); // True = add this to queue.
     lat_out_->SetStart(start_state);
 
     while (!queue_.empty()) {
       if (max_states_ > 0 && lat_out_->NumStates() > max_states_) {
         KALDI_WARN << "Number of states in lattice exceeded max-states of "
                    << max_states_ << ", original lattice had "
                    << lat_.NumStates() << " states.  Returning what we have.";
         RemoveEpsilonsFromLattice();
         return false;
       }
       ProcessQueueElement();
     }
 
     RemoveEpsilonsFromLattice();
 
     return !error_;
   }

◆ GetStateForTuple()

StateId GetStateForTuple	(	const Tuple &	tuple,
		bool	add_to_queue
	)

inline

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

References LatticeWordAligner::lat_out_, LatticeWordAligner::map_, and LatticeWordAligner::queue_.

Referenced by LatticeWordAligner::AlignLattice(), LatticeWordAligner::ProcessFinal(), and LatticeWordAligner::ProcessQueueElement().

                                                                   {
     MapType::iterator iter = map_.find(tuple);
     if (iter == map_.end()) { // not in map.
       StateId output_state = lat_out_->AddState();
       map_[tuple] = output_state;
       if (add_to_queue)
         queue_.push_back(std::make_pair(tuple, output_state));
       return output_state;
     } else {
       return iter->second;
     }
   }

◆ ProcessFinal()

void ProcessFinal	(	Tuple	tuple,
		StateId	output_state
	)

inline

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

References LatticeWordAligner::Tuple::comp_state, LatticeWordAligner::error_, LatticeWordAligner::ComputationState::FinalWeight(), LatticeWordAligner::GetStateForTuple(), LatticeWordAligner::info_, LatticeWordAligner::ComputationState::IsEmpty(), KALDI_ASSERT, LatticeWordAligner::lat_out_, LatticeWordAligner::ComputationState::OutputArcForce(), fst::Plus(), and LatticeWordAligner::tmodel_.

Referenced by LatticeWordAligner::ProcessQueueElement().

                                                        {
     // ProcessFinal is only called if the input_state has
     // final-prob of One().  [else it should be zero.  This
     // is because we called CreateSuperFinal().]
 
     if (tuple.comp_state.IsEmpty()) { // computation state doesn't have
       // anything pending.
       std::vector<int32> empty_vec;
       CompactLatticeWeight cw(tuple.comp_state.FinalWeight(), empty_vec);
       lat_out_->SetFinal(output_state, Plus(lat_out_->Final(output_state), cw));
     } else {
       // computation state has something pending, i.e. input or
       // output symbols that need to be flushed out.  Note: OutputArc() would
       // have returned false or we wouldn't have been called, so we have to
       // force it out.
       CompactLatticeArc lat_arc;
       tuple.comp_state.OutputArcForce(info_, tmodel_, &lat_arc, &error_);
       // True in the next line means add it to the queue.
       lat_arc.nextstate = GetStateForTuple(tuple, true);
       // The final-prob stuff will get called again from ProcessQueueElement().
       // Note: because we did CreateSuperFinal(), this final-state on the input
       // lattice will have no output arcs (and unit final-prob), so there will be
       // no complications with processing the arcs from this state (there won't
       // be any).
       KALDI_ASSERT(output_state != lat_arc.nextstate);
       lat_out_->AddArc(output_state, lat_arc);
     }
   }

◆ ProcessQueueElement()

void ProcessQueueElement ( )

inline

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

Referenced by LatticeWordAligner::AlignLattice().

                              {
     KALDI_ASSERT(!queue_.empty());
     Tuple tuple = queue_.back().first;
     StateId output_state = queue_.back().second;
     queue_.pop_back();
 
     // First thing is-- we see whether the computation-state has something
     // pending that it wants to output.  In this case we don't do
     // anything further.  This is a chosen behavior similar to the
     // epsilon-sequencing rules encoded by the filters in
     // composition.
     CompactLatticeArc lat_arc;
     if (tuple.comp_state.OutputArc(info_, tmodel_, &lat_arc, &error_)) {
       // note: this function changes the tuple (when it returns true).
       lat_arc.nextstate = GetStateForTuple(tuple, true); // true == add to queue,
       // if not already present.
       KALDI_ASSERT(output_state != lat_arc.nextstate);
       lat_out_->AddArc(output_state, lat_arc);
     } else {
       // when there's nothing to output, we'll process arcs from the input-state.
       // note: it would in a sense be valid to do both (i.e. process the stuff
       // above, and also these), but this is a bit like the epsilon-sequencing
       // stuff in composition: we avoid duplicate arcs by doing it this way.
 
       if (lat_.Final(tuple.input_state) != CompactLatticeWeight::Zero()) {
         KALDI_ASSERT(lat_.Final(tuple.input_state) == CompactLatticeWeight::One());
         // ... since we did CreateSuperFinal.
         ProcessFinal(tuple, output_state);
       }
       // Now process the arcs.  Note: final-state shouldn't have any arcs.
       for (fst::ArcIterator<CompactLattice> aiter(lat_, tuple.input_state);
           !aiter.Done(); aiter.Next()) {
         const CompactLatticeArc &arc = aiter.Value();
         Tuple next_tuple(tuple);
         LatticeWeight weight;
         next_tuple.comp_state.Advance(arc, &weight);
         next_tuple.input_state = arc.nextstate;
         StateId next_output_state = GetStateForTuple(next_tuple, true); // true == add to queue,
         // if not already present.
         // We add an epsilon arc here (as the input and output happens
         // separately)... the epsilons will get removed later.
         KALDI_ASSERT(next_output_state != output_state);
         lat_out_->AddArc(output_state,
                          CompactLatticeArc(0, 0,
                              CompactLatticeWeight(weight, std::vector<int32>()),
                              next_output_state));
       }
     }
   }

◆ RemoveEpsilonsFromLattice()

void RemoveEpsilonsFromLattice ( )

inline

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

References LatticeWordAligner::info_, LatticeWordAligner::info_in_, LatticeWordAligner::lat_out_, WordBoundaryInfo::partial_word_label, fst::RemoveSomeInputSymbols(), and WordBoundaryInfo::silence_label.

Referenced by LatticeWordAligner::AlignLattice().

                                    {
     // Remove epsilon arcs from output lattice.
     RmEpsilon(lat_out_, true); // true = connect.
     std::vector<int32> syms_to_remove;
     if (info_in_.partial_word_label == 0)
       syms_to_remove.push_back(info_.partial_word_label);
     if (info_in_.silence_label == 0)
       syms_to_remove.push_back(info_.silence_label);
     if (!syms_to_remove.empty()) {
       RemoveSomeInputSymbols(syms_to_remove, lat_out_);
       Project(lat_out_, fst::PROJECT_INPUT);
     }
   }