FunASR/runtime/onnxruntime/src/bias-lm.cpp

#include "bias-lm.h"
#ifdef _WIN32
#include "fst-types.cc"
#endif
namespace funasr {
void print(std::queue<StateId> &q) {
  std::queue<StateId> data = q;
  while (!data.empty())
  {
    cout << data.front() << " ";
    data.pop();
  }
  cout << endl;
}

void BiasLm::LoadCfgFromYaml(const char* filename, BiasLmOption &opt) {
  YAML::Node config;
  try {
    config = YAML::LoadFile(filename);
  } catch(exception const &e) {
    LOG(INFO) << "Error loading file, yaml file error or not exist.";
    exit(-1);
  }
  try {
    YAML::Node bias_lm_conf = config["bias_lm_conf"];
    opt_.incre_bias_ = bias_lm_conf["increment_weight"].as<float>();
  } catch(exception const &e) {
  }
}

void BiasLm::BuildGraph(std::vector<std::vector<int>> &split_id_vec,
  std::vector<float> &custom_weight) {
  if (split_id_vec.empty()) {
    LOG(INFO) << "Skip building biaslm graph, hotword not exits.";
    return ; 
  }
  assert(split_id_vec.size() == custom_weight.size());
  // Build prefix tree
  std::unique_ptr<fst::StdVectorFst> prefix_tree(new fst::StdVectorFst());
  StateId start_state = prefix_tree->AddState();
  prefix_tree->SetStart(start_state);
  int id = 0;
  for (auto& x : split_id_vec) {
    StateId state = start_state;
    StateId next_state = state;
    float w = custom_weight[id++];
    std::vector<int> split_id = x;
    for (int j = 0; j < split_id.size(); j++) {
      next_state = prefix_tree->AddState();
      if (j == split_id.size() - 1) {
        prefix_tree->SetFinal(next_state, w);
      }
      prefix_tree->AddArc(state, Arc(split_id[j], split_id[j], opt_.incre_bias_, next_state));
      state = next_state;
    }
  }
  graph_ = std::unique_ptr<fst::StdVectorFst>(new fst::StdVectorFst());
  fst::Determinize(*prefix_tree, graph_.get());

  int num_node = graph_->NumStates();
  node_list_.resize(num_node);
  for (auto& x : split_id_vec) {
    StateId cur_state = 0;
    StateId next_state = 0;
    std::vector<int> split_id = x;
    for (int j = 0; j < split_id.size(); j++) {
      Matcher matcher(*graph_, fst::MATCH_INPUT);
      matcher.SetState(cur_state);
      if (matcher.Find(split_id[j])) {
        next_state = matcher.Value().nextstate;
        if (graph_->Final(next_state) != Weight::Zero()) {
          node_list_[next_state].is_final_ = true;
        }
        node_list_[next_state].score_ = opt_.incre_bias_ * (j + 1);
        cur_state = next_state;
      }
    }
  }
  
  // Build Aho-Corasick Automata
  std::queue<StateId> q;
  Matcher matcher(*graph_, fst::MATCH_INPUT);
  // Back off state of all child nodes of the root node points to the root node
  for (ArcIterator aiter(*graph_, start_state); !aiter.Done(); aiter.Next()) {
    const Arc& arc = aiter.Value();
    node_list_[arc.nextstate].back_off_ = start_state;
    float back_off_score = (node_list_[arc.nextstate].is_final_ ? 0 :
      node_list_[start_state].score_ - node_list_[arc.nextstate].score_);
    graph_->AddArc(arc.nextstate, Arc(0, 0, back_off_score, start_state));
    q.push(arc.nextstate);
  }
  while (!q.empty()) {
    StateId state_id = q.front();
    q.pop();
    for (ArcIterator aiter(*graph_, state_id); !aiter.Done(); aiter.Next()) {
      const Arc& arc = aiter.Value();
      StateId next_state = arc.nextstate;
      StateId temp_state = node_list_[state_id].back_off_;
      if (next_state == start_state || next_state == temp_state) { 
        continue; 
      }
      while (true) {
        matcher.SetState(temp_state);
        if (matcher.Find(arc.ilabel)) {
          node_list_[next_state].back_off_ = matcher.Value().nextstate;
          break;
        } else if (temp_state == start_state) {
          node_list_[next_state].back_off_ = start_state;
          break;
        }
        temp_state = node_list_[temp_state].back_off_;
      }
      float back_off_score = (node_list_[next_state].is_final_ ? 0 :
        node_list_[node_list_[next_state].back_off_].score_ -
        node_list_[next_state].score_);
      graph_->AddArc(next_state, Arc(0, 0, back_off_score, 
        node_list_[next_state].back_off_));
      q.push(next_state);
    }
  }
  fst::ArcSort(graph_.get(), fst::StdILabelCompare());
  //graph_->Write("graph.final.fst");
}

float BiasLm::BiasLmScore(const StateId &his_state, const Label &lab, Label &new_state) {
  if (lab < 1 || lab > phn_set_.Size() || !graph_) { return VALUE_ZERO; }
  StateId cur_state = his_state;
  StateId next_state;
  float score = VALUE_ZERO;
  Matcher matcher(*graph_, fst::MATCH_INPUT);
  while (true) {
    StateId prev_state = cur_state;
    matcher.SetState(cur_state);
    if (matcher.Find(lab)) {
      next_state = matcher.Value().nextstate;
      score += matcher.Value().weight.Value();
      if (node_list_[next_state].is_final_) {
        score = score + graph_->Final(next_state).Value();
      }
      cur_state = next_state;
      break;
    } else {
      ArcIterator aiter(*graph_, cur_state);
      const Arc& arc = aiter.Value();
      if (arc.ilabel == 0) {
        score += arc.weight.Value();
        next_state = arc.nextstate;
        cur_state = next_state;
      }
      if (prev_state == ROOT_NODE && cur_state == ROOT_NODE) {
        break;
      }
    }
  }
  new_state = cur_state;
  return score;
}

void BiasLm::VocabIdToPhnIdVector(int vocab_id, std::vector<int> &phn_ids) {
  bool is_oov = false;
  phn_ids.clear();
  std::string word = vocab_.Id2String(vocab_id);
  std::vector<std::string> phn_vec;
  Utf8ToCharset(word, phn_vec);
  for (auto& phn : phn_vec) {
    if (!phn_set_.Find(phn)) {
      is_oov = true;
      break;
    } else {
      phn_ids.push_back(phn_set_.String2Id(phn));
    }
  }
  if (is_oov) { phn_ids.clear(); }
}

std::string BiasLm::GetPhoneLabel(int phone_id) {
  if (phone_id < 0 || phone_id >= phn_set_.Size()) { return ""; }
  return phn_set_.Id2String(phone_id);
}
}