A fala de colegas no Discord e de outros jogadores saía na legenda como se fosse do streamer. Agora cada palavra tem falante: - voz: cada trecho de fala vira uma impressão de voz (WeSpeaker ResNet34-LM, ONNX, pesos CC-BY-4.0) na análise do bloco (~0,2 s de CPU por bloco); as vozes da sessão são agrupadas sob demanda (0,05 s) e a do streamer é a que mexe a boca na webcam (YuNet, nova série `mouth` no rastreio) ou a mais alta no áudio. Sem prova, tudo continua como do streamer. - dados: `scoring.Word.speaker`; `words_json` aceita o 4º elemento; tabela `voice_chunks` (CREATE TABLE IF NOT EXISTS, fora da lista de migrações). - legenda: streamer na posição normal e outra pessoa logo abaixo, em outra cor (`caption.otherColor`/`otherSize`); blocos nunca misturam falantes; os dois juntos = duas linhas; gancho desvia as duas; vertical e horizontal. - tradução com `speaker` por linha; juízes recebem a transcrição marcada. - painel: cor da outra pessoa na configuração, falante na transcrição do editor (com correção manual), prévia em duas linhas e "O que falam" no modal. - doc/clipador/FALANTES.md com abordagem, licenças e qualidade medida na sessão 15. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
101 lines
4.4 KiB
Python
101 lines
4.4 KiB
Python
"""Impressão de voz (embedding de falante) para o Clipador: fbank no estilo Kaldi em numpy + WeSpeaker ResNet34-LM
|
||
(ONNX, CC-BY-4.0) no onnxruntime. Só E/S de modelo e conta numérica; a decisão de quem fala mora em `speakers.py`.
|
||
|
||
- Modelo: `voxceleb_resnet34_LM.onnx` do repositório Wespeaker/wespeaker-voxceleb-resnet34-LM (Hugging Face, commit
|
||
fixo no `models.lock.json`, licença CC-BY-4.0 — uso comercial permitido com atribuição; ver doc/clipador/FALANTES.md).
|
||
- Entrada do modelo: fbank 80 bandas, janela 25 ms / passo 10 ms, 16 kHz, com a média de cada trecho subtraída (CMN),
|
||
igual ao `compute_fbank` do WeSpeaker. Saída: vetor de 256, normalizado aqui (comparação por cosseno).
|
||
|
||
Nada daqui importa numpy/onnxruntime na carga do módulo: o serviço sobe (e os testes rodam) sem eles.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import math
|
||
import threading
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
SAMPLE_RATE = 16_000
|
||
FRAME_LEN, FRAME_SHIFT, N_FFT, N_MELS = 400, 160, 512, 80
|
||
PREEMPH = 0.97
|
||
MIN_SAMPLES = FRAME_LEN + FRAME_SHIFT * 20 # ~0,2 s: menos que isso não vira vetor
|
||
|
||
|
||
class VoiceprintUnavailable(RuntimeError):
|
||
"""numpy/onnxruntime ou o modelo faltando: a atribuição de falante fica de fora (tudo `streamer`)."""
|
||
|
||
|
||
_mel_cache: dict[int, Any] = {}
|
||
|
||
|
||
def _mel_banks(np: Any) -> Any:
|
||
"""Banco de filtros triangulares na escala mel do Kaldi (20 Hz até Nyquist), 80 × 257."""
|
||
if N_MELS in _mel_cache:
|
||
return _mel_cache[N_MELS]
|
||
|
||
def mel(f: Any) -> Any:
|
||
return 1127.0 * np.log(1.0 + f / 700.0)
|
||
|
||
lo, hi = mel(np.float64(20.0)), mel(np.float64(SAMPLE_RATE / 2))
|
||
centers = np.linspace(lo, hi, N_MELS + 2)
|
||
bins = mel(np.arange(N_FFT // 2 + 1) * SAMPLE_RATE / N_FFT)
|
||
banks = np.zeros((N_MELS, N_FFT // 2 + 1), np.float32)
|
||
for m in range(N_MELS):
|
||
left, center, right = centers[m], centers[m + 1], centers[m + 2]
|
||
up = (bins - left) / (center - left)
|
||
down = (right - bins) / (right - center)
|
||
banks[m] = np.maximum(0.0, np.minimum(up, down))
|
||
_mel_cache[N_MELS] = banks
|
||
return banks
|
||
|
||
|
||
def fbank(samples: Any) -> Any:
|
||
"""Fbank Kaldi (snip_edges, janela povey, pré-ênfase 0,97, sem dither) de amostras int16/float na escala int16.
|
||
Devolve (quadros × 80) float32 já com a média subtraída (CMN), como o WeSpeaker espera."""
|
||
import numpy as np
|
||
|
||
x = np.asarray(samples, dtype=np.float64)
|
||
n = 1 + (len(x) - FRAME_LEN) // FRAME_SHIFT
|
||
if n < 1:
|
||
return np.zeros((0, N_MELS), np.float32)
|
||
idx = np.arange(FRAME_LEN)[None, :] + FRAME_SHIFT * np.arange(n)[:, None]
|
||
frames = x[idx]
|
||
frames = frames - frames.mean(axis=1, keepdims=True) # tira o nível DC
|
||
frames = np.concatenate([frames[:, :1] * (1 - PREEMPH), frames[:, 1:] - PREEMPH * frames[:, :-1]], axis=1)
|
||
window = (0.5 - 0.5 * np.cos(2 * math.pi * np.arange(FRAME_LEN) / (FRAME_LEN - 1))) ** 0.85 # povey
|
||
spec = np.abs(np.fft.rfft(frames * window, N_FFT)) ** 2
|
||
feats = np.log(np.maximum(spec @ _mel_banks(np).T.astype(np.float64), np.finfo(np.float32).eps))
|
||
feats = feats - feats.mean(axis=0, keepdims=True)
|
||
return feats.astype(np.float32)
|
||
|
||
|
||
class Voiceprint:
|
||
"""Sessão ONNX do WeSpeaker. Um por motor; `embed` é seguro entre threads (trinco)."""
|
||
|
||
def __init__(self, model_path: Path, threads: int = 2):
|
||
try:
|
||
import numpy as np
|
||
import onnxruntime as ort
|
||
except ImportError as exc: # pragma: no cover - depende da instalação
|
||
raise VoiceprintUnavailable("numpy/onnxruntime não instalados (rode o setup.bat)") from exc
|
||
if not Path(model_path).is_file():
|
||
raise VoiceprintUnavailable(f"modelo de voz ausente: {model_path}")
|
||
opts = ort.SessionOptions()
|
||
opts.intra_op_num_threads, opts.inter_op_num_threads = threads, 1
|
||
self._np = np
|
||
self._sess = ort.InferenceSession(str(model_path), sess_options=opts, providers=["CPUExecutionProvider"])
|
||
self._input = self._sess.get_inputs()[0].name
|
||
self._lock = threading.Lock()
|
||
|
||
def embed(self, samples: Any) -> list[float] | None:
|
||
"""Vetor de 256 (norma 1) de um trecho de fala; None se curto demais."""
|
||
np = self._np
|
||
if len(samples) < MIN_SAMPLES:
|
||
return None
|
||
feats = fbank(samples)
|
||
with self._lock:
|
||
out = self._sess.run(None, {self._input: feats[None]})[0][0]
|
||
norm = float(np.linalg.norm(out))
|
||
return (out / norm).astype(np.float32).tolist() if norm > 0 else None
|