feat: add is_final support for streaming Paraformer

sherpa-onnx/c-api/c-api.cc

@@ -351,6 +351,11 @@ void SherpaOnnxOnlineStreamInputFinished(const SherpaOnnxOnlineStream *stream) {
   stream->impl->InputFinished();
 }
 
+void SherpaOnnxOnlineStreamSetFinalChunk(
+    const SherpaOnnxOnlineStream *stream) {
+  stream->impl->SetParaformerFinalChunk(true);
+}
+
 int32_t SherpaOnnxOnlineStreamIsEndpoint(
     const SherpaOnnxOnlineRecognizer *recognizer,
     const SherpaOnnxOnlineStream *stream) {

sherpa-onnx/c-api/c-api.h

@@ -380,6 +380,17 @@ SHERPA_ONNX_API void SherpaOnnxOnlineStreamReset(
 SHERPA_ONNX_API void SherpaOnnxOnlineStreamInputFinished(
     const SherpaOnnxOnlineStream *stream);
 
+/// Signal that the current chunk is the final chunk for streaming Paraformer.
+/// This enables:
+///   1. Short chunk acceptance (less than chunk_size frames)
+///   2. CIF tail token flush for residual accumulated alpha
+///
+/// Call this BEFORE the last InputFinished() + DecodeStream() cycle.
+///
+/// @param stream A pointer returned by SherpaOnnxCreateOnlineStream()
+SHERPA_ONNX_API void SherpaOnnxOnlineStreamSetFinalChunk(
+    const SherpaOnnxOnlineStream *stream);
+
 /// Return 1 if an endpoint has been detected.
 ///
 /// @param recognizer A pointer returned by SherpaOnnxCreateOnlineRecognizer()

sherpa-onnx/c-api/sherpa-onnx-symbols-c.exp

@@ -111,6 +111,7 @@ _SherpaOnnxOnlinePunctuationAddPunct
 _SherpaOnnxOnlinePunctuationFreeText
 _SherpaOnnxOnlineStreamAcceptWaveform
 _SherpaOnnxOnlineStreamInputFinished
+_SherpaOnnxOnlineStreamSetFinalChunk
 _SherpaOnnxOnlineStreamIsEndpoint
 _SherpaOnnxOnlineStreamReset
 _SherpaOnnxPrint

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

@@ -156,7 +156,15 @@ class OnlineRecognizerParaformerImpl : public OnlineRecognizerImpl {
   }
 
   bool IsReady(OnlineStream *s) const override {
-    return s->GetNumProcessedFrames() + chunk_size_ < s->NumFramesReady();
+    if (s->GetNumProcessedFrames() + chunk_size_ < s->NumFramesReady()) {
+      return true;
+    }
+    // is_final: accept short chunks (less than chunk_size_ frames)
+    if (s->IsParaformerFinalChunk() &&
+        s->GetNumProcessedFrames() < s->NumFramesReady()) {
+      return true;
+    }
+    return false;
   }
 
   void DecodeStreams(OnlineStream **ss, int32_t n) const override {
@@ -212,8 +220,30 @@ class OnlineRecognizerParaformerImpl : public OnlineRecognizerImpl {
  private:
   void DecodeStream(OnlineStream *s) const {
     const auto num_processed_frames = s->GetNumProcessedFrames();
-    std::vector<float> frames = s->GetFrames(num_processed_frames, chunk_size_);
-    s->GetNumProcessedFrames() += chunk_size_ - 1;
+
+    // is_final: accept short chunks, pad with zeros if needed
+    int32_t available_frames = s->NumFramesReady() - num_processed_frames;
+    int32_t actual_chunk_size = chunk_size_;
+    if (s->IsParaformerFinalChunk() && available_frames < chunk_size_) {
+      actual_chunk_size = available_frames;
+    }
+
+    std::vector<float> frames =
+        s->GetFrames(num_processed_frames, actual_chunk_size);
+
+    // Pad to chunk_size_ if short chunk
+    if (actual_chunk_size < chunk_size_) {
+      int32_t feat_dim_raw = config_.feat_config.feature_dim;
+      frames.resize(chunk_size_ * feat_dim_raw, 0.0f);
+    }
+
+    // For non-final chunks the original code uses chunk_size_ - 1 to create
+    // 1-frame overlap.  For the final short chunk we consume all frames.
+    if (s->IsParaformerFinalChunk()) {
+      s->GetNumProcessedFrames() += actual_chunk_size;
+    } else {
+      s->GetNumProcessedFrames() += chunk_size_ - 1;
+    }
 
     frames = ApplyLFR(frames);
     ApplyCMVN(&frames);
@@ -315,6 +345,16 @@ class OnlineRecognizerParaformerImpl : public OnlineRecognizerImpl {
 
     alpha_cache[0] = integrate;
 
+    // is_final: tail flush — force-fire residual token if integrate is
+    // high enough (token was mostly accumulated, just shy of threshold).
+    if (s->IsParaformerFinalChunk() && integrate >= kCifTailFlushMinAlpha) {
+      acoustic_embedding.insert(acoustic_embedding.end(),
+                                initial_hidden.begin(), initial_hidden.end());
+      integrate = 0.0f;
+      std::fill(initial_hidden.begin(), initial_hidden.end(), 0.0f);
+      alpha_cache[0] = integrate;
+    }
+
     if (acoustic_embedding.empty()) {
       return;
     }
@@ -372,7 +412,8 @@ class OnlineRecognizerParaformerImpl : public OnlineRecognizerImpl {
 
     for (int32_t i = 0; i != num_tokens; ++i) {
       int32_t t = p_sample_ids[i];
-      if (t == 0) {
+      if (t == 0 || t == 1 || t == 2) {
+        // skip blank(0), sos(1), eos(2)
         continue;
       }
 
@@ -469,6 +510,11 @@ class OnlineRecognizerParaformerImpl : public OnlineRecognizerImpl {
 
   int32_t left_chunk_size_ = 5;
   int32_t right_chunk_size_ = 3;
+
+  // Minimum CIF residual alpha to force-fire a tail token on final chunk.
+  // Empirically tuned: below 0.6 causes hallucinated extra tokens;
+  // above 0.6 misses legitimate partial tokens.
+  static constexpr float kCifTailFlushMinAlpha = 0.6f;
 };
 
 }  // namespace sherpa_onnx

sherpa-onnx/csrc/online-stream.cc

@@ -48,6 +48,7 @@ class OnlineStream::Impl {
     // we don't reset the feature extractor
     start_frame_index_ += num_processed_frames_;
     num_processed_frames_ = 0;
+    paraformer_is_final_ = false;
   }
 
   int32_t &GetNumProcessedFrames() {
@@ -128,6 +129,14 @@ class OnlineStream::Impl {
     return paraformer_alpha_cache_;
   }
 
+  void SetParaformerFinalChunk(bool is_final) {
+    paraformer_is_final_ = is_final;
+  }
+
+  bool IsParaformerFinalChunk() const {
+    return paraformer_is_final_;
+  }
+
   void SetFasterDecoder(std::unique_ptr<kaldi_decoder::FasterDecoder> decoder) {
     faster_decoder_ = std::move(decoder);
   }
@@ -159,6 +168,7 @@ class OnlineStream::Impl {
   std::vector<float> paraformer_encoder_out_cache_;
   std::vector<float> paraformer_alpha_cache_;
   OnlineParaformerDecoderResult paraformer_result_;
+  bool paraformer_is_final_ = false;
   std::unique_ptr<kaldi_decoder::FasterDecoder> faster_decoder_;
   int32_t faster_decoder_processed_frames_ = 0;
 };
@@ -282,4 +292,12 @@ std::vector<float> &OnlineStream::GetParaformerAlphaCache() {
   return impl_->GetParaformerAlphaCache();
 }
 
+void OnlineStream::SetParaformerFinalChunk(bool is_final) {
+  impl_->SetParaformerFinalChunk(is_final);
+}
+
+bool OnlineStream::IsParaformerFinalChunk() const {
+  return impl_->IsParaformerFinalChunk();
+}
+
 }  // namespace sherpa_onnx

sherpa-onnx/csrc/online-stream.h

@@ -111,6 +111,10 @@ class OnlineStream {
   std::vector<float> &GetParaformerEncoderOutCache();
   std::vector<float> &GetParaformerAlphaCache();
 
+  // for streaming paraformer is_final support
+  void SetParaformerFinalChunk(bool is_final);
+  bool IsParaformerFinalChunk() const;
+
  private:
   class Impl;
   std::unique_ptr<Impl> impl_;

sherpa-onnx/python/csrc/online-stream.cc

@@ -52,6 +52,9 @@ void PybindOnlineStream(py::module *m) {
           py::call_guard<py::gil_scoped_release>())
       .def("input_finished", &PyClass::InputFinished,
            py::call_guard<py::gil_scoped_release>())
+      .def("set_paraformer_final_chunk", &PyClass::SetParaformerFinalChunk,
+           py::arg("is_final") = true,
+           py::call_guard<py::gil_scoped_release>())
       .def("get_frames", &PyClass::GetFrames,
            py::arg("frame_index"), py::arg("n"), kGetFramesUsage,
            py::call_guard<py::gil_scoped_release>());