add test binary

Author: LvHang

src/bin/Makefile

@@ -22,7 +22,7 @@ BINFILES = align-equal align-equal-compiled acc-tree-stats \
         matrix-sum build-pfile-from-ali get-post-on-ali tree-info am-info \
         vector-sum matrix-sum-rows est-pca sum-lda-accs sum-mllt-accs \
         transform-vec align-text matrix-dim post-to-smat compile-graph \
-        compare-int-vector
+        compare-int-vector latgen-faster-mapped-combine
 
 
 OBJFILES =

src/decoder/decoder-wrappers.cc

@@ -546,4 +546,303 @@ void AlignUtteranceWrapper(
   }
 }
 
+// For lattice-faster-decoder-combine
+DecodeUtteranceLatticeFasterCombineClass::DecodeUtteranceLatticeFasterCombineClass(
+    LatticeFasterDecoderCombine *decoder,
+    DecodableInterface *decodable,
+    const TransitionModel &trans_model,
+    const fst::SymbolTable *word_syms,
+    std::string utt,
+    BaseFloat acoustic_scale,
+    bool determinize,
+    bool allow_partial,
+    Int32VectorWriter *alignments_writer,
+    Int32VectorWriter *words_writer,
+    CompactLatticeWriter *compact_lattice_writer,
+    LatticeWriter *lattice_writer,
+    double *like_sum, // on success, adds likelihood to this.
+    int64 *frame_sum, // on success, adds #frames to this.
+    int32 *num_done, // on success (including partial decode), increments this.
+    int32 *num_err,  // on failure, increments this.
+    int32 *num_partial):  // If partial decode (final-state not reached), increments this.
+    decoder_(decoder), decodable_(decodable), trans_model_(&trans_model),
+    word_syms_(word_syms), utt_(utt), acoustic_scale_(acoustic_scale),
+    determinize_(determinize), allow_partial_(allow_partial),
+    alignments_writer_(alignments_writer),
+    words_writer_(words_writer),
+    compact_lattice_writer_(compact_lattice_writer),
+    lattice_writer_(lattice_writer),
+    like_sum_(like_sum), frame_sum_(frame_sum),
+    num_done_(num_done), num_err_(num_err),
+    num_partial_(num_partial),
+    computed_(false), success_(false), partial_(false),
+    clat_(NULL), lat_(NULL) { }
+
+
+void DecodeUtteranceLatticeFasterCombineClass::operator () () {
+  // Decoding and lattice determinization happens here.
+  computed_ = true; // Just means this function was called-- a check on the
+  // calling code.
+  success_ = true;
+  using fst::VectorFst;
+  if (!decoder_->Decode(decodable_)) {
+    KALDI_WARN << "Failed to decode file " << utt_;
+    success_ = false;
+  }
+  if (!decoder_->ReachedFinal()) {
+    if (allow_partial_) {
+      KALDI_WARN << "Outputting partial output for utterance " << utt_
+                 << " since no final-state reached\n";
+      partial_ = true;
+    } else {
+      KALDI_WARN << "Not producing output for utterance " << utt_
+                 << " since no final-state reached and "
+                 << "--allow-partial=false.\n";
+      success_ = false;
+    }
+  }
+  if (!success_) return;
+
+  // Get lattice, and do determinization if requested.
+  lat_ = new Lattice;
+  decoder_->GetRawLattice(lat_);
+  if (lat_->NumStates() == 0)
+    KALDI_ERR << "Unexpected problem getting lattice for utterance " << utt_;
+  fst::Connect(lat_);
+  if (determinize_) {
+    clat_ = new CompactLattice;
+    if (!DeterminizeLatticePhonePrunedWrapper(
+            *trans_model_,
+            lat_,
+            decoder_->GetOptions().lattice_beam,
+            clat_,
+            decoder_->GetOptions().det_opts))
+      KALDI_WARN << "Determinization finished earlier than the beam for "
+                 << "utterance " << utt_;
+    delete lat_;
+    lat_ = NULL;
+    // We'll write the lattice without acoustic scaling.
+    if (acoustic_scale_ != 0.0)
+      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale_), clat_);
+  } else {
+    // We'll write the lattice without acoustic scaling.
+    if (acoustic_scale_ != 0.0)
+      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale_), lat_);
+  }
+}
+
+DecodeUtteranceLatticeFasterCombineClass::~DecodeUtteranceLatticeFasterCombineClass() {
+  if (!computed_)
+    KALDI_ERR << "Destructor called without operator (), error in calling code.";
+
+  if (!success_) {
+    if (num_err_ != NULL) (*num_err_)++;
+  } else { // successful decode.
+    // Getting the one-best output is lightweight enough that we can do it in
+    // the destructor (easier than adding more variables to the class, and
+    // will rarely slow down the main thread.)
+    double likelihood;
+    LatticeWeight weight;
+    int32 num_frames;
+    { // First do some stuff with word-level traceback...
+      // This is basically for diagnostics.
+      fst::VectorFst<LatticeArc> decoded;
+      decoder_->GetBestPath(&decoded);
+      if (decoded.NumStates() == 0) {
+        // Shouldn't really reach this point as already checked success.
+        KALDI_ERR << "Failed to get traceback for utterance " << utt_;
+      }
+      std::vector<int32> alignment;
+      std::vector<int32> words;
+      GetLinearSymbolSequence(decoded, &alignment, &words, &weight);
+      num_frames = alignment.size();
+      if (words_writer_->IsOpen())
+        words_writer_->Write(utt_, words);
+      if (alignments_writer_->IsOpen())
+        alignments_writer_->Write(utt_, alignment);
+      if (word_syms_ != NULL) {
+        std::cerr << utt_ << ' ';
+        for (size_t i = 0; i < words.size(); i++) {
+          std::string s = word_syms_->Find(words[i]);
+          if (s == "")
+            KALDI_ERR << "Word-id " << words[i] << " not in symbol table.";
+          std::cerr << s << ' ';
+        }
+        std::cerr << '\n';
+      }
+      likelihood = -(weight.Value1() + weight.Value2());
+    }
+
+    // Ouptut the lattices.
+    if (determinize_) { // CompactLattice output.
+      KALDI_ASSERT(compact_lattice_writer_ != NULL && clat_ != NULL);
+      if (clat_->NumStates() == 0) {
+        KALDI_WARN << "Empty lattice for utterance " << utt_;
+      } else {
+        compact_lattice_writer_->Write(utt_, *clat_);
+      }
+      delete clat_;
+      clat_ = NULL;
+    } else {
+      KALDI_ASSERT(lattice_writer_ != NULL && lat_ != NULL);
+      if (lat_->NumStates() == 0) {
+        KALDI_WARN << "Empty lattice for utterance " << utt_;
+      } else {
+        lattice_writer_->Write(utt_, *lat_);
+      }
+      delete lat_;
+      lat_ = NULL;
+    }
+
+    // Print out logging information.
+    KALDI_LOG << "Log-like per frame for utterance " << utt_ << " is "
+              << (likelihood / num_frames) << " over "
+              << num_frames << " frames.";
+    KALDI_VLOG(2) << "Cost for utterance " << utt_ << " is "
+                  << weight.Value1() << " + " << weight.Value2();
+
+    // Now output the various diagnostic variables.
+    if (like_sum_ != NULL) *like_sum_ += likelihood;
+    if (frame_sum_ != NULL) *frame_sum_ += num_frames;
+    if (num_done_ != NULL) (*num_done_)++;
+    if (partial_ && num_partial_ != NULL) (*num_partial_)++;
+  }
+  // We were given ownership of these two objects that were passed in in
+  // the initializer.
+  delete decoder_;
+  delete decodable_;
+}
+
+
+// Takes care of output.  Returns true on success.
+template <typename FST>
+bool DecodeUtteranceLatticeFasterCombine(
+    LatticeFasterDecoderCombineTpl<FST> &decoder, // not const but is really an input.
+    DecodableInterface &decodable, // not const but is really an input.
+    const TransitionModel &trans_model,
+    const fst::SymbolTable *word_syms,
+    std::string utt,
+    double acoustic_scale,
+    bool determinize,
+    bool allow_partial,
+    Int32VectorWriter *alignment_writer,
+    Int32VectorWriter *words_writer,
+    CompactLatticeWriter *compact_lattice_writer,
+    LatticeWriter *lattice_writer,
+    double *like_ptr) { // puts utterance's like in like_ptr on success.
+  using fst::VectorFst;
+
+  if (!decoder.Decode(&decodable)) {
+    KALDI_WARN << "Failed to decode file " << utt;
+    return false;
+  }
+  if (!decoder.ReachedFinal()) {
+    if (allow_partial) {
+      KALDI_WARN << "Outputting partial output for utterance " << utt
+                 << " since no final-state reached\n";
+    } else {
+      KALDI_WARN << "Not producing output for utterance " << utt
+                 << " since no final-state reached and "
+                 << "--allow-partial=false.\n";
+      return false;
+    }
+  }
+
+  double likelihood;
+  LatticeWeight weight;
+  int32 num_frames;
+  { // First do some stuff with word-level traceback...
+    VectorFst<LatticeArc> decoded;
+    if (!decoder.GetBestPath(&decoded))
+      // Shouldn't really reach this point as already checked success.
+      KALDI_ERR << "Failed to get traceback for utterance " << utt;
+
+    std::vector<int32> alignment;
+    std::vector<int32> words;
+    GetLinearSymbolSequence(decoded, &alignment, &words, &weight);
+    num_frames = alignment.size();
+    if (words_writer->IsOpen())
+      words_writer->Write(utt, words);
+    if (alignment_writer->IsOpen())
+      alignment_writer->Write(utt, alignment);
+    if (word_syms != NULL) {
+      std::cerr << utt << ' ';
+      for (size_t i = 0; i < words.size(); i++) {
+        std::string s = word_syms->Find(words[i]);
+        if (s == "")
+          KALDI_ERR << "Word-id " << words[i] << " not in symbol table.";
+        std::cerr << s << ' ';
+      }
+      std::cerr << '\n';
+    }
+    likelihood = -(weight.Value1() + weight.Value2());
+  }
+
+  // Get lattice, and do determinization if requested.
+  Lattice lat;
+  decoder.GetRawLattice(&lat);
+  if (lat.NumStates() == 0)
+    KALDI_ERR << "Unexpected problem getting lattice for utterance " << utt;
+  fst::Connect(&lat);
+  if (determinize) {
+    CompactLattice clat;
+    if (!DeterminizeLatticePhonePrunedWrapper(
+            trans_model,
+            &lat,
+            decoder.GetOptions().lattice_beam,
+            &clat,
+            decoder.GetOptions().det_opts))
+      KALDI_WARN << "Determinization finished earlier than the beam for "
+                 << "utterance " << utt;
+    // We'll write the lattice without acoustic scaling.
+    if (acoustic_scale != 0.0)
+      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &clat);
+    compact_lattice_writer->Write(utt, clat);
+  } else {
+    // We'll write the lattice without acoustic scaling.
+    if (acoustic_scale != 0.0)
+      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &lat);
+    lattice_writer->Write(utt, lat);
+  }
+  KALDI_LOG << "Log-like per frame for utterance " << utt << " is "
+            << (likelihood / num_frames) << " over "
+            << num_frames << " frames.";
+  KALDI_VLOG(2) << "Cost for utterance " << utt << " is "
+                << weight.Value1() << " + " << weight.Value2();
+  *like_ptr = likelihood;
+  return true;
+}
+
+// Instantiate the template above for the two required FST types.
+template bool DecodeUtteranceLatticeFasterCombine(
+    LatticeFasterDecoderCombineTpl<fst::Fst<fst::StdArc> > &decoder,
+    DecodableInterface &decodable,
+    const TransitionModel &trans_model,
+    const fst::SymbolTable *word_syms,
+    std::string utt,
+    double acoustic_scale,
+    bool determinize,
+    bool allow_partial,
+    Int32VectorWriter *alignment_writer,
+    Int32VectorWriter *words_writer,
+    CompactLatticeWriter *compact_lattice_writer,
+    LatticeWriter *lattice_writer,
+    double *like_ptr);
+
+template bool DecodeUtteranceLatticeFasterCombine(
+    LatticeFasterDecoderCombineTpl<fst::GrammarFst> &decoder,
+    DecodableInterface &decodable,
+    const TransitionModel &trans_model,
+    const fst::SymbolTable *word_syms,
+    std::string utt,
+    double acoustic_scale,
+    bool determinize,
+    bool allow_partial,
+    Int32VectorWriter *alignment_writer,
+    Int32VectorWriter *words_writer,
+    CompactLatticeWriter *compact_lattice_writer,
+    LatticeWriter *lattice_writer,
+    double *like_ptr);
+
+
 } // end namespace kaldi.

src/decoder/decoder-wrappers.h

@@ -23,6 +23,7 @@
 #include "itf/options-itf.h"
 #include "decoder/lattice-faster-decoder.h"
 #include "decoder/lattice-simple-decoder.h"
+#include "decoder/lattice-faster-decoder-combine.h"
 
 // This header contains declarations from various convenience functions that are called
 // from binary-level programs such as gmm-decode-faster.cc, gmm-align-compiled.cc, and
@@ -196,6 +197,78 @@ bool DecodeUtteranceLatticeSimple(
     double *like_ptr);  // puts utterance's likelihood in like_ptr on success.
 
 
+// For lattice-faster-decoder-combine
+template <typename FST>
+bool DecodeUtteranceLatticeFasterCombine(
+    LatticeFasterDecoderCombineTpl<FST> &decoder, // not const but is really an input.
+    DecodableInterface &decodable, // not const but is really an input.
+    const TransitionModel &trans_model,
+    const fst::SymbolTable *word_syms,
+    std::string utt,
+    double acoustic_scale,
+    bool determinize,
+    bool allow_partial,
+    Int32VectorWriter *alignments_writer,
+    Int32VectorWriter *words_writer,
+    CompactLatticeWriter *compact_lattice_writer,
+    LatticeWriter *lattice_writer,
+    double *like_ptr);  // puts utterance's likelihood in like_ptr on success.
+
+
+class DecodeUtteranceLatticeFasterCombineClass {
+ public:
+  // Initializer sets various variables.
+  // NOTE: we "take ownership" of "decoder" and "decodable".  These
+  // are deleted by the destructor.  On error, "num_err" is incremented.
+  DecodeUtteranceLatticeFasterCombineClass(
+      LatticeFasterDecoderCombine *decoder,
+      DecodableInterface *decodable,
+      const TransitionModel &trans_model,
+      const fst::SymbolTable *word_syms,
+      std::string utt,
+      BaseFloat acoustic_scale,
+      bool determinize,
+      bool allow_partial,
+      Int32VectorWriter *alignments_writer,
+      Int32VectorWriter *words_writer,
+      CompactLatticeWriter *compact_lattice_writer,
+      LatticeWriter *lattice_writer,
+      double *like_sum, // on success, adds likelihood to this.
+      int64 *frame_sum, // on success, adds #frames to this.
+      int32 *num_done, // on success (including partial decode), increments this.
+      int32 *num_err,  // on failure, increments this.
+      int32 *num_partial);  // If partial decode (final-state not reached), increments this.
+  void operator () (); // The decoding happens here.
+  ~DecodeUtteranceLatticeFasterCombineClass(); // Output happens here.
+ private:
+  // The following variables correspond to inputs:
+  LatticeFasterDecoderCombine *decoder_;
+  DecodableInterface *decodable_;
+  const TransitionModel *trans_model_;
+  const fst::SymbolTable *word_syms_;
+  std::string utt_;
+  BaseFloat acoustic_scale_;
+  bool determinize_;
+  bool allow_partial_;
+  Int32VectorWriter *alignments_writer_;
+  Int32VectorWriter *words_writer_;
+  CompactLatticeWriter *compact_lattice_writer_;
+  LatticeWriter *lattice_writer_;
+  double *like_sum_;
+  int64 *frame_sum_;
+  int32 *num_done_;
+  int32 *num_err_;
+  int32 *num_partial_;
+
+  // The following variables are stored by the computation.
+  bool computed_; // operator ()  was called.
+  bool success_; // decoding succeeded (possibly partial)
+  bool partial_; // decoding was partial.
+  CompactLattice *clat_; // Stored output, if determinize_ == true.
+  Lattice *lat_; // Stored output, if determinize_ == false.
+};
+
+
 
 } // end namespace kaldi.