lattice-determinize-pruned-parallel.cc File Reference

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

Include dependency graph for lattice-determinize-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 97 of file lattice-determinize-pruned-parallel.cc.

References DeterminizeLatticeTask::DeterminizeLatticeTask(), SequentialTableReader< Holder >::Done(), ParseOptions::GetArg(), KALDI_ERR, KALDI_LOG, KALDI_VLOG, SequentialTableReader< Holder >::Key(), DeterminizeLatticePrunedOptions::max_loop, DeterminizeLatticePrunedOptions::max_mem, SequentialTableReader< Holder >::Next(), ParseOptions::NumArgs(), ParseOptions::PrintUsage(), ParseOptions::Read(), ParseOptions::Register(), DeterminizeLatticePrunedOptions::Register(), TaskSequencerConfig::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 acoustic states)\n"
        "for each input-symbol sequence.  This is a version of lattice-determnize-pruned\n"
        "that accepts the --num-threads option.  These programs do pruning as part of the\n"
        "determinization algorithm, which is more efficient and prevents blowup.\n"
        "See http://kaldi-asr.org/doc/lattices.html for more information on lattices.\n"
        "\n"
        "Usage: lattice-determinize-pruned-parallel [options] lattice-rspecifier lattice-wspecifier\n"
        " e.g.: lattice-determinize-pruned-parallel --acoustic-scale=0.1 --beam=6.0 ark:in.lats ark:det.lats\n";
    
    ParseOptions po(usage);
    BaseFloat acoustic_scale = 1.0;
    BaseFloat beam = 10.0;
    bool minimize = false;
    TaskSequencerConfig sequencer_config; // has --num-threads option
    fst::DeterminizeLatticePrunedOptions determinize_config; // Options used in DeterminizeLatticePruned--
    // this options class does not have its own Register function as it's viewed as
    // being more part of "fst world", so we register its elements independently.
    determinize_config.max_mem = 50000000;
    determinize_config.max_loop = 0; // was 500000;
    
    po.Register("acoustic-scale", &acoustic_scale,
                "Scaling factor for acoustic likelihoods");
    po.Register("beam", &beam, "Pruning beam [applied after acoustic scaling].");
    po.Register("minimize", &minimize,
                "If true, push and minimize after determinization");
    determinize_config.Register(&po);
    sequencer_config.Register(&po);
    po.Read(argc, argv);

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

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


    // Read as regular lattice-- this is the form the determinization code
    // accepts.
    SequentialLatticeReader lat_reader(lats_rspecifier);
    
    // Write as compact lattice.
    CompactLatticeWriter compact_lat_writer(lats_wspecifier); 
    TaskSequencer<DeterminizeLatticeTask> sequencer(sequencer_config);
    
    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();

      Lattice *lat = lat_reader.Value().Copy(); // will give ownership to "task"
                                                // below
      
      KALDI_VLOG(2) << "Processing lattice " << key;

      DeterminizeLatticeTask *task = new DeterminizeLatticeTask(
          determinize_config, key, acoustic_scale, beam, minimize,
          lat, &compact_lat_writer, &n_warn);
      sequencer.Run(task);
      n_done++;
    }
    sequencer.Wait();
    KALDI_LOG << "Done " << n_done << " lattices, had warnings on " << n_warn
              << " of these.";
    return (n_done != 0 ? 0 : 1);
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}