LatticePhoneAligner Class Reference

Collaboration diagram for LatticePhoneAligner:

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 ()
	LatticePhoneAligner (const CompactLattice &lat, const TransitionModel &tmodel, const PhoneAlignLatticeOptions &opts, CompactLattice *lat_out)
void	RemoveEpsilonsFromLattice ()
bool	AlignLattice ()

Public Attributes
CompactLattice	lat_
const TransitionModel &	tmodel_
const PhoneAlignLatticeOptions &	opts_
CompactLattice *	lat_out_
std::vector< std::pair< Tuple, StateId > >	queue_
MapType	map_
bool	error_

Detailed Description

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

Member Typedef Documentation

Label

typedef CompactLatticeArc::Label Label

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

MapType

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

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

StateId

typedef CompactLatticeArc::StateId StateId

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

Constructor & Destructor Documentation

LatticePhoneAligner()

LatticePhoneAligner ( const CompactLattice &  lat, const TransitionModel &  tmodel, const PhoneAlignLatticeOptions &  opts, CompactLattice *  lat_out  )

inline

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

References fst::CreateSuperFinal(), and LatticePhoneAligner::lat_.

                                             :
      lat_(lat), tmodel_(tmodel), opts_(opts), lat_out_(lat_out),
      error_(false) {
    fst::CreateSuperFinal(&lat_); // Creates a super-final state, so the
    // only final-probs are One().
  }

Member Function Documentation

AlignLattice()

bool AlignLattice ( )

inline

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

References LatticePhoneAligner::error_, LatticePhoneAligner::GetStateForTuple(), KALDI_WARN, LatticePhoneAligner::lat_, LatticePhoneAligner::lat_out_, LatticePhoneAligner::opts_, LatticePhoneAligner::ProcessQueueElement(), LatticePhoneAligner::queue_, PhoneAlignLatticeOptions::remove_epsilon, and LatticePhoneAligner::RemoveEpsilonsFromLattice().

Referenced by kaldi::PhoneAlignLattice().

                      {
    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())
      ProcessQueueElement();

    if (opts_.remove_epsilon)
      RemoveEpsilonsFromLattice();

    return !error_;
  }

GetStateForTuple()

StateId GetStateForTuple ( const Tuple &  tuple, bool  add_to_queue  )

inline

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

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

Referenced by LatticePhoneAligner::AlignLattice(), LatticePhoneAligner::ProcessFinal(), and LatticePhoneAligner::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 163 of file phone-align-lattice.cc.

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

Referenced by LatticePhoneAligner::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;
      // Note: the next call will change the computation-state of the tuple,
      // so it becomes a different tuple.
      tuple.comp_state.OutputArcForce(tmodel_, opts_, &lat_arc, &error_);
      lat_arc.nextstate = GetStateForTuple(tuple, true); // true == add to queue.
      // 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 194 of file phone-align-lattice.cc.

References LatticePhoneAligner::ComputationState::Advance(), LatticePhoneAligner::Tuple::comp_state, LatticePhoneAligner::error_, LatticePhoneAligner::GetStateForTuple(), LatticePhoneAligner::Tuple::input_state, KALDI_ASSERT, LatticePhoneAligner::lat_, LatticePhoneAligner::lat_out_, CompactLatticeWeightTpl< WeightType, IntType >::One(), LatticePhoneAligner::opts_, LatticePhoneAligner::ProcessFinal(), LatticePhoneAligner::queue_, LatticePhoneAligner::tmodel_, and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

Referenced by LatticePhoneAligner::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.OutputPhoneArc(tmodel_, opts_, &lat_arc, &error_) ||
        tuple.comp_state.OutputWordArc(tmodel_, opts_, &lat_arc, &error_)) {
      // note: the functions OutputPhoneArc() and OutputWordArc() change the
      // tuple (when they return 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-states 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, opts_, &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 261 of file phone-align-lattice.cc.

References LatticePhoneAligner::lat_out_.

Referenced by LatticePhoneAligner::AlignLattice().

                                   {
    RmEpsilon(lat_out_, true); // true = connect.
  }

Member Data Documentation

error_

bool error_

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

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

lat_

CompactLattice lat_

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

Referenced by LatticePhoneAligner::AlignLattice(), LatticePhoneAligner::LatticePhoneAligner(), and LatticePhoneAligner::ProcessQueueElement().

lat_out_

CompactLattice* lat_out_

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

Referenced by LatticePhoneAligner::AlignLattice(), LatticePhoneAligner::GetStateForTuple(), LatticePhoneAligner::ProcessFinal(), LatticePhoneAligner::ProcessQueueElement(), and LatticePhoneAligner::RemoveEpsilonsFromLattice().

map_

MapType map_

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

Referenced by LatticePhoneAligner::GetStateForTuple().

opts_

const PhoneAlignLatticeOptions& opts_

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

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

queue_

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

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

Referenced by LatticePhoneAligner::AlignLattice(), LatticePhoneAligner::GetStateForTuple(), and LatticePhoneAligner::ProcessQueueElement().

tmodel_

const TransitionModel& tmodel_

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

Referenced by LatticePhoneAligner::ProcessFinal(), and LatticePhoneAligner::ProcessQueueElement().

---

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

• lat/phone-align-lattice.cc