lattice-determinize-phone-pruned-parallel.cc File Reference

#include "base/kaldi-common.h"
#include "hmm/transition-model.h"
#include "lat/kaldi-lattice.h"
#include "lat/determinize-lattice-pruned.h"
#include "lat/lattice-functions.h"
#include "lat/push-lattice.h"
#include "util/common-utils.h"
#include "util/kaldi-thread.h"

Include dependency graph for lattice-determinize-phone-pruned-parallel.cc:

Go to the source code of this file.

Classes
class	DeterminizeLatticeTask

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 89 of file lattice-determinize-phone-pruned-parallel.cc.

References DeterminizeLatticeTask::DeterminizeLatticeTask(), SequentialTableReader< Holder >::Done(), ParseOptions::GetArg(), KALDI_ERR, KALDI_LOG, KALDI_VLOG, SequentialTableReader< Holder >::Key(), DeterminizeLatticePhonePrunedOptions::max_mem, SequentialTableReader< Holder >::Next(), ParseOptions::NumArgs(), ParseOptions::PrintUsage(), ParseOptions::Read(), kaldi::ReadKaldiObject(), ParseOptions::Register(), TaskSequencerConfig::Register(), DeterminizeLatticePhonePrunedOptions::Register(), TaskSequencer< C >::Run(), SequentialTableReader< Holder >::Value(), and TaskSequencer< C >::Wait().

                                 {
  try {
    using namespace kaldi;
    typedef kaldi::int32 int32;
    
    const char *usage =
        "Determinize lattices, keeping only the best path (sequence of\n"
        "acoustic states) for each input-symbol sequence. This is a version\n"
        "of lattice-determinize-phone-pruned that accepts the --num-threads\n"
        "option. The program does phone insertion when doing a first pass\n"
        "determinization, it then removes the inserted symbols and does a\n"
        "second pass determinization. It also does pruning as part of the\n"
        "determinization algorithm, which is more efficient and prevents\n"
        "blowup.\n"
        "\n"
        "Usage: lattice-determinize-phone-pruned-parallel [options] \\\n"
        "                 <model> <lattice-rspecifier> <lattice-wspecifier>\n"
        " e.g.: lattice-determinize-phone-pruned-parallel \\\n"
        "           --acoustic-scale=0.1 final.mdl ark:in.lats ark:det.lats\n";
    
    ParseOptions po(usage);
    BaseFloat acoustic_scale = 1.0;
    BaseFloat beam = 10.0;

    TaskSequencerConfig sequencer_opts;
    fst::DeterminizeLatticePhonePrunedOptions determinize_opts;
    determinize_opts.max_mem = 50000000;
    
    po.Register("acoustic-scale", &acoustic_scale, "Scaling factor for acoustic"
                " likelihoods.");
    po.Register("beam", &beam, "Pruning beam [applied after acoustic scaling].");
    determinize_opts.Register(&po);
    sequencer_opts.Register(&po);
    po.Read(argc, argv);

    if (po.NumArgs() != 3) {
      po.PrintUsage();
      exit(1);
    }

    std::string model_rxfilename = po.GetArg(1),
        lats_rspecifier = po.GetArg(2),
        lats_wspecifier = po.GetArg(3);

    TransitionModel trans_model;
    ReadKaldiObject(model_rxfilename, &trans_model);

    // Reads as regular lattice-- this is the form the determinization code
    // accepts.
    SequentialLatticeReader lat_reader(lats_rspecifier);
    
    // Writes as compact lattice.
    CompactLatticeWriter compact_lat_writer(lats_wspecifier);

    TaskSequencer<DeterminizeLatticeTask> sequencer(sequencer_opts);

    int32 n_done = 0, n_warn = 0;

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

    for (; !lat_reader.Done(); lat_reader.Next()) {
      std::string key = lat_reader.Key();

      // Will give ownership to "task" below.
      Lattice *lat = lat_reader.Value().Copy();

      KALDI_VLOG(2) << "Processing lattice " << key;

      DeterminizeLatticeTask *task = new DeterminizeLatticeTask(
          trans_model, determinize_opts, key, acoustic_scale, beam,
          lat, &compact_lat_writer, &n_warn);
      sequencer.Run(task);

      n_done++;
    }
    sequencer.Wait();
    KALDI_LOG << "Done " << n_done << " lattices, determinization finished "
              << "earlier than specified by the beam on " << n_warn << " of "
              << "these.";
    return (n_done != 0 ? 0 : 1);
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}