Asr Streaming Conformer Librispeech

🚀 适用于LibriSpeech的Conformer模型

本仓库提供了在SpeechBrain中使用基于LibriSpeech（英文）预训练的端到端系统进行自动语音识别所需的所有工具。为获得更好的使用体验，建议您进一步了解 SpeechBrain。

🚀 快速开始

本仓库提供了在SpeechBrain中使用基于LibriSpeech（英文）预训练的端到端系统进行自动语音识别所需的所有工具。若想获得更好的使用体验，建议您进一步了解 SpeechBrain。

模型在全上下文模式（非流式）下的性能如下：

流式处理时，在测试集纯净数据上不同块大小的结果如下：

✨ 主要特性

• 本自动语音识别系统是一个使用RNN - T损失（带有辅助CTC损失以稳定训练）训练的Conformer模型，采用了一元分词器。
• 支持流式处理，利用了动态块训练技术，多头注意力模块使用了分块注意力，并采用了 动态块卷积 的实现。
• 模型在训练时支持不同的块大小（甚至全上下文），适用于各种块大小和离线转录。
• 系统使用采样率为16kHz（单声道）的录音进行训练，调用 transcribe_file 时，代码会根据需要自动对音频进行归一化处理（即重采样 + 单声道选择）。

📦 安装指南

首先，请使用以下命令安装SpeechBrain：

pip install speechbrain

建议您阅读我们的教程，进一步了解 SpeechBrain。

💻 使用示例

基础用法

对英文音频文件进行转录：

from speechbrain.inference.ASR import StreamingASR
from speechbrain.utils.dynamic_chunk_training import DynChunkTrainConfig
asr_model = StreamingASR.from_hparams(
    source="speechbrain/asr-streaming-conformer-librispeech",
    savedir="pretrained_models/asr-streaming-conformer-librispeech"
)
asr_model.transcribe_file(
    "speechbrain/asr-streaming-conformer-librispeech/test-en.wav",
    # 选择约960ms的块大小，左上下文为4个块
    DynChunkTrainConfig(24, 4),
    # 禁用torchaudio流式处理，以便从HuggingFace获取数据
    # 对于您自己的文件或流，将此设置为True以允许流式文件解码
    use_torchaudio_streaming=False,
)

DynChunkTrainConfig 的值可以根据延迟、计算能力和转录准确性进行调整。请参考流式WER表，选择适合您用例的值。

高级用法

命令行工具转录文件或实时流

使用ffmpeg从实时流解码（BBC Radio 4）：

python3 asr.py http://as-hls-ww-live.akamaized.net/pool_904/live/ww/bbc_radio_fourfm/bbc_radio_fourfm.isml/bbc_radio_fourfm-audio%3d96000.norewind.m3u8 --model-source=speechbrain/asr-streaming-conformer-librispeech --device=cpu -v

从文件解码：

python3 asr.py some-english-speech.wav --model-source=speechbrain/asr-streaming-conformer-librispeech --device=cpu -v

from argparse import ArgumentParser
import logging

parser = ArgumentParser()
parser.add_argument("audio_path")
parser.add_argument("--model-source", required=True)
parser.add_argument("--device", default="cpu")
parser.add_argument("--ip", default="127.0.0.1")
parser.add_argument("--port", default=9431)
parser.add_argument("--chunk-size", default=24, type=int)
parser.add_argument("--left-context-chunks", default=4, type=int)
parser.add_argument("--num-threads", default=None, type=int)
parser.add_argument("--verbose", "-v", default=False, action="store_true")
args = parser.parse_args()

if args.verbose:
    logging.getLogger().setLevel(logging.INFO)

logging.info("Loading libraries")

from speechbrain.inference.ASR import StreamingASR
from speechbrain.utils.dynamic_chunk_training import DynChunkTrainConfig
import torch

device = args.device

if args.num_threads is not None:
    torch.set_num_threads(args.num_threads)

logging.info(f"Loading model from \"{args.model_source}\" onto device {device}")

asr = StreamingASR.from_hparams(args.model_source, run_opts={"device": device})
config = DynChunkTrainConfig(args.chunk_size, args.left_context_chunks)

logging.info(f"Starting stream from URI \"{args.audio_path}\"")

for text_chunk in asr.transcribe_file_streaming(args.audio_path, config):
    print(text_chunk, flush=True, end="")

使用Gradio在浏览器中进行实时ASR解码

from argparse import ArgumentParser
from dataclasses import dataclass
import logging

parser = ArgumentParser()
parser.add_argument("--model-source", required=True)
parser.add_argument("--device", default="cpu")
parser.add_argument("--ip", default="127.0.0.1")
parser.add_argument("--port", default=9431)
parser.add_argument("--chunk-size", default=24, type=int)
parser.add_argument("--left-context-chunks", default=4, type=int)
parser.add_argument("--num-threads", default=None, type=int)
parser.add_argument("--verbose", "-v", default=False, action="store_true")
args = parser.parse_args()

if args.verbose:
    logging.getLogger().setLevel(logging.INFO)

logging.info("Loading libraries")

from speechbrain.inference.ASR import StreamingASR, ASRStreamingContext
from speechbrain.utils.dynamic_chunk_training import DynChunkTrainConfig
import torch
import gradio as gr
import torchaudio
import numpy as np

device = args.device

if args.num_threads is not None:
    torch.set_num_threads(args.num_threads)

logging.info(f"Loading model from \"{args.model_source}\" onto device {device}")

asr = StreamingASR.from_hparams(args.model_source, run_opts={"device": device})
config = DynChunkTrainConfig(args.chunk_size, args.left_context_chunks)

@dataclass
class GradioStreamingContext:
    context: ASRStreamingContext
    chunk_size: int
    waveform_buffer: torch.Tensor
    decoded_text: str

def transcribe(stream, new_chunk):
    sr, y = new_chunk

    y = y.astype(np.float32)
    y = torch.tensor(y, dtype=torch.float32, device=device)
    y /= max(1, torch.max(torch.abs(y)).item())  # norm by max abs() within chunk & avoid NaN
    if len(y.shape) > 1:
        y = torch.mean(y, dim=1)  # downmix to mono

    # HACK: we are making poor use of the resampler across chunk boundaries
    # which may degrade accuracy.
    # NOTE: we should also absolutely avoid recreating a resampler every time
    resampler = torchaudio.transforms.Resample(orig_freq=sr, new_freq=asr.audio_normalizer.sample_rate).to(device)
    y = resampler(y)  # janky resample (probably to 16kHz)


    if stream is None:
        stream = GradioStreamingContext(
            context=asr.make_streaming_context(config),
            chunk_size=asr.get_chunk_size_frames(config),
            waveform_buffer=y,
            decoded_text="",
        )
    else:
        stream.waveform_buffer = torch.concat((stream.waveform_buffer, y))

    while stream.waveform_buffer.size(0) > stream.chunk_size:
        chunk = stream.waveform_buffer[:stream.chunk_size]
        stream.waveform_buffer = stream.waveform_buffer[stream.chunk_size:]

        # fake batch dim
        chunk = chunk.unsqueeze(0)

        # list of transcribed strings, of size 1 because the batch size is 1
        with torch.no_grad():
            transcribed = asr.transcribe_chunk(stream.context, chunk)
        stream.decoded_text += transcribed[0]

    return stream, stream.decoded_text

# NOTE: latency seems relatively high, which may be due to this:
# https://github.com/gradio-app/gradio/issues/6526

demo = gr.Interface(
    transcribe,
    ["state", gr.Audio(sources=["microphone"], streaming=True)],
    ["state", "text"],
    live=True,
)

demo.launch(server_name=args.ip, server_port=args.port)

在GPU上进行推理

在调用 from_hparams 方法时，添加 run_opts={"device":"cuda"} 即可在GPU上进行推理。

批量并行推理

目前，高级转录接口不支持批量推理，但低级接口（如 encode_chunk）支持。我们希望未来能提供高效的批量推理功能。

📚 详细文档

训练步骤

该模型使用SpeechBrain（提交哈希：3f9e33a）进行训练。若要从头开始训练，请按以下步骤操作：

1. 克隆SpeechBrain仓库：

git clone https://github.com/speechbrain/speechbrain/

2. 安装SpeechBrain：

cd speechbrain
pip install -r requirements.txt
pip install -e .

3. 运行训练脚本：

cd recipes/LibriSpeech/ASR/transducer
python train.py hparams/conformer_transducer.yaml --data_folder=your_data_folder

更多详细信息，请参阅 配方目录。

局限性

SpeechBrain团队不保证该模型在其他数据集上的性能。

🔧 技术细节

本自动语音识别系统是一个Conformer模型，使用RNN - T损失（带有辅助CTC损失以稳定训练）进行训练，采用一元分词器。架构细节可在 训练超参数文件 中查看。

流式支持利用了动态块训练技术。多头注意力模块使用分块注意力，并采用了 动态块卷积 的实现。模型在训练时支持不同的块大小（甚至全上下文），因此适用于各种块大小和离线转录。

系统使用采样率为16kHz（单声道）的录音进行训练，调用 transcribe_file 时，代码会根据需要自动对音频进行归一化处理（即重采样 + 单声道选择）。

📄 许可证

本项目采用Apache 2.0许可证。

模型信息表格

模型评估结果

引用

如果您在研究或业务中使用了SpeechBrain，请引用以下文献：

@misc{speechbrain,
  title={{SpeechBrain}: A General-Purpose Speech Toolkit},
  author={Mirco Ravanelli and Titouan Parcollet and Peter Plantinga and Aku Rouhe and Samuele Cornell and Loren Lugosch and Cem Subakan and Nauman Dawalatabad and Abdelwahab Heba and Jianyuan Zhong and Ju-Chieh Chou and Sung-Lin Yeh and Szu-Wei Fu and Chien-Feng Liao and Elena Rastorgueva and François Grondin and William Aris and Hwidong Na and Yan Gao and Renato De Mori and Yoshua Bengio},
  year={2021},
  eprint={2106.04624},
  archivePrefix={arXiv},
  primaryClass={eess.AS},
  note={arXiv:2106.04624}
}

关于SpeechBrain

• 官网：https://speechbrain.github.io/
• 代码仓库：https://github.com/speechbrain/speechbrain/
• Hugging Face页面：https://huggingface.co/speechbrain/