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
import unittest
import numpy as np
import torch
from funasr.auto.auto_model import AutoModel
from funasr.frontends.wav_frontend import WavFrontend
from funasr.models.contextual_paraformer.model import ContextualParaformer
from funasr.models.paraformer.model import Paraformer
from funasr.models.seaco_paraformer.model import SeacoParaformer
class _DummyTokenizer:
def ids2tokens(self, ids):
return ["x" for _ in ids]
def tokens2text(self, tokens):
return "".join(tokens)
class _ZeroTokenMixin:
"""Encoder/predictor stand-ins where every utterance predicts zero tokens."""
def _setup(self):
torch.nn.Module.__init__(self)
self.dummy = torch.nn.Parameter(torch.zeros(1))
self.beam_search = None
self.ctc = None
self.sos = 1
self.eos = 2
self.blank_id = 0
def encode(self, speech, speech_lengths):
return torch.zeros(speech.size(0), 4, 2), torch.full((speech.size(0),), 4)
def calc_predictor(self, encoder_out, encoder_out_lens):
batch = encoder_out.size(0)
return (
torch.zeros(batch, 1, 2),
torch.full((batch,), 0.4),
torch.zeros(batch, 4),
torch.zeros(batch, 4),
)
def generate_hotwords_list(self, *args, **kwargs):
return None
def cal_decoder_with_predictor(self, *args, **kwargs):
raise AssertionError("decoder must not run when no token is predicted")
_seaco_decode_with_ASF = cal_decoder_with_predictor
class _ZeroTokenParaformer(_ZeroTokenMixin, Paraformer):
def __init__(self):
self._setup()
class _ZeroTokenContextualParaformer(_ZeroTokenMixin, ContextualParaformer):
def __init__(self):
self._setup()
class _ZeroTokenSeacoParaformer(_ZeroTokenMixin, SeacoParaformer):
def __init__(self, predictor_name="CifPredictorV3"):
self._setup()
self.predictor_name = predictor_name
def _frontend():
return WavFrontend(cmvn_file=None, dither=0.0)
def _inference(model, keys, **kwargs):
return model.inference(
[np.zeros(1600, dtype=np.float32) for _ in keys],
key=list(keys),
frontend=_frontend(),
device="cpu",
**kwargs,
)
class TestParaformerEmptyTokenBatch(unittest.TestCase):
def test_paraformer_returns_one_keyed_result_per_utterance(self):
results, meta_data = _inference(
_ZeroTokenParaformer(), ["a", "b"], tokenizer=_DummyTokenizer()
)
self.assertEqual(results, [{"key": "a", "text": ""}, {"key": "b", "text": ""}])
self.assertIn("batch_data_time", meta_data)
def test_paraformer_keeps_timestamp_field(self):
results, _ = _inference(
_ZeroTokenParaformer(), ["a", "b"], tokenizer=_DummyTokenizer(), output_timestamp=True
)
self.assertEqual(
results,
[{"key": "a", "text": "", "timestamp": []}, {"key": "b", "text": "", "timestamp": []}],
)
def test_paraformer_without_tokenizer_returns_empty_token_ids(self):
results, _ = _inference(_ZeroTokenParaformer(), ["a", "b"])
self.assertEqual(results, [{"key": "a", "token_int": []}, {"key": "b", "token_int": []}])
def test_contextual_paraformer_returns_one_keyed_result_per_utterance(self):
results, _ = _inference(
_ZeroTokenContextualParaformer(), ["a", "b"], tokenizer=_DummyTokenizer()
)
self.assertEqual(results, [{"key": "a", "text": ""}, {"key": "b", "text": ""}])
def test_seaco_paraformer_returns_one_keyed_result_per_utterance(self):
results, _ = _inference(
_ZeroTokenSeacoParaformer(), ["a", "b"], tokenizer=_DummyTokenizer()
)
self.assertEqual(
results,
[{"key": "a", "text": "", "timestamp": []}, {"key": "b", "text": "", "timestamp": []}],
)
results, _ = _inference(
_ZeroTokenSeacoParaformer("CifPredictorV2"), ["a"], tokenizer=_DummyTokenizer()
)
self.assertEqual(results, [{"key": "a", "text": ""}])
def test_auto_model_keeps_every_utterance_of_the_batch(self):
am = AutoModel.__new__(AutoModel)
am.model = _ZeroTokenParaformer()
am.kwargs = {
"batch_size": 2,
"disable_pbar": True,
"device": "cpu",
"frontend": _frontend(),
"tokenizer": _DummyTokenizer(),
}
res = AutoModel.inference(
am,
[np.zeros(1600, dtype=np.float32), np.zeros(1600, dtype=np.float32)],
key=["a", "b"],
)
self.assertEqual(res, [{"key": "a", "text": ""}, {"key": "b", "text": ""}])
if __name__ == "__main__":
unittest.main()