[src] Fix issue found by Remi Francis in incremental decoder, causing failure (#3874)

Author: danpovey

src/decoder/lattice-incremental-decoder.cc

@@ -901,6 +901,12 @@ const CompactLattice& LatticeIncrementalDecoderTpl<FST, Token>::GetLattice(
        this will do very little work. */
     PruneActiveTokens(config_.lattice_beam * config_.prune_scale);
 
+    if (determinizer_.GetLattice().NumStates() == 0 ||
+        determinizer_.GetLattice().Final(0) != CompactLatticeWeight::Zero()) {
+      num_frames_in_lattice_ = 0;
+      determinizer_.Init();
+    }
+
     Lattice chunk_lat;
 
     unordered_map<Label, LatticeArc::StateId> token_label2state;
@@ -1331,7 +1337,7 @@ void LatticeIncrementalDeterminizer::GetRawLatticeFinalCosts(
       if (value.olabel >= (Label)kTokenLabelOffset &&
           value.olabel < (Label)kMaxTokenLabel) {
         LatticeWeight final_weight = raw_fst.Final(value.nextstate);
-        if (final_weight == LatticeWeight::Zero() ||
+        if (final_weight != LatticeWeight::Zero() &&
             final_weight.Value2() != 0) {
           KALDI_ERR << "Label " << value.olabel << " from state " << s
                     << " looks like a token-label but its next-state "
@@ -1356,8 +1362,7 @@ void LatticeIncrementalDeterminizer::GetRawLatticeFinalCosts(
 
 bool LatticeIncrementalDeterminizer::ProcessArcsFromChunkStartState(
     const CompactLattice &chunk_clat,
-    std::unordered_map<CompactLattice::StateId, CompactLattice::StateId> *state_map,
-    CompactLatticeWeight *extra_start_weight) {
+    std::unordered_map<CompactLattice::StateId, CompactLattice::StateId> *state_map) {
   using StateId = CompactLattice::StateId;
   StateId clat_num_states = clat_.NumStates();
 
@@ -1408,21 +1413,17 @@ bool LatticeIncrementalDeterminizer::ProcessArcsFromChunkStartState(
     // in_weight is an extra weight that we'll include on arcs entering this
     // state from the previous chunk.  We need to cancel out
     // `forward_costs[clat_state]`, which was included in the corresponding arc
-    // in the raw lattice for pruning purposes; and we need to include
-    // the weight from the start-state of `chunk_clat` to this state.
+    // in the raw lattice for pruning purposes; and we need to include the
+    // weight on the arc from the start-state of `chunk_clat` to this state.
     CompactLatticeWeight extra_weight_in = arc.weight;
     extra_weight_in.SetWeight(
         fst::Times(extra_weight_in.Weight(),
                    LatticeWeight(-forward_costs_[clat_state], 0.0)));
 
-    if (clat_state == 0) {
-      // if clat_state is the star-state of clat_ (state 0), we can't modify
-      // incoming arcs; we need to modify outgoing arcs, but we'll do that
-      // later, after we add them.
-      *extra_start_weight = extra_weight_in;
-      forward_costs_[0] = forward_costs_[0] + ConvertToCost(extra_weight_in);
-      continue;
-    }
+    // We don't allow state 0 to be a redeterminized-state; calling code assures
+    // this.  Search for `determinizer_.GetLattice().Final(0) !=
+    // CompactLatticeWeight::Zero())` to find that calling code.
+    KALDI_ASSERT(clat_state != 0);
 
     // Note: 0 is the start state of clat_.  This was checked.
     forward_costs_[clat_state] = (clat_state == 0 ? 0 :
@@ -1431,11 +1432,12 @@ bool LatticeIncrementalDeterminizer::ProcessArcsFromChunkStartState(
     arcs_in.swap(arcs_in_[clat_state]);
     for (auto p: arcs_in) {
       // Note: we'll be doing `continue` below if this input arc came from
-      // another redeterminized-state, because we did DeleteStates() for them in
+      // another redeterminized-state, because we did DeleteArcs() for them in
       // InitializeRawLatticeChunk().  Those arcs will be transferred
       // from chunk_clat later on.
       CompactLattice::StateId src_state = p.first;
       int32 arc_pos = p.second;
+
       if (arc_pos >= (int32)clat_.NumArcs(src_state))
         continue;
       fst::MutableArcIterator<CompactLattice> aiter(&clat_, src_state);
@@ -1459,16 +1461,6 @@ bool LatticeIncrementalDeterminizer::ProcessArcsFromChunkStartState(
   return false;  // this is not the first chunk.
 }
 
-void LatticeIncrementalDeterminizer::ReweightStartState(
-    CompactLatticeWeight &extra_start_weight) {
-  for (fst::MutableArcIterator<CompactLattice> aiter(&clat_, 0);
-       !aiter.Done(); aiter.Next()) {
-    CompactLatticeArc arc(aiter.Value());
-    arc.weight = fst::Times(extra_start_weight, arc.weight);
-    aiter.SetValue(arc);
-  }
-}
-
 void LatticeIncrementalDeterminizer::TransferArcsToClat(
     const CompactLattice &chunk_clat,
     bool is_first_chunk,
@@ -1602,9 +1594,7 @@ bool LatticeIncrementalDeterminizer::AcceptRawLatticeChunk(
   std::unordered_map<StateId, StateId> state_map;
 
 
-  CompactLatticeWeight extra_start_weight = CompactLatticeWeight::One();
-  bool is_first_chunk = ProcessArcsFromChunkStartState(chunk_clat, &state_map,
-                                                       &extra_start_weight);
+  bool is_first_chunk = ProcessArcsFromChunkStartState(chunk_clat, &state_map);
 
   // Remove any existing arcs in clat_ that leave redeterminized-states, and
   // make those states non-final.  Below, we'll add arcs leaving those states
@@ -1645,9 +1635,6 @@ bool LatticeIncrementalDeterminizer::AcceptRawLatticeChunk(
   TransferArcsToClat(chunk_clat, is_first_chunk,
                      state_map, chunk_state_to_token, old_final_costs);
 
-  if (extra_start_weight != CompactLatticeWeight::One())
-    ReweightStartState(extra_start_weight);
-
   GetNonFinalRedetStates();
 
   return determinized_till_beam;

src/decoder/lattice-incremental-decoder.h

@@ -138,7 +138,7 @@ struct LatticeIncrementalDecoderConfig {
         prune_interval(25),
         beam_delta(0.5),
         hash_ratio(2.0),
-        prune_scale(0.1),
+        prune_scale(0.01),
         determinize_max_delay(60),
         determinize_min_chunk_size(20) {
     det_opts.minimize = false;
@@ -328,34 +328,11 @@ class LatticeIncrementalDeterminizer {
                           processing
         @param [out] state_map    Mapping from states in chunk_clat to
                           the state in clat_ they correspond to.
-        @param [out] extra_start_weight  If the start-state of
-                          clat_ (its state 0) needs to be modified as
-                          if its incoming arcs were multiplied by
-                          `extra_start_weight`, this isn't possible
-                          using the `in_arcs_` data-structure,
-                          so we remember the extra weight and multiply
-                          it in later, after processing arcs leaving
-                          the start state of clat_.  This is set
-                          only if the start-state of clat_ is a
-                          redeterminized state.
         @return     Returns true if this is the first chunk.
   */
   bool ProcessArcsFromChunkStartState(
       const CompactLattice &chunk_clat,
-      std::unordered_map<CompactLattice::StateId, CompactLattice::StateId> *state_map,
-      CompactLatticeWeight *extra_start_weight);
-
-  /**
-     This function, called from AcceptRawLatticeChunk(), takes care of an
-     unusual situation where we need to reweight the start state of clat_.  This
-     `extra_start_weight` is to be thought of as an extra `incoming` weight, and
-     we need to left-multiply all the arcs leaving the start state, by it.
-
-     This function does not need to modify forward_costs_; that will
-     already have been done by ProcessArcsFromChunkStartState().
-   */
-  void ReweightStartState(CompactLatticeWeight &extra_start_weight);
-
+      std::unordered_map<CompactLattice::StateId, CompactLattice::StateId> *state_map);
 
   /**
      This function, called from AcceptRawLatticeChunk(), transfers arcs from