语音识别系列3--KALDI解码器（SimpleDecoder）

古城微笑少年丶 2022-01-29 23:23 501阅读 0赞

**Kaldi简单解码器（SimpleDecoder）**

*  **总述**

本节我们讲述kaldi中一个最简单的解码器，实现这个解码器的类是SimpleDecoder，理解了这个解码器，也就打下了解码搜索的基础，其他的解码器方法也与其类似，目录在kaldi/src/decoder/simple-decoder.h。解码图数据结构依赖于openfst，基本上可以通过名称猜到表达的含义。

*  **分析**

上一节已经知道，解码的过程就是在解码图中搜索最优路径的过程，解码图的构建也在上一节做了简单的介绍，它就是语言模型、词典、上下文音素和HMM构成的一个大的资源图。关于具体如何去做以后我们结合脚本再进行细讲。

我们知道，WFST解码图中，信息都在边上、节点上没有信息（终止节点除外），边上输入表示建模单元、输出表示词、权重表示概率（语言模型概率+转移概率+词典发音概率）。

在解码前，需要先加载解码图，设定剪枝系数beam，传进解码器中，调用构造函数

SimpleDecoder(const fst::Fst<fst::StdArc> &fst, BaseFloat beam): fst\_(fst), beam\_(beam) \{ \}

bool Decode(DecodableInterface \*decodable);解码一整句话。

函数bool ReachedFinal() const;表示是否有节点到达终止节点。

函数bool GetBestPath(Lattice \*fst\_out, bool use\_final\_probs = true) const;获取最后输出路径。

函数BaseFloat FinalRelativeCost() const;会返回全局最优路径和到达终止节点的最优路径的差值。

函数void InitDecoding();初始化解码器，一句新的语音开始，要初始化解码器。

函数void AdvanceDecoding(DecodableInterface \*decodable,int32 max\_num\_frames = -1);解码一段语音数据。

函数int32 NumFramesDecoded() const \{ return num\_frames\_decoded\_; \}返回已经解码的帧数。

类class Token；在解码过程中挂载在某个状态上的令牌，保存当前解码信息。

函数void ProcessEmitting(DecodableInterface \*decodable);每帧调用，扩展实边（ilabel!=0）。

函数void ProcessNonemitting();每帧调用，扩展空边（ilabel==0）。

成员变量unordered\_map<StateId, Token\*> cur\_toks\_;当前帧活跃的节点和对应的令牌。

成员变量unordered\_map<StateId, Token\*> prev\_toks\_;上一帧活跃的节点和对应的令牌。

成员变量const fst::Fst<fst::StdArc> &fst\_;解码图

成员变量BaseFloat beam\_;剪枝系数

函数static void ClearToks(unordered\_map<StateId, Token\*> &toks);清空令牌。

函数static void PruneToks(BaseFloat beam, unordered\_map<StateId, Token\*> \*toks);剪枝

**下面解析几个主要的方法：**

先来看一个整的解码过程

bool SimpleDecoder::Decode(DecodableInterface *decodable) {
    
      //初始化解码器
    
      InitDecoding();
    
      //帧同步解码，循环次数为帧数
    
      while( !decodable->IsLastFrame(num_frames_decoded_ - 1)) {
    
        //清空上一帧，把当前帧不依赖的历史token清空
    
    ClearToks(prev_toks_);
    
    //当前帧作为上一帧
    
    cur_toks_.swap(prev_toks_);
    
    //根据上一帧的结果扩展当前帧
    
    ProcessEmitting(decodable);
    
    //扩展当前帧的空边（由词典的消岐符和语言模型回退概率产生）
    
    ProcessNonemitting();
    
    //对当前帧的令牌进行剪枝（为了加速）
    
        PruneToks(beam_, &cur_toks_);
    
      }
    
      return (!cur_toks_.empty());
    
    }
    
    
    
    解码器初始化
    
    void SimpleDecoder::InitDecoding() {
    
      // clean up from last time:
    
      //清空所有的令牌（注意先清空当前令牌，再清空之前令牌，这样可完全清空所有令牌）
    
      ClearToks(cur_toks_);
    
      ClearToks(prev_toks_);
    
      // initialize decoding:
    
      //获取FST开始节点
    
      StateId start_state = fst_.Start();
    
      KALDI_ASSERT(start_state != fst::kNoStateId);
    
      //产生一个令牌
    
      StdArc dummy_arc(0, 0, StdWeight::One(), start_state);
    
      cur_toks_[start_state] = new Token(dummy_arc, 0.0, NULL);
    
      //当前已解码帧数清零。
    
      num_frames_decoded_ = 0;
    
      //扩展一次空边，把所有从开始节点的通过空边可到达的节点和边进行扩展，信息保留在令牌中。
    
      ProcessNonemitting();
    
    }
    
    
    
    支持流式解码，和Decode相似。
    
    void SimpleDecoder::AdvanceDecoding(DecodableInterface *decodable,
    
                                          int32 max_num_frames) {
    
      KALDI_ASSERT(num_frames_decoded_ >= 0 &&
    
                   "You must call InitDecoding() before AdvanceDecoding()");
    
      int32 num_frames_ready = decodable->NumFramesReady();
    
      // num_frames_ready must be >= num_frames_decoded, or else
    
      // the number of frames ready must have decreased (which doesn't
    
      // make sense) or the decodable object changed between calls
    
      // (which isn't allowed).
    
      KALDI_ASSERT(num_frames_ready >= num_frames_decoded_);
    
      int32 target_frames_decoded = num_frames_ready;
    
      if (max_num_frames >= 0)
    
        target_frames_decoded = std::min(target_frames_decoded,
    
                                         num_frames_decoded_ + max_num_frames);
    
      //除了少了初始化操作，其他和Decode一样
    
      while (num_frames_decoded_ < target_frames_decoded) {
    
        // note: ProcessEmitting() increments num_frames_decoded_
    
        ClearToks(prev_toks_);
    
        cur_toks_.swap(prev_toks_);
    
        ProcessEmitting(decodable);
    
        ProcessNonemitting();
    
        PruneToks(beam_, &cur_toks_);
    
      }
    
    }
    
    
    
    实边扩展
    
    void SimpleDecoder::ProcessEmitting(DecodableInterface *decodable) {
    
      int32 frame = num_frames_decoded_;
    
      // Processes emitting arcs for one frame.  Propagates from
    
      // prev_toks_ to cur_toks_.
    
      //设置开始剪枝系数为无限大
    
      double cutoff = std::numeric_limits<BaseFloat>::infinity();
    
      //遍历上一帧所有活跃节点
    
      for (unordered_map<StateId, Token*>::iterator iter = prev_toks_.begin();
    
           iter != prev_toks_.end();
    
           ++iter) {
    
        //拿到一个活跃节点和令牌
    
        StateId state = iter->first;
    
        Token *tok = iter->second;
    
    KALDI_ASSERT(state == tok->arc_.nextstate);
    
    //遍历活跃节点的后续边
    
        for (fst::ArcIterator<fst::Fst<StdArc> > aiter(fst_, state);
    
             !aiter.Done();
    
             aiter.Next()) {
    
          const StdArc &arc = aiter.Value();
    
          //只扩展实边
    
          if (arc.ilabel != 0) {  // propagate..
    
            BaseFloat acoustic_cost = -decodable->LogLikelihood(frame, arc.ilabel);
    
            double total_cost = tok->cost_ + arc.weight.Value() + acoustic_cost;
    
            //当前累计代价太大的边剪掉
    
            if (total_cost > cutoff) continue;
    
            //更新剪枝系数
    
            if (total_cost + beam_  < cutoff)
    
              cutoff = total_cost + beam_;
    
            //当前边的目的节点挂载令牌
    
            Token *new_tok = new Token(arc, acoustic_cost, tok);
    
            unordered_map<StateId, Token*>::iterator find_iter
    
                = cur_toks_.find(arc.nextstate);
    
            //如果目标节点上没有令牌，则挂上
    
            if (find_iter == cur_toks_.end()) {
    
              cur_toks_[arc.nextstate] = new_tok;
    
            } else {
    
    //目标节点有令牌，判断保留哪个令牌，如果新令牌比较强则把老的令牌删掉，把新的挂上，否则把新的删掉
    
              if ( *(find_iter->second) < *new_tok ) {
    
                Token::TokenDelete(find_iter->second);
    
                find_iter->second = new_tok;
    
              } else {
    
                Token::TokenDelete(new_tok);
    
              }
    
            }
    
          }
    
        }
    
      }
    
      //扩展一帧，帧数加1
    
      num_frames_decoded_++;
    
    }
    
    
    
    空边扩展
    
    void SimpleDecoder::ProcessNonemitting() {
    
      // Processes nonemitting arcs for one frame.  Propagates within
    
      // cur_toks_.
    
      std::vector<StateId> queue_;
    
      double infinity = std::numeric_limits<double>::infinity();
    
      double best_cost = infinity;
    
      //查看当前有哪些节点是活跃的，放入队列中，一会遍历它的空边
    
      for (unordered_map<StateId, Token*>::iterator iter = cur_toks_.begin();
    
           iter != cur_toks_.end();
    
           ++iter) {
    
        queue_.push_back(iter->first);
    
        best_cost = std::min(best_cost, iter->second->cost_);
    
      }
    
      double cutoff = best_cost + beam_;
    
      //遍历队列中每一个活跃的节点
    
      while (!queue_.empty()) {
    
        StateId state = queue_.back();
    
        queue_.pop_back();
    
        Token *tok = cur_toks_[state];
    
    KALDI_ASSERT(tok != NULL && state == tok->arc_.nextstate);
    
    //每一个节点遍历后续空边
    
        for (fst::ArcIterator<fst::Fst<StdArc> > aiter(fst_, state);
    
             !aiter.Done();
    
             aiter.Next()) {
    
          const StdArc &arc = aiter.Value();
    
          //只考虑空边
    
          if (arc.ilabel == 0) {  // propagate nonemitting only...
    
            const BaseFloat acoustic_cost = 0.0;
    
            Token *new_tok = new Token(arc, acoustic_cost, tok);
    
            //剪枝
    
            if (new_tok->cost_ > cutoff) {
    
              Token::TokenDelete(new_tok);
    
            } else {
    
              unordered_map<StateId, Token*>::iterator find_iter
    
                  = cur_toks_.find(arc.nextstate);
    
              //一个节点仅挂载一个令牌，保留最优令牌
    
              if (find_iter == cur_toks_.end()) {
    
                cur_toks_[arc.nextstate] = new_tok;
    
    //加入队列，继续扩展
    
                queue_.push_back(arc.nextstate);
    
              } else {
    
                if ( *(find_iter->second) < *new_tok ) {
    
                  Token::TokenDelete(find_iter->second);
    
                  find_iter->second = new_tok;
    
                  //加入队列，继续扩展
    
                  queue_.push_back(arc.nextstate);
    
                } else {
    
                  Token::TokenDelete(new_tok);
    
                }
    
              }
    
            }
    
          }
    
        }
    
      }
    
    }

*  **总结**

本文解析了kaldi简单解码器中几个主要的解码方法，如有不当，敬请谅解。