Download code/speaker_teacher.py from laion/tyger-speaker-predictor: direct link, hf CLI and curl.
- Browser
- Download file 8.65 kB
-
https://huggingface.co/laion/tyger-speaker-predictor/resolve/main/code/speaker_teacher.py
- Command line
-
hf download hf://laion/tyger-speaker-predictor/code/speaker_teacher.py
-
curl -L -o speaker_teacher.py https://huggingface.co/laion/tyger-speaker-predictor/resolve/main/code/speaker_teacher.py
8.65 kB
| """Optional CPU ECAPA teacher baseline; no training, GPU or network access. | |
| This is NOT the Nemotron-feature TYGER V2 student. All audio/embeddings remain | |
| in memory, and speaker identity is an approximate cue, never authentication. | |
| Configure ROBO_ECAPA_ROOT to an existing pinned SpeechBrain snapshot, or use | |
| an already populated HF_HUB_CACHE. Importing this module loads no model. | |
| """ | |
| from __future__ import annotations | |
| from collections import deque | |
| import os | |
| from pathlib import Path | |
| import threading | |
| import time | |
| import numpy as np | |
| SAMPLE_RATE = 16000 | |
| EMBEDDING_DIM = 192 | |
| TEACHER_REVISION = "0f99f2d0ebe89ac095bcc5903c4dd8f72b367286" | |
| REPO = "speechbrain/spkrec-ecapa-voxceleb" | |
| REQUIRED_FILES = ("hyperparams.yaml", "embedding_model.ckpt", | |
| "mean_var_norm_emb.ckpt", "classifier.ckpt", "label_encoder.txt") | |
| def preserve_encoder_precision(): | |
| """SpeechBrain's import quirk must not enable TF32 in the EARS process.""" | |
| disabled={x.strip() for x in os.environ.get('SB_DISABLE_QUIRKS','').split(',') if x.strip()} | |
| disabled.add('allow_tf32') | |
| os.environ['SB_DISABLE_QUIRKS']=','.join(sorted(disabled)) | |
| def resolve_model_root(model_root=None): | |
| """Resolve local files only; never call snapshot_download or trust a remote ID.""" | |
| explicit = model_root or os.environ.get("ROBO_ECAPA_ROOT") | |
| if explicit: | |
| root = Path(explicit).expanduser().resolve() | |
| else: | |
| from huggingface_hub.constants import HF_HUB_CACHE | |
| cache = Path(os.environ.get("HF_HUB_CACHE", HF_HUB_CACHE)).expanduser() | |
| root = cache / "models--speechbrain--spkrec-ecapa-voxceleb" / "snapshots" / TEACHER_REVISION | |
| missing = [name for name in REQUIRED_FILES if not (root / name).is_file()] | |
| if missing: | |
| raise FileNotFoundError("ECAPA is offline-only: set ROBO_ECAPA_ROOT to a complete " | |
| "local snapshot; missing " + ", ".join(missing)) | |
| return root | |
| def _audio(values): | |
| x = np.asarray(values, dtype=np.float32) | |
| if x.ndim != 1 or not np.isfinite(x).all(): | |
| raise ValueError("Expected finite mono float audio at 16000 Hz") | |
| return np.ascontiguousarray(x) | |
| class EcapaTeacher: | |
| """Thread-safe lazy model; embed() returns a unit-length float32 [192]. | |
| A minimum of 640 ms is accepted, but clean full utterances are preferable. | |
| The RMS check rejects silence, not noise/overlap; use upstream activity cues. | |
| Calls are serialized to avoid competing CPU inference on the shared model. | |
| No torch thread setting or other process-global runtime option is changed. | |
| """ | |
| def __init__(self, model_root=None, min_seconds=.64, min_rms=1e-5): | |
| if min_seconds < .64 or min_rms < 0: | |
| raise ValueError("Need at least 640 ms and a nonnegative silence threshold") | |
| self.model_root = model_root | |
| self.min_samples = int(np.ceil(min_seconds * SAMPLE_RATE)) | |
| self.min_rms = min_rms | |
| self._model = None | |
| self._lock = threading.RLock() | |
| def loaded(self): | |
| return self._model is not None | |
| def _load(self): | |
| if self._model is None: | |
| preserve_encoder_precision() | |
| from speechbrain.inference.speaker import EncoderClassifier | |
| from speechbrain.utils.fetching import FetchConfig, LocalStrategy | |
| root = resolve_model_root(self.model_root) | |
| # NO_LINK leaves the local snapshot alone, even when caches are read-only. | |
| # allow_network=False covers pretrainer collection as well as YAML fetch. | |
| self._model = EncoderClassifier.from_hparams( | |
| source=str(root), overrides={"pretrained_path": str(root)}, | |
| savedir=None, local_strategy=LocalStrategy.NO_LINK, | |
| fetch_config=FetchConfig(allow_network=False, allow_updates=False), | |
| run_opts={"device": "cpu"}) | |
| self._model.eval() | |
| return self._model | |
| def embed(self, audio16): | |
| x = _audio(audio16) | |
| if len(x) < self.min_samples: | |
| raise ValueError("Need at least 640 ms of speech; prefer a clean full utterance") | |
| if float(np.sqrt(np.mean(x.astype(np.float64)**2))) < self.min_rms: | |
| raise ValueError("Silent/near-silent audio has no reliable speaker embedding") | |
| import torch | |
| with self._lock, torch.inference_mode(): | |
| model = self._load() | |
| result = model.encode_batch(torch.from_numpy(x.copy())[None]).reshape(-1) | |
| vector = result.detach().cpu().float().numpy().copy() | |
| norm = float(np.linalg.norm(vector)) | |
| if vector.shape != (EMBEDDING_DIM,) or not np.isfinite(vector).all() or norm < 1e-8: | |
| raise ValueError("Teacher returned an invalid speaker embedding") | |
| return (vector / norm).astype(np.float32, copy=False) | |
| _shared = {} | |
| _shared_lock = threading.Lock() | |
| def get_cached_teacher(model_root=None): | |
| """Share one lazy CPU model per local snapshot in this process.""" | |
| root = resolve_model_root(model_root) | |
| with _shared_lock: | |
| if str(root) not in _shared: | |
| _shared[str(root)] = EcapaTeacher(root) | |
| return _shared[str(root)] | |
| class StreamingTeacher: | |
| """Bounded per-conversation audio context over a shared teacher. | |
| Input cadence may be 20 ms or 320 ms. First estimate needs 1.6 s of accepted | |
| speech; subsequent estimates are computed every 640 ms by default. Set | |
| update_seconds=1.0 for a slower CPU cadence. Call from a worker thread, not | |
| the microphone/event-loop callback. Never publish/persist these buffers. | |
| speech=True must come from a separate activity cue, not speaker similarity. | |
| speech=False and overlap=True clear context immediately. With speech=None, | |
| energy alone cannot establish speech, so no identity is emitted. Confidence | |
| is a context/eligibility indicator, NOT a calibrated identity probability. | |
| """ | |
| def __init__(self, teacher=None, min_context_seconds=1.6, update_seconds=.64, | |
| max_context_seconds=4., min_rms=.003): | |
| if min_context_seconds < 1.6 or update_seconds <= 0 or max_context_seconds < min_context_seconds or min_rms < 0: | |
| raise ValueError("Need >=1.6 s context, positive cadence and sufficient buffer") | |
| self.teacher = teacher if teacher is not None else get_cached_teacher() | |
| self.min_samples = int(np.ceil(min_context_seconds * SAMPLE_RATE)) | |
| self.update_samples = int(np.ceil(update_seconds * SAMPLE_RATE)) | |
| self.max_samples = int(np.ceil(max_context_seconds * SAMPLE_RATE)) | |
| self.min_rms = min_rms | |
| self.reset() | |
| def reset(self): | |
| self._chunks = deque() | |
| self._samples = 0 | |
| self._since_update = 0 | |
| self._estimated = False | |
| def _reply(self, kind, **fields): | |
| return {"embedding": None, "kind": kind, "confidence": 0., | |
| "context_ms": self._samples * 1000 / SAMPLE_RATE, | |
| "source": "ecapa_teacher_cpu", "fresh": False, **fields} | |
| def update(self, audio16, speech=None, overlap=False): | |
| x = _audio(audio16) | |
| if not len(x): | |
| return self._reply("warming") | |
| rms = float(np.sqrt(np.mean(x.astype(np.float64)**2))) | |
| active = isinstance(speech, (bool, np.bool_)) and bool(speech) | |
| silent = isinstance(speech, (bool, np.bool_)) and not bool(speech) | |
| if overlap or not active or rms < self.min_rms: | |
| self.reset() | |
| return self._reply("overlap" if overlap else "silence" if silent or rms < self.min_rms else "uncertain") | |
| retained = x[-self.max_samples:].copy() | |
| self._chunks.append(retained) | |
| self._samples += len(retained) | |
| self._since_update += len(x) | |
| while self._samples > self.max_samples: | |
| extra = self._samples - self.max_samples | |
| first = self._chunks.popleft() | |
| trim = min(extra, len(first)) | |
| if trim < len(first): | |
| self._chunks.appendleft(first[trim:].copy()) | |
| self._samples -= trim | |
| if self._samples < self.min_samples: | |
| return self._reply("warming") | |
| if self._estimated and self._since_update < self.update_samples: | |
| # Do not repeat the last voiceprint and accidentally count it as new evidence. | |
| return self._reply("waiting") | |
| started = time.perf_counter() | |
| vector = self.teacher.embed(np.concatenate(self._chunks)) | |
| self._since_update = 0 | |
| self._estimated = True | |
| return self._reply("speech", embedding=vector, confidence=.8, fresh=True, | |
| latency_ms=(time.perf_counter()-started)*1000) | |