sfstcount.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.
// Algorithm to count from a stochastic FST w.r.t. a backoff-complete FST whose
// topology is provided.  Result is FST with backoff-complete topology weighted
// by expected counts derived from the input stochastic FST.

#include <cstring>
#include <string>

#include <fst/flags.h>
#include <fst/log.h>
#include <fst/arc.h>
#include <fst/fst.h>
#include <fst/mutable-fst.h>
#include <fst/properties.h>
#include <sfst/approx.h>
#include <sfst/count.h>
#include <sfst/normalize.h>

DEFINE_int64(phi_label, fst::kNoLabel,
             "Specifies failure label (default: none)");
DEFINE_double(delta, sfst::kApproxDelta, "Convergence delta");

int main(int argc, char **argv) {
  namespace f = fst;
  std::string usage = "Algorithm to count from stochastic FST w.r.t. a";
  usage += " backoff-complete FST whose topology is provided.\n\n  Usage: ";
  usage += argv[0];
  usage += " sfst.fst top.fst [out.fst]\n";

  SET_FLAGS(usage.c_str(), &argc, &argv, true);
  if (argc > 4) {
    ShowUsage();
    return 1;
  }

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

  if (in1_name.empty() && in2_name.empty()) {
    LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
    return 1;
  }

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

  f::StdMutableFst *ofst = f::StdMutableFst::Read(in2_name, true);
  if (!ofst) return 1;

  if (ifst->Properties(f::kCyclic, true) &&
      !sfst::IsNormalized(*ifst, FST_FLAGS_phi_label)) {
    LOG(ERROR) << argv[0] << ": First input is not a normalized stochastic FST";
    return 1;
  }

  sfst::Counter<f::StdArc> counter(FST_FLAGS_phi_label,
                                   FST_FLAGS_delta, ofst);
  counter.Count(*ifst);
  counter.Finalize();

  if (ofst->Properties(f::kError, false))
    return 1;

  if (!ofst->Write(out_name))
    return 1;

  return 0;
}