sfstrandgen.cc

Go to the documentation of this file.

// Copyright 2018-2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the 'License');
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an 'AS IS' BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Generates random paths through a stochastic FST. The FST must be a
// normalized.

#include <time.h>

#include <climits>
#include <cstring>
#include <string>

#include <fst/flags.h>
#include <fst/log.h>
#include <fst/arc.h>
#include <fst/fst.h>
#include <fst/randgen.h>
#include <fst/vector-fst.h>
#include <sfst/normalize.h>
#include <sfst/randgen.h>

DEFINE_int64(phi_label, fst::kNoLabel,
             "Specifies failure label (default: none)");
DEFINE_int32(max_length, INT_MAX, "Maximum path length");
DEFINE_int64(npath, 1, "Number of paths to generate");
DEFINE_int32(seed, time(0), "Random seed");
DEFINE_bool(weighted, false,
            "Output tree weighted by path count vs. unweighted paths");
DEFINE_bool(remove_total_weight, false,
            "Remove total weight when output weighted");
DEFINE_bool(minimal, false,
            "Epsilon/phi-remove and minimize when output is weighted");
DEFINE_bool(stochastic, false,
            "Same as --weighted --remove_total_weight --minimal");


int main(int argc, char **argv) {
  namespace f = fst;
  std::string usage = "Generates random paths through an LM.\n\n  Usage: ";
  usage += argv[0];
  usage += " [in.fst [out.fst]]\n";

  SET_FLAGS(usage.c_str(), &argc, &argv, true);
  if (FST_FLAGS_stochastic) {
  }

  if (argc > 3) {
    ShowUsage();
    return 1;
  }

  VLOG(1) << argv[0] << ": Seed = " << FST_FLAGS_seed;

  std::string in_name =
      (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
  std::string out_name = argc > 2 ? argv[2] : "";

  f::StdFst *ifst = f::StdFst::Read(in_name);
  if (!ifst) return 1;

  if (!sfst::IsNormalized(*ifst, FST_FLAGS_phi_label)) {
    LOG(ERROR) << argv[0] << ": Input is not a normalized stochastic FST";
    return 1;
  }

  f::StdVectorFst ofst;

  sfst::SFstArcSelector<f::StdArc> selector(FST_FLAGS_seed,
                                            FST_FLAGS_phi_label);
  f::RandGenOptions<sfst::SFstArcSelector<f::StdArc>> opts(
      selector, FST_FLAGS_max_length, FST_FLAGS_npath,
      FST_FLAGS_weighted, FST_FLAGS_remove_total_weight);
  f::RandGen(*ifst, &ofst, opts);
  if (FST_FLAGS_weighted && FST_FLAGS_minimal)
    f::RandMinimize(&ofst, FST_FLAGS_phi_label);
  if (!ofst.Write(out_name))
    return 1;

  return 0;
}