fstcomposecontext.cc File Reference

#include "base/kaldi-common.h"
#include "util/common-utils.h"
#include "fst/fstlib.h"
#include "fstext/context-fst.h"
#include "fstext/grammar-context-fst.h"
#include "fstext/fstext-utils.h"
#include "fstext/kaldi-fst-io.h"

Include dependency graph for fstcomposecontext.cc:

Go to the source code of this file.

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

Function Documentation

main()

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

Definition at line 66 of file fstcomposecontext.cc.

References fst::ComposeContext(), fst::ComposeContextLeftBiphone(), ParseOptions::GetArg(), ParseOptions::GetOptArg(), rnnlm::i, KALDI_ERR, KALDI_WARN, ParseOptions::NumArgs(), kaldi::PrintableRxfilename(), kaldi::PrintableWxfilename(), ParseOptions::PrintUsage(), ParseOptions::Read(), fst::ReadFstKaldi(), kaldi::ReadIntegerVectorSimple(), ParseOptions::Register(), fst::WriteFstKaldi(), fst::WriteILabelInfo(), and kaldi::WriteIntegerVectorSimple().

                                 {
  try {
    using namespace kaldi;
    using namespace fst;
    using kaldi::int32;
    /*
        # fstcomposecontext composes efficiently with a context fst
        # that it generates.  Without --disambig-syms specified, it
        # assumes that all input symbols of in.fst are phones.
        # It adds the subsequential symbol itself (it does not
        # appear in the output so doesn't need to be specified by the user).
        # the disambig.list is a list of disambiguation symbols on the LHS
        # of in.fst.  The symbols on the LHS of out.fst are indexes into
        # the ilabels.list file, which is a kaldi-format file containing a
        # vector<vector<int32> >, which specifies what the labels mean in
        # terms of windows of symbols.
        fstcomposecontext  ilabels.sym  [ in.fst [ out.fst ] ]
         --disambig-syms=disambig.list
         --context-size=3
         --central-position=1
         --binary=false
    */

    const char *usage =
        "Composes on the left with a dynamically created context FST\n"
        "\n"
        "Usage:  fstcomposecontext <ilabels-output-file>  [<in.fst> [<out.fst>] ]\n"
        "E.g:  fstcomposecontext ilabels.sym < LG.fst > CLG.fst\n";


    ParseOptions po(usage);
    bool binary = true;
    std::string disambig_rxfilename,
        disambig_wxfilename;
    int32 context_width = 3, central_position = 1;
    int32 nonterm_phones_offset = -1;
    po.Register("binary", &binary,
                "If true, output ilabels-output-file in binary format");
    po.Register("read-disambig-syms", &disambig_rxfilename,
                "List of disambiguation symbols on input of in.fst");
    po.Register("write-disambig-syms", &disambig_wxfilename,
                "List of disambiguation symbols on input of out.fst");
    po.Register("context-size", &context_width, "Size of phone context window");
    po.Register("central-position", &central_position,
                "Designated central position in context window");
    po.Register("nonterm-phones-offset",  &nonterm_phones_offset,
                "The integer id of #nonterm_bos in your phones.txt, if present "
                "(only relevant for grammar-FST construction, see "
                "doc/grammar.dox");

    po.Read(argc, argv);

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

    std::string ilabels_out_filename = po.GetArg(1),
        fst_in_filename = po.GetOptArg(2),
        fst_out_filename = po.GetOptArg(3);

    VectorFst<StdArc> *fst = ReadFstKaldi(fst_in_filename);

    if ( (disambig_wxfilename != "") && (disambig_rxfilename == "") )
      KALDI_ERR << "fstcomposecontext: cannot specify --write-disambig-syms if "
          "not specifying --read-disambig-syms\n";

    std::vector<int32> disambig_in;
    if (disambig_rxfilename != "")
      if (!ReadIntegerVectorSimple(disambig_rxfilename, &disambig_in))
        KALDI_ERR << "fstcomposecontext: Could not read disambiguation symbols from "
                  << PrintableRxfilename(disambig_rxfilename);

    if (disambig_in.empty()) {
      KALDI_WARN << "Disambiguation symbols list is empty; this likely "
                 << "indicates an error in data preparation.";
    }

    std::vector<std::vector<int32> > ilabels;
    VectorFst<StdArc> composed_fst;

    // Work gets done here (see context-fst.h)
    if (nonterm_phones_offset < 0) {
      // The normal case.
      ComposeContext(disambig_in, context_width, central_position,
                     fst, &composed_fst, &ilabels);
    } else {
      // The grammar-FST case. See ../doc/grammar.dox for an intro.
      if (context_width != 2 || central_position != 1) {
        KALDI_ERR << "Grammar-fst graph creation only supports models with left-"
            "biphone context.  (--nonterm-phones-offset option was supplied).";
      }
      ComposeContextLeftBiphone(nonterm_phones_offset,  disambig_in,
                                *fst, &composed_fst, &ilabels);
    }
    WriteILabelInfo(Output(ilabels_out_filename, binary).Stream(),
                    binary, ilabels);

    if (disambig_wxfilename != "") {
      std::vector<int32> disambig_out;
      for (size_t i = 0; i < ilabels.size(); i++)
        if (ilabels[i].size() == 1 && ilabels[i][0] <= 0)
          disambig_out.push_back(static_cast<int32>(i));
      if (!WriteIntegerVectorSimple(disambig_wxfilename, disambig_out)) {
        std::cerr << "fstcomposecontext: Could not write disambiguation symbols to "
                  << PrintableWxfilename(disambig_wxfilename) << '\n';
        return 1;
      }
    }

    WriteFstKaldi(composed_fst, fst_out_filename);
    delete fst;
    return 0;
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}