Open-source speech recognition toolkit for training, inference, streaming ASR, VAD, punctuation, speaker diarization pipelines, and OpenAI-compatible/MCP serving.
Python asraudiochineseemotion-recognitionfunasrmcp-servermultilingual-asropenai-compatible-apiparaformerpunctuationpytorchreal-time-asrspeaker-diarizationspeech-recognitionspeech-to-textstreaming-asrtranscriptionvllmvoice-activity-detectionwhisper-alternative
feat(vad): add Silero VAD adapter
wuhongsheng22920822a2ed
diff --git a/README_zh.md b/README_zh.mdindex f2916d422..de2b3d9b4 100644--- a/README_zh.md+++ b/README_zh.md@@ -239,6 +239,13 @@ from funasr import AutoModelmodel = AutoModel(model="paraformer-zh", vad_model="fsmn-vad", punc_model="ct-punc", spk_model="cam++", device="cuda")result = model.generate(input="https://isv-data.oss-cn-hangzhou.aliyuncs.com/ics/MaaS/ASR/test_audio/asr_example_zh.wav", hotword="关键词 20")+# 使用 Silero VAD(先安装:python -m pip install "funasr[silero]")+model = AutoModel(+ model="paraformer-zh", vad_model="silero-vad", device="cpu",+ vad_kwargs={"silero_threshold": 0.5, "silero_min_silence_duration_ms": 100},+)+result = model.generate(input="audio.wav")+# 中/英/日 + 中文方言model = AutoModel(model="FunAudioLLM/Fun-ASR-Nano-2512", hub="hf", trust_remote_code=True,vad_model="fsmn-vad", vad_kwargs={"max_single_segment_time": 30000}, device="cuda")diff --git a/funasr/auto/auto_model.py b/funasr/auto/auto_model.pyindex dd94a3fd2..3dbb7a4f2 100644--- a/funasr/auto/auto_model.py+++ b/funasr/auto/auto_model.py@@ -536,6 +536,12 @@ class AutoModel:kwargs contains the resolved configuration."""assert "model" in kwargs+ # Silero VAD is loaded by its optional Python package rather than a+ # FunASR model repository. Supplying model_conf keeps it on the normal+ # AutoModel construction path while bypassing hub config resolution.+ if kwargs["model"] in {"silero-vad", "silero_vad"}:+ kwargs.setdefault("model_conf", {})+ kwargs["model"] = "SileroVad"if "model_conf" not in kwargs:logging.info("download models from model hub: {}".format(kwargs.get("hub", "ms")))kwargs = download_model(**kwargs)diff --git a/funasr/models/silero_vad/__init__.py b/funasr/models/silero_vad/__init__.pynew file mode 100644index 000000000..d62060435--- /dev/null+++ b/funasr/models/silero_vad/__init__.py@@ -0,0 +1 @@+"""Silero VAD adapter for the FunASR AutoModel pipeline."""diff --git a/funasr/models/silero_vad/model.py b/funasr/models/silero_vad/model.pynew file mode 100644index 000000000..1ba989f2a--- /dev/null+++ b/funasr/models/silero_vad/model.py@@ -0,0 +1,81 @@+"""Adapter that makes Silero VAD return FunASR-compatible millisecond segments."""++import time++import torch++from funasr.register import tables+from funasr.utils.load_utils import load_audio_text_image_video++[email protected]("model_classes", "SileroVad")+class SileroVad(torch.nn.Module):+ """Offline Silero VAD adapter used by ``AutoModel(vad_model='silero-vad')``.++ Requires the official ``silero-vad`` Python package.+ """++ def __init__(self, **kwargs):+ super().__init__()+ self.anchor = torch.nn.Parameter(torch.empty(0), requires_grad=False)+ try:+ from silero_vad import get_speech_timestamps, load_silero_vad+ except ImportError as error:+ raise ImportError(+ "Silero VAD requires the optional dependency. Install it with "+ '`python -m pip install "funasr[silero]"` or '+ "`python -m pip install silero-vad`."+ ) from error+ self.model = load_silero_vad(onnx=kwargs.get("silero_onnx", False))+ self.get_speech_timestamps = get_speech_timestamps++ @staticmethod+ def _split_long_segments(segments, max_single_segment_time):+ if not max_single_segment_time:+ return segments+ limit_ms = int(max_single_segment_time)+ split = []+ for start, end in segments:+ while end - start > limit_ms:+ split.append([start, start + limit_ms])+ start += limit_ms+ split.append([start, end])+ return split++ def inference(self, data_in, key=None, **kwargs):+ sample_rate = int(kwargs.get("silero_sampling_rate", 16000))+ if sample_rate not in (8000, 16000):+ raise ValueError("Silero VAD supports silero_sampling_rate=8000 or 16000")+ audio_list = load_audio_text_image_video(+ data_in,+ fs=sample_rate,+ audio_fs=kwargs.get("fs", sample_rate),+ data_type=kwargs.get("data_type", "sound"),+ )+ if not isinstance(audio_list, list):+ audio_list = [audio_list]++ started = time.perf_counter()+ results = []+ for index, audio in enumerate(audio_list):+ waveform = torch.as_tensor(audio, dtype=torch.float32).flatten().cpu()+ timestamps = self.get_speech_timestamps(+ waveform,+ self.model,+ sampling_rate=sample_rate,+ threshold=kwargs.get("silero_threshold", 0.5),+ min_speech_duration_ms=kwargs.get("silero_min_speech_duration_ms", 250),+ min_silence_duration_ms=kwargs.get("silero_min_silence_duration_ms", 100),+ speech_pad_ms=kwargs.get("silero_speech_pad_ms", 30),+ )+ segments = [+ [int(item["start"] * 1000 / sample_rate), int(item["end"] * 1000 / sample_rate)]+ for item in timestamps+ ]+ segments = self._split_long_segments(+ segments, kwargs.get("max_single_segment_time")+ )+ results.append({"key": key[index] if key else str(index), "value": segments})+ elapsed = time.perf_counter() - started+ total_samples = sum(len(torch.as_tensor(audio)) for audio in audio_list)+ return results, {"batch_data_time": total_samples / sample_rate, "forward": elapsed}diff --git a/setup.py b/setup.pyindex 7875d77e3..d96614136 100644--- a/setup.py+++ b/setup.py@@ -48,6 +48,9 @@ requirements = {"train": ["rapidfuzz>=3.0.0",],+ "silero": [+ "silero-vad>=6.0.0",+ ],# all: The modules should be optionally installled due to some reason.# Please consider moving them to "install" occasionally"all": [diff --git a/tests/test_silero_vad_adapter.py b/tests/test_silero_vad_adapter.pynew file mode 100644index 000000000..0e5819382--- /dev/null+++ b/tests/test_silero_vad_adapter.py@@ -0,0 +1,57 @@+import unittest+from importlib.util import find_spec+from unittest.mock import patch++import torch++from funasr.auto.auto_model import AutoModel+from funasr.models.silero_vad.model import SileroVad++[email protected](find_spec("silero_vad"), "silero-vad is not installed")+class TestSileroVadAdapter(unittest.TestCase):+ def _timestamps_stub(self, waveform, model, sampling_rate, **options):+ self.assertEqual(sampling_rate, 16000)+ self.assertEqual(options["threshold"], 0.6)+ return [{"start": 1600, "end": 17600}]++ def _load_stub(self, *args, **kwargs):+ self.assertEqual(kwargs, {"onnx": False})+ return torch.nn.Identity()++ @patch("silero_vad.get_speech_timestamps")+ @patch("silero_vad.load_silero_vad")+ def test_returns_funasr_millisecond_segments_and_honors_max_length(self, load_model, timestamps):+ load_model.side_effect = self._load_stub+ timestamps.side_effect = self._timestamps_stub+ model = SileroVad()+ results, metadata = model.inference(+ data_in=[torch.zeros(32000)],+ key=["sample"],+ silero_threshold=0.6,+ max_single_segment_time=500,+ )++ self.assertEqual(results, [{"key": "sample", "value": [[100, 600], [600, 1100]]}])+ self.assertEqual(metadata["batch_data_time"], 2.0)+ load_model.assert_called_once_with(onnx=False)++ @patch("silero_vad.get_speech_timestamps")+ @patch("silero_vad.load_silero_vad")+ def test_rejects_unsupported_sampling_rate(self, load_model, timestamps):+ load_model.side_effect = self._load_stub+ model = SileroVad()+ with self.assertRaisesRegex(ValueError, "8000 or 16000"):+ model.inference(data_in=[torch.zeros(16000)], silero_sampling_rate=44100)++ @patch("silero_vad.get_speech_timestamps")+ @patch("silero_vad.load_silero_vad")+ def test_auto_model_alias_uses_the_existing_vad_build_path(self, load_model, timestamps):+ load_model.side_effect = self._load_stub+ model, resolved = AutoModel.build_model(model="silero-vad", device="cpu")+ self.assertIsInstance(model, SileroVad)+ self.assertEqual(resolved["model"], "SileroVad")+++if __name__ == "__main__":+ unittest.main()