lattice-combine.cc File Reference

#include <string>
#include <vector>
#include "util/common-utils.h"
#include "lat/lattice-functions.h"
#include "lat/kaldi-lattice.h"
#include "lat/sausages.h"

Include dependency graph for lattice-combine.cc:

Go to the source code of this file.

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

Functions
bool	CompactLatticeNormalize (CompactLattice *clat, BaseFloat weight)
void	SplitStringToWeights (const string &full, const char *delim, vector< BaseFloat > *out)
int	main (int argc, char *argv[])

Function Documentation

main()

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

Definition at line 122 of file lattice-combine.cc.

References kaldi::CompactLatticeNormalize(), kaldi::DeletePointers(), SequentialTableReader< Holder >::Done(), SequentialTableReader< Holder >::FreeCurrent(), ParseOptions::GetArg(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, KALDI_WARN, SequentialTableReader< Holder >::Key(), fst::LatticeScale(), SequentialTableReader< Holder >::Next(), ParseOptions::NumArgs(), ParseOptions::PrintUsage(), ParseOptions::Read(), ParseOptions::Register(), fst::ScaleLattice(), kaldi::SplitStringToWeights(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

                                 {
  try {
    using namespace kaldi;
    typedef kaldi::int32 int32;

    const char *usage =
        "Combine lattices generated by different systems by removing the total\n"
        "cost of all paths (backward cost) from individual lattices and doing\n"
        "a union of the reweighted lattices.  Note: the acoustic and LM scales\n"
        "that this program applies are not removed before outputting the lattices.\n"
        "Intended for use in system combination prior to MBR decoding, see comments\n"
        "in code.\n"
        "Usage: lattice-combine [options] <lattice-rspecifier1> <lattice-rspecifier2>"
        " [<lattice-rspecifier3> ... ] <lattice-wspecifier>\n"
        "E.g.: lattice-combine 'ark:gunzip -c foo/lat.1.gz|' 'ark:gunzip -c bar/lat.1.gz|' ark:- | ...\n";

    ParseOptions po(usage);
    BaseFloat acoustic_scale = 1.0, inv_acoustic_scale = 1.0, lm_scale = 1.0;
    string weight_str;
    po.Register("acoustic-scale", &acoustic_scale, "Scaling factor for "
                "acoustic likelihoods");
    po.Register("inv-acoustic-scale", &inv_acoustic_scale, "An alternative way "
                "of setting the acoustic scale: you can set its inverse.");
    po.Register("lm-scale", &lm_scale, "Scaling factor for language model "
                "probabilities");
    po.Register("lat-weights", &weight_str, "Colon-separated list of weights "
                "for each rspecifier (which should sum to 1), e.g. '0.2:0.8'");

    po.Read(argc, argv);

    KALDI_ASSERT(acoustic_scale == 1.0 || inv_acoustic_scale == 1.0);
    if (inv_acoustic_scale != 1.0)
      acoustic_scale = 1.0 / inv_acoustic_scale;


    int32 num_args = po.NumArgs();
    if (num_args < 3) {
      po.PrintUsage();
      exit(1);
    }

    string lats_rspecifier1 = po.GetArg(1),
        lats_wspecifier = po.GetArg(num_args);

    // Output lattice
    CompactLatticeWriter clat_writer(lats_wspecifier);

    // Input lattices
    SequentialCompactLatticeReader clat_reader1(lats_rspecifier1);
    vector<RandomAccessCompactLatticeReader*> clat_reader_vec(
        num_args-2, static_cast<RandomAccessCompactLatticeReader*>(NULL));
    vector<string> clat_rspec_vec(num_args-2);
    for (int32 i = 2; i < num_args; ++i) {
      clat_reader_vec[i-2] = new RandomAccessCompactLatticeReader(po.GetArg(i));
      clat_rspec_vec[i-2] = po.GetArg(i);
    }

    vector<BaseFloat> lat_weights(num_args-1, 1.0/(num_args-1));
    if (!weight_str.empty())
      SplitStringToWeights(weight_str, ":", &lat_weights);

    int32 n_utts = 0, n_total_lats = 0, n_success = 0, n_missing = 0,
        n_other_errors = 0;
    vector< vector<double> > lat_scale = fst::LatticeScale(lm_scale,
                                                           acoustic_scale);

    for (; !clat_reader1.Done(); clat_reader1.Next()) {
      std::string key = clat_reader1.Key();
      CompactLattice clat1 = clat_reader1.Value();
      clat_reader1.FreeCurrent();
      n_utts++;
      n_total_lats++;
      fst::ScaleLattice(lat_scale, &clat1);
      bool success = CompactLatticeNormalize(&clat1, lat_weights[0]);
      if (!success) {
        KALDI_WARN << "Could not normalize lattice for system 1, utterance: "
                   << key;
        n_other_errors++;
        continue;
      }

      for (int32 i = 0; i < num_args-2; ++i) {
        if (clat_reader_vec[i]->HasKey(key)) {
          CompactLattice clat2 = clat_reader_vec[i]->Value(key);
          n_total_lats++;
          fst::ScaleLattice(lat_scale, &clat2);
          success = CompactLatticeNormalize(&clat2, lat_weights[i+1]);
          if (!success) {
            KALDI_WARN << "Could not normalize lattice for system "<< (i + 2)
                       << ", utterance: " << key;
            n_other_errors++;
            continue;
          }
          fst::Union(&clat1, clat2);
        } else {
          KALDI_WARN << "No lattice found for utterance " << key << " for "
                     << "system " << (i + 2) << ", rspecifier: "
                     << clat_rspec_vec[i];
          n_missing++;
        }
      }

      clat_writer.Write(key, clat1);
      n_success++;
    }

    KALDI_LOG << "Processed " << n_utts << " utterances: with a total of "
              << n_total_lats << " lattices across " << (num_args-1)
              << " different systems";
    KALDI_LOG << "Produced output for " << n_success << " utterances; "
              << n_missing << " total missing lattices and " << n_other_errors
              << " total lattices had errors in processing.";
    DeletePointers(&clat_reader_vec);
    // The success code we choose is that at least one lattice was output,
    // and more lattices were "all there" than had at least one system missing.
    return (n_success != 0 && n_missing < (n_success - n_missing) ? 0 : 1);
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}