给 CTC 强行加上时间输出

examples/asr/asr_cache_aware_streaming/speech_to_text_cache_aware_streaming_infer.py

@@ -115,7 +115,7 @@ from nemo.collections.asr.parts.submodules.rnnt_decoding import RNNTDecodingConf
 from nemo.collections.asr.parts.utils.manifest_utils import read_manifest
 from nemo.collections.asr.parts.utils.rnnt_utils import Hypothesis
 from nemo.collections.asr.parts.utils.streaming_utils import CacheAwareStreamingAudioBuffer
-from nemo.collections.asr.parts.utils.transcribe_utils import setup_model
+from nemo.collections.asr.parts.utils.transcribe_utils import setup_model, normalize_timestamp_output, process_timestamp_outputs
 from nemo.core.config import hydra_runner
 from nemo.utils import logging
 
@@ -173,9 +173,9 @@ class TranscriptionConfig:
     matmul_precision: str = "high"  # Literal["highest", "high", "medium"]
 
     # Decoding strategy for CTC models
-    ctc_decoding: CTCDecodingConfig = field(default_factory=CTCDecodingConfig)
+    ctc_decoding: CTCDecodingConfig = field(default_factory=lambda: CTCDecodingConfig(compute_timestamps=True))
     # Decoding strategy for RNNT models
-    rnnt_decoding: RNNTDecodingConfig = field(default_factory=lambda: RNNTDecodingConfig(fused_batch_size=-1))
+    rnnt_decoding: RNNTDecodingConfig = field(default_factory=lambda: RNNTDecodingConfig(fused_batch_size=-1, compute_timestamps=True))
     # Selects the decoder for Hybrid ASR models which has both the CTC and RNNT decoder.
     decoder_type: Optional[str] = None  # Literal["ctc", "rnnt"]
 
@@ -187,17 +187,26 @@ class TranscriptionConfig:
     debug_mode: bool = False  # Whether to print more detail in the output.
 
 
-def extract_transcriptions(hyps):
+def extract_transcriptions(hyps, return_timestamps=False):
     """
     The transcribed_texts returned by CTC and RNNT models are different.
     This method would extract and return the text section of the hypothesis.
     """
     if isinstance(hyps[0], Hypothesis):
         transcriptions = []
+        timestamps = []
         for hyp in hyps:
             transcriptions.append(hyp.text)
+            if hasattr(hyp, 'timestamp') and hyp.timestamp:
+                timestamps.append(hyp.timestamp)
+            else:
+                timestamps.append(None)
+        if return_timestamps:
+            return transcriptions, timestamps
     else:
         transcriptions = hyps
+        if return_timestamps:
+            return transcriptions, [None] * len(transcriptions)
     return transcriptions
 
 
@@ -272,13 +281,53 @@ def perform_streaming(
                     previous_hypotheses=previous_hypotheses,
                     previous_pred_out=pred_out_stream,
                     drop_extra_pre_encoded=calc_drop_extra_pre_encoded(asr_model, step_num, pad_and_drop_preencoded),
-                    return_transcription=True,
+                    return_transcription=False, # 关闭默认的简单文本解码
                 )
+                
+                # 显式使用带有 return_hypotheses=True 的完整解码
+                if hasattr(asr_model, 'ctc_decoder'):
+                    decoding = asr_model.ctc_decoding
+                else:
+                    decoding = asr_model.decoding
+                
+                transcribed_texts = []
+                for preds_idx, preds_concat in enumerate(pred_out_stream):
+                    encoded_len = torch.tensor([len(preds_concat)], device=preds_concat.device)
+                    decoded_out = decoding.ctc_decoder_predictions_tensor(
+                        decoder_outputs=preds_concat.unsqueeze(0),
+                        decoder_lengths=encoded_len,
+                        return_hypotheses=True,
+                    )
+                    # decoded_out is a list of list of Hypotheses or a list of Hypotheses depending on batch
+                    if isinstance(decoded_out[0], list):
+                        transcribed_texts.append(decoded_out[0][0])
+                    else:
+                        transcribed_texts.append(decoded_out[0])
 
         if debug_mode:
-            logging.info(f"Streaming transcriptions: {extract_transcriptions(transcribed_texts)}")
-
-    final_streaming_tran = extract_transcriptions(transcribed_texts)
+            current_texts = extract_transcriptions(transcribed_texts)
+            # 实时打印每个 chunk 的结果
+            print(f"\r[Streaming Step {step_num}] {current_texts[0]}", end='', flush=True)
+            # logging.info(f"Streaming transcriptions: {extract_transcriptions(transcribed_texts)}")
+
+    print() # 换行
+    final_streaming_tran, final_streaming_timestamps = extract_transcriptions(transcribed_texts, return_timestamps=True)
+    
+    # 获取模型的降采样率和帧移
+    if hasattr(asr_model.cfg, 'preprocessor'):
+        window_stride = asr_model.cfg.preprocessor.get('window_stride', 0.01)
+    else:
+        window_stride = 0.01
+        
+    subsampling_factor = 1
+    if hasattr(asr_model, 'encoder') and hasattr(asr_model.encoder, 'subsampling_factor'):
+        subsampling_factor = asr_model.encoder.subsampling_factor
+    elif hasattr(asr_model, 'encoder') and hasattr(asr_model.encoder, 'conv_subsampling_factor'):
+        subsampling_factor = asr_model.encoder.conv_subsampling_factor
+        
+    # 对结果进行时间戳转换
+    process_timestamp_outputs(transcribed_texts, subsampling_factor=subsampling_factor, window_stride=window_stride)
+    
     logging.info(f"Final streaming transcriptions: {final_streaming_tran}")
 
     if compare_vs_offline:
@@ -296,7 +345,7 @@ def perform_streaming(
                 f"The shape of the outputs of the model in streaming mode ({pred_out_stream_cat.size()}) is different from offline mode ({pred_out_offline_cat.size()})."
             )
 
-    return final_streaming_tran, final_offline_tran
+    return final_streaming_tran, final_offline_tran, final_streaming_timestamps
 
 
 @hydra_runner(config_name="TranscriptionConfig", schema=TranscriptionConfig)
@@ -373,6 +422,13 @@ def main(cfg: TranscriptionConfig):
                 asr_model.change_decoding_strategy(cfg.rnnt_decoding)
         else:
             asr_model.change_decoding_strategy(cfg.ctc_decoding)
+            
+        # 强制开启时间戳计算（针对某些模型可能未正确应用配置的情况）
+        if hasattr(asr_model.decoding, 'compute_timestamps'):
+            asr_model.decoding.compute_timestamps = True
+        if hasattr(asr_model.decoding, 'ctc_decoder') and hasattr(asr_model.decoding.ctc_decoder, 'compute_timestamps'):
+            asr_model.decoding.ctc_decoder.compute_timestamps = True
+            asr_model.decoding.ctc_decoder.return_hypotheses = True
 
     asr_model = asr_model.to(device=device, dtype=compute_dtype)
     asr_model.eval()
@@ -411,7 +467,7 @@ def main(cfg: TranscriptionConfig):
         if cfg.audio_file is not None:
             # stream a single audio file
             _ = streaming_buffer.append_audio_file(cfg.audio_file, stream_id=-1)
-            perform_streaming(
+            streaming_tran, offline_tran, streaming_timestamps = perform_streaming(
                 asr_model=asr_model,
                 streaming_buffer=streaming_buffer,
                 compute_dtype=compute_dtype,
@@ -419,12 +475,20 @@ def main(cfg: TranscriptionConfig):
                 debug_mode=cfg.debug_mode,
                 pad_and_drop_preencoded=cfg.pad_and_drop_preencoded,
             )
+            
+            # 打印单个文件的时间戳
+            if streaming_timestamps and streaming_timestamps[0]:
+                for key, val in streaming_timestamps[0].items():
+                    if key != 'timestep':
+                        logging.info(f"Timestamps {key}: {normalize_timestamp_output(val)}")
+            
             # return early for single file mode
             return
         else:
             # stream audio files in a manifest file in batched mode
             all_streaming_tran = []
             all_offline_tran = []
+            all_streaming_timestamps = []
             all_refs_text = []
             batch_size = cfg.batch_size
 
@@ -460,7 +524,7 @@ def main(cfg: TranscriptionConfig):
                     logging.info(
                         f"Starting to stream samples {sample_idx - len(streaming_buffer) + 1} to {sample_idx}..."
                     )
-                    streaming_tran, offline_tran = perform_streaming(
+                    streaming_tran, offline_tran, streaming_timestamps = perform_streaming(
                         asr_model=asr_model,
                         streaming_buffer=streaming_buffer,
                         compute_dtype=compute_dtype,
@@ -469,6 +533,7 @@ def main(cfg: TranscriptionConfig):
                         pad_and_drop_preencoded=cfg.pad_and_drop_preencoded,
                     )
                     all_streaming_tran.extend(streaming_tran)
+                    all_streaming_timestamps.extend(streaming_timestamps)
                     if cfg.compare_vs_offline:
                         all_offline_tran.extend(offline_tran)
                     streaming_buffer.reset_buffer()
@@ -489,14 +554,19 @@ def main(cfg: TranscriptionConfig):
 
             hyp_json = os.path.join(cfg.output_path, fname)
             os.makedirs(cfg.output_path, exist_ok=True)
-            with open(hyp_json, "w") as out_f:
+            with open(hyp_json, "w", encoding='utf-8') as out_f:
                 for i, hyp in enumerate(all_streaming_tran):
                     record = {
                         "pred_text": hyp,
                         "text": all_refs_text[i],
                         "wer": round(word_error_rate(hypotheses=[hyp], references=[all_refs_text[i]]) * 100, 2),
                     }
-                    out_f.write(json.dumps(record) + '\n')
+                    if all_streaming_timestamps[i]:
+                        for key, val in all_streaming_timestamps[i].items():
+                            if key != 'timestep':
+                                record[f'{key}'] = normalize_timestamp_output(val)
+                                
+                    out_f.write(json.dumps(record, ensure_ascii=False) + '\n')
 
 
 if __name__ == '__main__':

readme.txt

@@ -242,6 +242,60 @@ python examples/asr/asr_cache_aware_streaming/speech_to_text_cache_aware_streami
 
 
 
+
+它是不是真的流式输入，流式输出，为什么它是一下子打印全部结果，而不是边推理边输出部分结果 `examples\asr\asr_cache_aware_streaming\speech_to_text_cache_aware_streaming_infer.py` 
+   
+它**确实是真流式**的（前提是你用了支持 Cache-aware 的模型并搭配这个脚本）。
+
+它的运行机制是：
+1. `CacheAwareStreamingAudioBuffer` 将输入的音频切割成一个个非常小的片段（Chunk，例如每次 0.08 秒 或 0.16 秒）。
+2. 在 `perform_streaming` 函数中，有一个 `for step_num, (chunk_audio, chunk_lengths) in enumerate(streaming_buffer_iter):` 的循环。
+3. 它在每一次循环中，只把当前这个小 chunk 喂给模型 (`asr_model.conformer_stream_step`)，模型结合上一次循环保存的历史状态（Cache）吐出当前的识别结果。
+
+**那为什么它是一下子打印全部结果？**
+这是因为在原版脚本中，如果你不开启 `debug_mode=true`，它就不会在内部循环打印；即便是开启了 `debug_mode=true`，原版代码使用的 `logging.info()` 也是每一行单独打印，或者因为音频太短执行太快，让你产生了一次性输出的错觉。它主要被设计用来“批量验证流式模型的最终识别准确率”，所以更侧重于输出最终结果（`Final streaming transcriptions`）。
+
+### 我已经帮你修改了脚本
+为了让你有更直观的“边说边出字”的实时流式体验，我修改了 [speech_to_text_cache_aware_streaming_infer.py](file:///e:/huggingface_echodict/NeMo/examples/asr/asr_cache_aware_streaming/speech_to_text_cache_aware_streaming_infer.py) 中的打印逻辑。
+
+现在，只要你**确保参数中带有 `debug_mode=true`**，它就会在终端的同一行动态刷新当前已识别的文本（就像你在看语音输入法打字那样）：
+
+```python
+[Streaming Step 0] 
+[Streaming Step 1] 私
+[Streaming Step 2] 私はな
+...
+[Streaming Step 45] 私はなぜか答えられなかった。
+```
+你可以再次运行试试看这个“打字机”效果！
+
+
+
+这里的 timestep 是这样的，为什么不是时间 'timestep' =[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] `examples\asr\asr_cache_aware_streaming\speech_to_text_cache_aware_streaming_infer.py#L201-201` 
+          
+你看到的那一串数字并不是时间，而是**模型预测结果在特征序列上的索引（Frames / Timesteps）**。
+
+在 CTC 或者 RNNT 模型中：
+- 语音信号首先被切成一帧一帧的特征（比如每 10ms 一帧）。
+- 然后经过前端卷积网络进行降采样（比如 4倍 下采样），意味着进入模型的特征序列缩短为每 40ms 一个 timestep。
+- `timestep` 里记录的 `[0, 1, 2, ...]` 就是指网络在第 0 帧、第 1 帧、第 2 帧输出了对应的文字（token）。
+
+**要将它们转换为实际时间（秒），需要进行换算：**
+`时间 (秒) = timestep * window_stride (特征帧移，通常是 0.01秒) * subsampling_factor (模型降采样倍数，通常是 4)`
+
+### 我已经帮你加了换算代码
+我已经修改了 [speech_to_text_cache_aware_streaming_infer.py](file:///e:/huggingface_echodict/NeMo/examples/asr/asr_cache_aware_streaming/speech_to_text_cache_aware_streaming_infer.py) 脚本。
+
+我引入了 NeMo 内置的 `process_timestamp_outputs` 函数，并在推理结束后：
+1. 自动读取你模型的 `window_stride` 和 `subsampling_factor`。
+2. 调用函数将原本的 `start_offset` 和 `end_offset`（帧索引）换算为了具体的 `start` 和 `end` （实际物理时间，单位为秒）。
+
+你现在重新运行一下脚本，输出里的时间戳应该就会多出 `start` 和 `end` 字段，它们就是你想要的实际时间了！
+
+
+
+
+
 如果要训练一个 ASR 语音识别大模型，只用一条数据，它既是训练集，又是验证集，又是测试集。这样它正确率能正 100% 吗