Clipador: quem fala cada palavra (streamer × outra pessoa) e legenda em duas linhas

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>
This commit is contained in:
Mateuus
2026-11-18 03:57:00 -03:00
co-authored by Claude Opus 5.5
parent 54eac7cebf
commit 377536f778
21 changed files with 1657 additions and 126 deletions
+100
View File
@@ -0,0 +1,100 @@
"""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