Small fix to online recongizer C++ code. (k2-fsa#3297)

Author: csukuangfj

sherpa-onnx/csrc/online-ebranchformer-transducer-model.cc

@@ -66,8 +66,8 @@ OnlineEbranchformerTransducerModel::OnlineEbranchformerTransducerModel(
     : env_(ORT_LOGGING_LEVEL_ERROR),
       config_(config),
       encoder_sess_opts_(GetSessionOptions(config)),
-      decoder_sess_opts_(GetSessionOptions(config)),
-      joiner_sess_opts_(GetSessionOptions(config)),
+      decoder_sess_opts_(GetSessionOptions(config, "decoder")),
+      joiner_sess_opts_(GetSessionOptions(config, "joiner")),
       allocator_{} {
   {
     auto buf = ReadFile(mgr, config.transducer.encoder);

sherpa-onnx/csrc/online-model-config.cc

@@ -134,6 +134,10 @@ bool OnlineModelConfig::Validate() const {
     }
   }
 
+  if (!provider_config.Validate()) {
+    return false;
+  }
+
   if (!paraformer.encoder.empty()) {
     return paraformer.Validate();
   }
@@ -154,10 +158,6 @@ bool OnlineModelConfig::Validate() const {
     return t_one_ctc.Validate();
   }
 
-  if (!provider_config.Validate()) {
-    return false;
-  }
-
   return transducer.Validate();
 }
 

sherpa-onnx/csrc/online-recognizer-ctc-impl.h

@@ -26,7 +26,7 @@
 
 namespace sherpa_onnx {
 
-OnlineRecognizerResult ConvertCtc(const OnlineCtcDecoderResult &src,
+static OnlineRecognizerResult ConvertCtc(const OnlineCtcDecoderResult &src,
                                   const SymbolTable &sym_table,
                                   float frame_shift_ms,
                                   int32_t subsampling_factor, int32_t segment,
@@ -79,8 +79,12 @@ class OnlineRecognizerCtcImpl : public OnlineRecognizerImpl {
       : OnlineRecognizerImpl(config),
         config_(config),
         model_(OnlineCtcModel::Create(config.model_config)),
-        sym_(config.model_config.tokens),
         endpoint_(config_.endpoint_config) {
+    if (!config.model_config.tokens_buf.empty()) {
+      sym_ = SymbolTable(config.model_config.tokens_buf, false);
+    } else {
+      sym_ = SymbolTable(config.model_config.tokens, true);
+    }
     PostInit();
   }
 
@@ -90,8 +94,12 @@ class OnlineRecognizerCtcImpl : public OnlineRecognizerImpl {
       : OnlineRecognizerImpl(mgr, config),
         config_(config),
         model_(OnlineCtcModel::Create(mgr, config.model_config)),
-        sym_(mgr, config.model_config.tokens),
         endpoint_(config_.endpoint_config) {
+    if (!config.model_config.tokens_buf.empty()) {
+      sym_ = SymbolTable(config.model_config.tokens_buf, false);
+    } else {
+      sym_ = SymbolTable(mgr, config.model_config.tokens);
+    }
     PostInit();
   }
 
@@ -209,11 +217,15 @@ class OnlineRecognizerCtcImpl : public OnlineRecognizerImpl {
 
     int32_t num_processed_frames = s->GetNumProcessedFrames();
 
-    // frame shift is 10 milliseconds
     float frame_shift_in_seconds = 0.01;
+    int32_t subsampling_factor = 4;
+    if (!config_.model_config.t_one_ctc.model.empty()) {
+      frame_shift_in_seconds = 0.03;
+      subsampling_factor = 1;
+    }
 
-    // subsampling factor is 4
-    int32_t trailing_silence_frames = s->GetCtcResult().num_trailing_blanks * 4;
+    int32_t trailing_silence_frames =
+        s->GetCtcResult().num_trailing_blanks * subsampling_factor;
 
     return endpoint_.IsEndpoint(num_processed_frames, trailing_silence_frames,
                                 frame_shift_in_seconds);
@@ -242,11 +254,6 @@ class OnlineRecognizerCtcImpl : public OnlineRecognizerImpl {
 
  private:
   void PostInit() {
-    if (!config_.model_config.tokens_buf.empty()) {
-      /// assuming tokens_buf and tokens are guaranteed not being both empty
-      sym_ = SymbolTable(config_.model_config.tokens_buf, false);
-    }
-
     if (!config_.model_config.wenet_ctc.model.empty()) {
       // WeNet CTC models assume input samples are in the range
       // [-32768, 32767], so we set normalize_samples to false

sherpa-onnx/csrc/online-recognizer-impl.cc

@@ -92,6 +92,7 @@ std::unique_ptr<OnlineRecognizerImpl> OnlineRecognizerImpl::Create(
 
   SHERPA_ONNX_LOGE("Please specify a model");
   SHERPA_ONNX_EXIT(-1);
+  return nullptr;
 }
 
 template <typename Manager>
@@ -152,6 +153,7 @@ std::unique_ptr<OnlineRecognizerImpl> OnlineRecognizerImpl::Create(
 
   SHERPA_ONNX_LOGE("Please specify a model");
   SHERPA_ONNX_EXIT(-1);
+  return nullptr;
 }
 
 OnlineRecognizerImpl::OnlineRecognizerImpl(const OnlineRecognizerConfig &config)

sherpa-onnx/csrc/online-recognizer-paraformer-impl.h

@@ -127,8 +127,12 @@ class OnlineRecognizerParaformerImpl : public OnlineRecognizerImpl {
       : OnlineRecognizerImpl(mgr, config),
         config_(config),
         model_(mgr, config.model_config),
-        sym_(mgr, config.model_config.tokens),
         endpoint_(config_.endpoint_config) {
+    if (!config.model_config.tokens_buf.empty()) {
+      sym_ = SymbolTable(config.model_config.tokens_buf, false);
+    } else {
+      sym_ = SymbolTable(mgr, config.model_config.tokens);
+    }
     if (config.decoding_method != "greedy_search") {
       SHERPA_ONNX_LOGE("Unsupported decoding method: %s",
                        config.decoding_method.c_str());
@@ -195,8 +199,14 @@ class OnlineRecognizerParaformerImpl : public OnlineRecognizerImpl {
   }
 
   void Reset(OnlineStream *s) const override {
-    OnlineParaformerDecoderResult r;
-    s->SetParaformerResult(r);
+    // segment is incremented only when the last result is not empty
+    const auto &r = s->GetParaformerResult();
+    if (!r.tokens.empty()) {
+      s->GetCurrentSegment() += 1;
+    }
+
+    OnlineParaformerDecoderResult empty;
+    s->SetParaformerResult(empty);
 
     s->GetStates().clear();
     s->GetParaformerEncoderOutCache().clear();

sherpa-onnx/csrc/online-recognizer-transducer-impl.h

@@ -168,7 +168,9 @@ class OnlineRecognizerTransducerImpl : public OnlineRecognizerImpl {
         bpe_encoder_ = std::make_unique<ssentencepiece::Ssentencepiece>(iss);
       }
 
-      if (!config_.hotwords_file.empty()) {
+      if (!config_.hotwords_buf.empty()) {
+        InitHotwordsFromBufStr();
+      } else if (!config_.hotwords_file.empty()) {
         InitHotwords(mgr);
       }
 
@@ -252,8 +254,7 @@ class OnlineRecognizerTransducerImpl : public OnlineRecognizerImpl {
       return;
     }
     int32_t chunk_size = model_->ChunkSize();
-    int32_t chunk_shift = model_->ChunkShift();
-    int32_t feature_dim = 80;
+    int32_t feature_dim = config_.feat_config.feature_dim;
     std::vector<OnlineTransducerDecoderResult> results(max_batch_size);
     std::vector<float> features_vec(max_batch_size * chunk_size * feature_dim);
     std::vector<std::vector<Ort::Value>> states_vec(max_batch_size);

sherpa-onnx/csrc/online-recognizer-transducer-nemo-impl.h

@@ -65,10 +65,14 @@ class OnlineRecognizerTransducerNeMoImpl : public OnlineRecognizerImpl {
       Manager *mgr, const OnlineRecognizerConfig &config)
       : OnlineRecognizerImpl(mgr, config),
         config_(config),
-        symbol_table_(mgr, config.model_config.tokens),
         endpoint_(config_.endpoint_config),
         model_(std::make_unique<OnlineTransducerNeMoModel>(
             mgr, config.model_config)) {
+    if (!config.model_config.tokens_buf.empty()) {
+      symbol_table_ = SymbolTable(config.model_config.tokens_buf, false);
+    } else {
+      symbol_table_ = SymbolTable(mgr, config.model_config.tokens);
+    }
     if (config.decoding_method == "greedy_search") {
       decoder_ = std::make_unique<OnlineTransducerGreedySearchNeMoDecoder>(
           model_.get(), config_.blank_penalty);

sherpa-onnx/csrc/online-recognizer.cc

@@ -131,13 +131,15 @@ void OnlineRecognizerConfig::Register(ParseOptions *po) {
 }
 
 bool OnlineRecognizerConfig::Validate() const {
-  if (decoding_method == "modified_beam_search" && !lm_config.model.empty()) {
+  if (decoding_method == "modified_beam_search") {
     if (max_active_paths <= 0) {
-      SHERPA_ONNX_LOGE("max_active_paths is less than 0! Given: %d",
+      SHERPA_ONNX_LOGE("max_active_paths must be > 0. Given: %d",
                        max_active_paths);
       return false;
     }
+  }
 
+  if (decoding_method == "modified_beam_search" && !lm_config.model.empty()) {
     if (!lm_config.Validate()) {
       return false;
     }

sherpa-onnx/csrc/online-recognizer.h

@@ -132,7 +132,8 @@ struct OnlineRecognizerConfig {
       int32_t max_active_paths, const std::string &hotwords_file,
       float hotwords_score, float blank_penalty, float temperature_scale,
       const std::string &rule_fsts, const std::string &rule_fars,
-      bool reset_encoder, const HomophoneReplacerConfig &hr)
+      bool reset_encoder, const HomophoneReplacerConfig &hr,
+      const std::string &hotwords_buf = {})
       : feat_config(feat_config),
         model_config(model_config),
         lm_config(lm_config),
@@ -148,7 +149,8 @@ struct OnlineRecognizerConfig {
         rule_fsts(rule_fsts),
         rule_fars(rule_fars),
         reset_encoder(reset_encoder),
-        hr(hr) {}
+        hr(hr),
+        hotwords_buf(hotwords_buf) {}
 
   void Register(ParseOptions *po);
   bool Validate() const;

sherpa-onnx/csrc/online-wenet-ctc-model.cc

@@ -256,6 +256,7 @@ std::vector<Ort::Value> OnlineWenetCtcModel::StackStates(
   if (states.size() != 1) {
     SHERPA_ONNX_LOGE("wenet CTC model supports only batch_size==1. Given: %d",
                      static_cast<int32_t>(states.size()));
+    SHERPA_ONNX_EXIT(-1);
   }
 
   return std::move(states[0]);