读取segemet的asr推理

[wwfcnu]

``

inference_pipeline = pipeline(
    task=Tasks.auto_speech_recognition,
    model='damo/speech_paraformer-large_asr_nat-zh-cn-16k-common-vocab8404-pytorch')

#segments_result = inference_pipeline_vad(audio_in=waveform)
#print(segments_result["text"])
wav_scp_path = {}
with open("wav.scp")as f1:
     for line in f1:
        wav_id,wav_path = line.strip().split(" ",1)
        wav_scp_path[wav_id] = wav_path



data = []
with open('segments', 'r') as f:
    for line in f:
        line = line.strip().split()
        data.append([line[0],line[1],float(line[2]), float(line[3])])

#print(data)
with open("output.txt","w")as fw:
    for i, segments in enumerate(data):
        
            waveform, sample_rate = soundfile.read(wav_scp_path.get(segments[1]))
            beg_idx = segments[2] * sample_rate
            end_idx = segments[3] * sample_rate
            wav_segment_id = segments[0]
            waveform_slice = waveform[int(beg_idx):int(end_idx)]
            result_segments = inference_pipeline(audio_in=waveform_slice)
            print(result_segments)
            hypothesis = result_segments["text"]
            fw.write(f'{wav_segment_id} {hypothesis}\n')
            fw.flush()

``
想问一下inference_pipeline(audio_in=waveform_slice)支持批次处理吗

[wwfcnu]

输入的语音必须是单通道的吗

[Simon-chai]

哥们，关于支持批次处理的问题，你找到答案了吗？我尝试了自己vad切割音频成数组分段丢给模型预测，效率慢了一个数量级，识别效果也差了

[LauraGPT]

可以。现在建议从旧的 ModelScope pipeline 迁移到 FunASR AutoModel：generate(input=...) 可以直接接收 list[np.ndarray]，batch_size 控制一次模型推理包含多少条切片。当前实现会按输入顺序返回结果，因此可以再与 segment ID 对齐。接口说明 批处理实现

下面是对 wav.scp + segments 的完整写法。它还避免了原代码在每个 segment 上重复读取同一录音：

from functools import lru_cache

import numpy as np
import soundfile as sf
from scipy.signal import resample_poly
from funasr import AutoModel

TARGET_SR = 16000
BATCH_SIZE = 8  # 按显存和切片长度调整


def read_wav_scp(path):
    recordings = {}
    with open(path, encoding="utf-8") as f:
        for line in f:
            recording_id, audio_path = line.rstrip().split(maxsplit=1)
            recordings[recording_id] = audio_path
    return recordings


@lru_cache(maxsize=8)
def load_mono(audio_path):
    # soundfile 的二维布局是 [samples, channels]
    audio, sample_rate = sf.read(
        audio_path, dtype="float32", always_2d=True
    )
    return audio.mean(axis=1, dtype=np.float32), sample_rate


def recognize_batch(model, batch, output):
    segment_ids = [item[0] for item in batch]
    waveforms = [item[1] for item in batch]
    results = model.generate(
        input=waveforms,
        batch_size=len(waveforms),
        fs=TARGET_SR,
    )
    if len(results) != len(batch):
        raise RuntimeError(f"Expected {len(batch)} results, got {len(results)}")
    for segment_id, result in zip(segment_ids, results):
        output.write(f"{segment_id} {result['text']}\n")


recordings = read_wav_scp("wav.scp")
model = AutoModel(
    model="paraformer-zh",
    hub="hf",                 # 使用 ModelScope 时可删除本行
    model_revision="main",    # 使用 ModelScope 时可删除本行
    device="cuda:0",
    disable_update=True,
    disable_pbar=True,
)

batch = []
with open("segments", encoding="utf-8") as segments, open(
    "output.txt", "w", encoding="utf-8"
) as output:
    for line_number, line in enumerate(segments, start=1):
        segment_id, recording_id, begin_text, end_text = line.split()
        audio, source_sr = load_mono(recordings[recording_id])

        # segment 时间属于原始采样率，所以先切片，再重采样。
        begin = max(0, round(float(begin_text) * source_sr))
        end = min(len(audio), round(float(end_text) * source_sr))
        if end <= begin:
            raise ValueError(f"Invalid segment at line {line_number}: {line.rstrip()}")

        clip = audio[begin:end]
        if source_sr != TARGET_SR:
            clip = resample_poly(clip, TARGET_SR, source_sr)
        clip = np.ascontiguousarray(clip, dtype=np.float32)
        batch.append((segment_id, clip))

        if len(batch) == BATCH_SIZE:
            recognize_batch(model, batch, output)
            batch.clear()

    if batch:
        recognize_batch(model, batch, output)

单双通道结论

• 如果传入的是音频文件路径，当前加载器默认会把多通道取平均，因此不要求源文件预先是单通道。文件加载代码
• 如果传入的是 numpy.ndarray，尤其是 soundfile.read(..., always_2d=True) 得到的 [samples, channels]，应先显式转成一维 mono；数组加载路径不会自动做同样的下混。数组加载代码
• 一个批次只有一个 fs 参数。不同录音采样率不一致时，应像示例一样逐段重采样到 16 kHz 后再组 batch。

我在当前主分支 1d8080af、FunASR 1.3.14、paraformer-zh revision d7811ee3 和 H100 上做了实际验证：3 个不同切片在 batch_size=3 时只进入一次底层 inference，逐条推理则进入 3 次；两种方式的 3 条文本逐项完全一致。双声道文件路径与单声道文件输出相同；直接传 [samples, 2] 数组会失败；8 kHz 一维数组配合 fs=8000 可以正确重采样并得到相同文本。

如果 segments 只是为了处理长录音而自行做的 VAD，而不是业务必须保留的边界，更推荐直接给原始录音配置 vad_model="fsmn-vad"。FunASR 会在内部按切片长度排序并按总时长组 batch，此时调的是 batch_size_s。逐段单条调用会降低吞吐；手工 VAD 若切掉字头、字尾或上下文，还会降低识别效果。VAD 内部批处理