feat(asr): REQ-265 前置 harness 流式档（序 2，端点参数注入面）

Author: Aparencia

app/src-tauri/src/bin/asr_eval.rs

@@ -22,35 +22,58 @@ use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 
 mod asr_eval_session;
+mod asr_eval_stream;
 
 use app_lib::audio_preprocess::{AudioPreprocessConfig, AudioPreprocessor};
 use app_lib::cer;
 use app_lib::eval_confusion::{profile, ConfusionAggregator};
 use app_lib::eval_report::{ab_verdict, cer_stats, is_regression, CerStats};
 use app_lib::eval_samples::{is_media_file, parse_srt, reference_text, srt_path_for};
+use asr_eval_stream::{transcribe_stream, StreamParams};
 use sherpa_onnx::{OfflineRecognizer, OfflineRecognizerConfig, OfflineSenseVoiceModelConfig};
 
 /// 默认 SenseVoice 模型目录（与 cer_bench/download 脚本约定一致）。
 const DEFAULT_MODEL_DIR: &str = "models/asr/sensevoice";
+/// 流式 zipformer 模型目录（与 streaming 下载脚本约定一致）。
+const STREAM_MODEL_DEFAULT: &str = "models/asr/streaming-zipformer-zh-fp16-2025-06-30";
 /// 基线回归容差（v0.20.0 契约：相对基线均值 CER 退化 >2% 即失败）。
 const REGRESSION_TOLERANCE: f32 = 0.02;
 
-/// A/B 路选择。
+/// A/B 路选择 + 流式档（序 2：stream 为附加被测路径）。
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Route {
     Off,
     On,
     Both,
+    Stream,
 }
 
 impl Route {
-    fn names(&self) -> Vec<&'static str> {
+    fn label(&self) -> &'static str {
         match self {
-            Route::Off => vec!["preproc_off"],
-            Route::On => vec!["preproc_on"],
-            Route::Both => vec!["preproc_off", "preproc_on"],
+            Route::Off => "preproc_off",
+            Route::On => "preproc_on",
+            Route::Both => unreachable!("Both 是组合态，不入单行标签"),
+            Route::Stream => "stream",
         }
     }
+
+    fn steps(preproc: Route, stream: bool) -> Vec<Route> {
+        let mut v = Vec::new();
+        match preproc {
+            Route::Off => v.push(Route::Off),
+            Route::On => v.push(Route::On),
+            Route::Both => {
+                v.push(Route::Off);
+                v.push(Route::On);
+            }
+            Route::Stream => {}
+        }
+        if stream {
+            v.push(Route::Stream);
+        }
+        v
+    }
 }
 
 #[derive(Debug)]
@@ -63,6 +86,10 @@ struct Options {
     baseline: Option<PathBuf>,
     update_baseline: bool,
     preproc: Route,
+    /// 流式档开关 + 模型目录 + 端点规则覆盖（REQ-265 参数注入面）。
+    stream: bool,
+    stream_model: String,
+    stream_params: StreamParams,
 }
 
 /// 单样本（文件对信道）。
@@ -116,16 +143,27 @@ fn main() -> ExitCode {
             continue;
         };
         let (sr, samples_f32) = (wave.sample_rate(), wave.samples());
-        for route in opts.preproc.names() {
-            let preproc_on = route == "preproc_on";
-            let text = transcribe(&recognizer, samples_f32, sr, preproc_on);
+        for route in Route::steps(opts.preproc, opts.stream) {
+            let text = match route {
+                Route::Off => transcribe(&recognizer, samples_f32, sr, false),
+                Route::On => transcribe(&recognizer, samples_f32, sr, true),
+                Route::Stream => {
+                    // 流式档自读音频（独立引擎），模型缺失 → None 提示后跳过该路
+                    match transcribe_stream(&s.wav.to_string_lossy(), &opts.stream_model, &opts.stream_params) {
+                        Some(t) => t,
+                        None => continue,
+                    }
+                }
+                Route::Both => unreachable!(),
+            };
+            let label = route.label();
             let c = cer::cer(&s.reference, &text);
-            rows.push((s.name.clone(), route.to_string(), c));
+            rows.push((s.name.clone(), label.to_string(), c));
             if let Some(v) = c {
-                cers.entry(route.to_string()).or_default().push(v);
+                cers.entry(label.to_string()).or_default().push(v);
             }
             portraits
-                .entry(route.to_string())
+                .entry(label.to_string())
                 .or_default()
                 .add(&profile(&s.reference, &text));
         }
@@ -141,7 +179,15 @@ fn main() -> ExitCode {
             None => out.push_str(&format!("{name}\t{route}\t-\n")),
         }
     }
-    for route in opts.preproc.names() {
+    // 汇总：按路统计（含 stream 档；Both 展开为两路后此处用单一路集合遍历）
+    let mut route_labels: Vec<&'static str> = Vec::new();
+    for r in Route::steps(opts.preproc, false) {
+        route_labels.push(r.label());
+    }
+    if opts.stream {
+        route_labels.push("stream");
+    }
+    for route in route_labels {
         let stats = cer_stats(cers.get(route).map(|v| v.as_slice()).unwrap_or(&[]));
         out.push_str(&format!(
             "\n[{}] 样本={} CER均值={} 范围={}~{}",
@@ -177,7 +223,7 @@ fn main() -> ExitCode {
     let _ = fs::write(opts.out_dir.join("summary.txt"), &out);
 
     // ── 基线回归门 ──
-    let primary = cers.get("preproc_off").map(|v| cer_stats(v)).flatten();
+    let primary = cers.get("preproc_off").and_then(|v| cer_stats(v));
     if let Some(bp) = &opts.baseline {
         let cur = primary.map(|s| s.mean);
         let base_mean = read_baseline_mean(bp);
@@ -273,6 +319,9 @@ fn parse_args() -> Option<Options> {
     let mut baseline = None;
     let mut update_baseline = false;
     let mut preproc = Route::Both;
+    let mut stream = false;
+    let mut stream_model = STREAM_MODEL_DEFAULT.to_string();
+    let mut stream_params = StreamParams::default();
     let mut it = args.iter();
     while let Some(a) = it.next() {
         match a.as_str() {
@@ -288,6 +337,11 @@ fn parse_args() -> Option<Options> {
                         .collect(),
                 );
             }
+            "--stream" => stream = true,
+            "--stream-model" => stream_model = it.next()?.clone(),
+            "--rule1-s" => stream_params.rule1_s = it.next()?.parse().ok()?,
+            "--rule2-s" => stream_params.rule2_s = it.next()?.parse().ok()?,
+            "--rule3-s" => stream_params.rule3_s = it.next()?.parse().ok()?,
             "--update-baseline" => update_baseline = true,
             "--preproc" => {
                 preproc = match it.next()?.as_str() {
@@ -313,6 +367,9 @@ fn parse_args() -> Option<Options> {
         baseline,
         update_baseline,
         preproc,
+        stream,
+        stream_model,
+        stream_params,
     })
 }
 

app/src-tauri/src/bin/asr_eval_stream.rs

@@ -0,0 +1,90 @@
+//! asr_eval 流式档（v0.20.1 / REQ-265 前置件，序 2；bin 子模块）。
+//!
+//! @ai-context: 目的——harness 增加"被测路径=流式链路"档：与生产
+//!              streaming_asr 同引擎（transducer zipformer 三件套）、同端点
+//!              规则（尾静音 rule1 2.4s/rule2 1.2s、rule3 强制断句可配）、
+//!              同块长（200ms@16k）、同解码（modified_beam_search）。
+//! @ai-context: **近似口径（诚实登记）**——本档为独立工具实现，不含生产的
+//!              能量自适应 VAD 静音隔块喂入/重打分/热词/标点恢复；A/B 结论
+//!              只对"本档语义"成立，与真链路的差距随后续档位逐步收窄。
+//! @ai-context: 模型缺失（streaming zipformer 未下载）→ None（跳过+提示），
+//!              不阻断离线档；模型路径与下载脚本约定一致（models/asr/…）。
+
+use std::path::Path;
+
+use sherpa_onnx::{OnlineRecognizer, OnlineRecognizerConfig};
+
+/// 流式档参数（规则覆盖点 = REQ-265 参数定案族的 VAD/端点族在 harness 的注入面）。
+#[derive(Debug, Clone, Copy)]
+pub struct StreamParams {
+    /// 端点 rule1：尾静音断句秒数（生产默认 2.4）。
+    pub rule1_s: f32,
+    /// 端点 rule2：尾静音短句断句秒数（生产默认 1.2）。
+    pub rule2_s: f32,
+    /// 端点 rule3：最长句强制断句秒数（生产默认 8，ADR-012 env 可覆盖）。
+    pub rule3_s: f32,
+}
+
+impl Default for StreamParams {
+    fn default() -> Self {
+        Self { rule1_s: 2.4, rule2_s: 1.2, rule3_s: 8.0 }
+    }
+}
+
+/// 音频块长：16kHz × 200ms（与生产链路同块长）。
+const BLOCK_SAMPLES: usize = 16_000 / 5;
+
+/// 流式转写整段音频（纯工具 IO）：返回逐句拼接文本；模型缺失/加载失败 → None。
+///
+/// @ai-context: 端点断句 = sherpa 判定（尾静音/最长句）——命中即取定稿并
+///              重建流（与生产 handle_endpoint 语义一致）；文件尾无端点段
+///              按生产 flush 语义取当前结果收尾。
+pub fn transcribe_stream(wav_path: &str, model_dir: &str, p: &StreamParams) -> Option<String> {
+    let dir = Path::new(model_dir);
+    let encoder = dir.join("encoder.onnx");
+    let decoder = dir.join("decoder.onnx");
+    let joiner = dir.join("joiner.onnx");
+    let tokens = dir.join("tokens.txt");
+    if ![&encoder, &decoder, &joiner, &tokens].iter().all(|f| f.exists()) {
+        eprintln!("[Stream] 流式模型缺失（{}）——本档跳过（下载脚本见 docs）", dir.display());
+        return None;
+    }
+    let wave = sherpa_onnx::Wave::read(wav_path)?;
+    let mut config = OnlineRecognizerConfig::default();
+    config.feat_config.sample_rate = 16_000;
+    config.feat_config.feature_dim = 80;
+    config.model_config.transducer.encoder = Some(encoder.to_string_lossy().into_owned());
+    config.model_config.transducer.decoder = Some(decoder.to_string_lossy().into_owned());
+    config.model_config.transducer.joiner = Some(joiner.to_string_lossy().into_owned());
+    config.model_config.tokens = Some(tokens.to_string_lossy().into_owned());
+    config.model_config.num_threads = 2;
+    config.decoding_method = Some("modified_beam_search".into());
+    config.enable_endpoint = true;
+    config.rule1_min_trailing_silence = p.rule1_s;
+    config.rule2_min_trailing_silence = p.rule2_s;
+    config.rule3_min_utterance_length = p.rule3_s;
+    let recognizer = OnlineRecognizer::create(&config)?;
+    let mut out = String::new();
+    let mut stream = recognizer.create_stream();
+    let samples = wave.samples();
+    let mut tail = String::new();
+    for block in samples.chunks(BLOCK_SAMPLES) {
+        stream.accept_waveform(16_000, block);
+        while recognizer.is_ready(&stream) {
+            recognizer.decode(&stream);
+        }
+        if recognizer.is_endpoint(&stream) {
+            if let Some(r) = recognizer.get_result(&stream) {
+                out.push_str(r.text.trim());
+                tail = String::new();
+            }
+            // 端点定稿后重建流（与生产 handle_endpoint 语义一致）
+            stream = recognizer.create_stream();
+        }
+    }
+    if let Some(r) = recognizer.get_result(&stream) {
+        tail = r.text.trim().to_string();
+    }
+    out.push_str(&tail);
+    Some(out)
+}

app/src-tauri/src/live_keyframes.rs

@@ -335,8 +335,8 @@ pub fn rewrite_with_fusion(
         crate::dtw_align::correct_drift_if_any(subtitles, asr_segments, MIN_FUSION_DTW_SEGS, MIN_APPLY_DRIFT_MS, MAX_APPLY_DRIFT_MS);
     if let Some(d) = correction.applied_ms {
         eprintln!("[Fusion] 会话 {} 字幕漂移校正 {:+}ms（{} 段）", session_id, d, subtitles.len());
-    } else if correction.measured_ms.is_some() {
-        eprintln!("[Fusion] 会话 {} 字幕漂移测量 {:+}ms 未采纳（带外或段数不足）", session_id, correction.measured_ms.unwrap());
+    } else if let Some(m) = correction.measured_ms {
+        eprintln!("[Fusion] 会话 {} 字幕漂移测量 {:+}ms 未采纳（带外或段数不足）", session_id, m);
     }
     let fused = merge_transcript(&correction.corrected, asr_segments, 0);
     if fused.is_empty() {