lattice-arc-post.cc File Reference

#include "base/kaldi-common.h"
#include "util/common-utils.h"
#include "fstext/fstext-lib.h"
#include "lat/kaldi-lattice.h"
#include "lat/lattice-functions.h"

Include dependency graph for lattice-arc-post.cc:

Go to the source code of this file.

Classes
class	ArcPosteriorComputer

Namespaces
	kaldi
	This code computes Goodness of Pronunciation (GOP) and extracts phone-level pronunciation feature for mispronunciations detection tasks, the reference:

Functions
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 112 of file lattice-arc-post.cc.

References SequentialTableReader< Holder >::Done(), SequentialTableReader< Holder >::FreeCurrent(), ParseOptions::GetArg(), KALDI_ERR, KALDI_LOG, KALDI_WARN, SequentialTableReader< Holder >::Key(), fst::LatticeScale(), SequentialTableReader< Holder >::Next(), ParseOptions::NumArgs(), ArcPosteriorComputer::OutputPosteriors(), ParseOptions::PrintUsage(), ParseOptions::Read(), kaldi::ReadKaldiObject(), ParseOptions::Register(), fst::ScaleLattice(), Output::Stream(), kaldi::TopSortCompactLatticeIfNeeded(), and SequentialTableReader< Holder >::Value().

                                 {
  try {
    typedef kaldi::int32 int32;
    using fst::SymbolTable;
    using fst::VectorFst;
    using fst::StdArc;

    const char *usage =
        "Print out information regarding posteriors of lattice arcs\n"
        "This program computes posteriors from a lattice and prints out\n"
        "information for each arc (the format is reminiscent of ctm, but\n"
        "contains information from multiple paths).  Each line is:\n"
        " <utterance-id> <start-frame> <num-frames> <posterior> <word> [<ali>] [<phone1> <phone2>...]\n"
        "for instance:\n"
        "2013a04-bk42\t104\t26\t0.95\t0\t11,242,242,242,71,894,894,62,63,63,63,63\t2 8 9\n"
        "where the --print-alignment option determines whether the alignments (i.e. the\n"
        "sequences of transition-ids) are printed, and the phones are printed only if the\n"
        "<model> is supplied on the command line.  Note, there are tabs between the major\n"
        "fields, but the phones are separated by spaces.\n"
        "Usage: lattice-arc-post [<model>] <lattices-rspecifier> <output-wxfilename>\n"
        "e.g.: lattice-arc-post --acoustic-scale=0.1 final.mdl 'ark:gunzip -c lat.1.gz|' post.txt\n"
        "You will probably want to word-align the lattices (e.g. lattice-align-words or\n"
        "lattice-align-words-lexicon) before this program, apply an acoustic scale either\n"
        "via the --acoustic-scale option or using lattice-scale.\n"
        "See also: lattice-post, lattice-to-ctm-conf, nbest-to-ctm\n";

    kaldi::BaseFloat acoustic_scale = 1.0, lm_scale = 1.0;
    kaldi::BaseFloat min_post = 0.0001;
    bool print_alignment = false;

    kaldi::ParseOptions po(usage);
    po.Register("acoustic-scale", &acoustic_scale,
                "Scaling factor for acoustic likelihoods");
    po.Register("lm-scale", &lm_scale,
                "Scaling factor for \"graph costs\" (including LM costs)");
    po.Register("print-alignment", &print_alignment,
                "If true, print alignments (i.e. sequences of transition-ids) for each\n"
                "arc.");
    po.Register("min-post", &min_post,
                "Arc posteriors below this value will be pruned away");
    po.Read(argc, argv);

    if (po.NumArgs() < 2 || po.NumArgs() > 3) {
      po.PrintUsage();
      exit(1);
    }

    if (acoustic_scale == 0.0)
      KALDI_ERR << "Do not use a zero acoustic scale (cannot be inverted)";

    kaldi::TransitionModel trans_model;

    std::string lats_rspecifier, output_wxfilename;
    if (po.NumArgs() == 3) {
      ReadKaldiObject(po.GetArg(1), &trans_model);
      lats_rspecifier = po.GetArg(2);
      output_wxfilename = po.GetArg(3);
    } else {
      lats_rspecifier = po.GetArg(1);
      output_wxfilename = po.GetArg(2);
    }


    kaldi::Output output(output_wxfilename, false);

    // Read as regular lattice
    kaldi::SequentialCompactLatticeReader clat_reader(lats_rspecifier);

    int64 tot_post = 0;
    int32 num_lat_done = 0, num_lat_err = 0;

    for (; !clat_reader.Done(); clat_reader.Next()) {
      std::string key = clat_reader.Key();
      kaldi::CompactLattice clat = clat_reader.Value();
      // FreeCurrent() is an optimization that prevents the lattice from being
      // copied unnecessarily (OpenFst does copy-on-write).
      clat_reader.FreeCurrent();
      fst::ScaleLattice(fst::LatticeScale(lm_scale, acoustic_scale), &clat);
      kaldi::TopSortCompactLatticeIfNeeded(&clat);

      kaldi::ArcPosteriorComputer computer(
          clat, min_post, print_alignment,
          (po.NumArgs() == 3 ? &trans_model : NULL));

      int32 num_post = computer.OutputPosteriors(key, output.Stream());
      if (num_post != 0) {
        num_lat_done++;
        tot_post += num_post;
      } else {
        num_lat_err++;
        KALDI_WARN << "No posterior printed for " << key;
      }
    }
    KALDI_LOG << "Printed posteriors for " << num_lat_done << " lattices ("
              << num_lat_err << " with errors); on average printed "
              << (tot_post / (num_lat_done == 0 ? 1 : num_lat_done))
              << " posteriors per lattice.";
    return (num_lat_done > 0 ? 0 : 1);
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}