Files
CenaForge/clipper/app/scoring.py
T
MateuusandClaude Opus 5.5 377536f778 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>
2026-11-18 03:57:00 -03:00

409 lines
21 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Escolha dos melhores momentos. Funções puras (sem E/S): recebem a linha do tempo e devolvem os trechos.
Ideia central: o chat reage DEPOIS do momento. Medimos a "empolgação" do chat por segundo (mensagens com peso:
risada, susto, hype e pedido de clip valem mais), comparamos com o normal recente da própria live (chat grande
tem muita mensagem o tempo todo; o que importa é o pico relativo) e, achado o pico, voltamos no tempo até onde a
reação começou e pegamos alguns segundos antes disso: é ali que aconteceu a coisa.
Sem chat (VOD), o sinal vem do volume do áudio (gritos, risadas) e de palavras de reação na transcrição.
Rosto do streamer (opcional, `face`): a série por segundo do rastreio (reaction.py). Reforça momentos do chat/áudio
(`reasons.face` + bônus limitado na nota) e cria momentos de fonte "face" só quando o áudio ou o chat também se
mexem no mesmo trecho — rosto sozinho nunca vira corte. Sem `face`, o resultado é idêntico ao de antes.
"""
from __future__ import annotations
import math
import re
import statistics
from collections import Counter
from dataclasses import dataclass, field, replace
from . import reaction
# Peso extra por categoria de reação. Uma mensagem pode somar mais de uma.
REACTION_PATTERNS: dict[str, tuple[re.Pattern[str], float]] = {
# Chat em inglês (fonte gringa, 18/11/2026): a risada lá é LMAO/LOL/💀/😭 e "I'm dead", não "kkkk".
"risada": (re.compile(r"(k{3,}|kek|lul|lmao+|lmfao|omegalul|icant|pepelaugh|haha|hehe|rsrs|ksks|😂|🤣|xd\b|"
r"\blo+l+\b|\brofl\b|💀|☠️?|😭|\bi'?m dead\b|\bim crying\b|\bdying\b)", re.I), 1.0),
"susto": (re.compile(r"(caralho|crlh|caraca|nossa|meu deus|mds|wtf|omg|que isso|q isso|monkas|monkaw|\bhuh+\b|"
r"😱|😳|\?{3,}|!{3,}|\bno+ ?wa+y+\b|\bna+h+\b|\bbru+h+\b|\bholy\b|\bjesus\b|"
r"\boh my god\b|\bwhat the\b)", re.I), 1.0),
"hype": (re.compile(r"(\bpog|pogchamp|poggers|\bw+\b|\bgg+\b|\bez\b|insano|absurdo|brabo|🔥|"
r"\blet'?s ?go+\b|\bletsgo+\b|\bshe+sh\b|\bclutch\b|\bcracked\b|\bgoated\b|\binsane\b|"
r"\bclap\b|\bdub\b)", re.I), 0.7),
# Palavra inteira: "clip5k1hmm" (emote) casava com \bclip e dava peso de pedido de clipe.
"clip": (re.compile(r"\b(clip|clips|clipa|clipe|clipou|clipar|clip it|clipit|clip that|clipped)\b", re.I), 3.0),
}
# Palavras faladas que indicam reação (modo sem chat), em português e em inglês (fonte gringa).
SPOKEN_REACTION = re.compile(r"^(caralho|caraca|nossa|meu|deus|socorro|mano|nãããão|não|sim|vai|gente|que|isso|olha|"
r"bro|bruh|dude|yo|what|no+|oh|wow|holy|fuck|shit|wait|god|jesus|yes+|bro+)$", re.I)
@dataclass(frozen=True)
class Params:
pre_s: float = 14.0 # quanto antes do início da reação o corte começa
post_s: float = 6.0 # quanto depois do pico o corte termina
# Duração do candidato: o motor troca pelos valores da configuração do corte de cada sessão (`duration`);
# estes são os mesmos padrões de layout.DEFAULTS (pedido do dono, 16/11/2026: cortes de 60 a 90 s).
min_s: float = 60.0
max_s: float = 90.0
threshold: float = 2.2 # pico precisa ser X vezes o normal recente do chat
audio_threshold: float = 2.0 # modo sem chat: z-score mínimo
min_gap_s: float = 45.0 # distância mínima entre dois picos
smooth_s: int = 5
baseline_s: int = 180
onset_ratio: float = 1.3 # o início da reação é onde a razão cai abaixo disto
max_onset_s: float = 30.0
settle_s: float = 12.0 # ao vivo: espera este tanto depois do fim do corte antes de fechar o pico
min_rate: float = 0.2 # mensagens/s mínimas no denominador (live com chat parado não vira pico por 2 msgs)
min_peak_messages: int = 12 # teto do mínimo de mensagens nos 8 s do pico (chat grande)
min_peak_floor: int = 4 # piso do mínimo (chat pequeno): 3 mensagens soltas nunca viram pico
min_reactions: int = 2 # mensagens de reação (risada/susto/hype/clip) nos 8 s do pico
sparse_rate: float = 0.5 # msg/s abaixo disso o chat é "fraco" e o áudio também propõe momentos
warmup_s: int = 60 # começo da gravação: ainda não há "normal" do chat para comparar
# --- rosto do streamer (reaction.py) ---
face_threshold: float = 3.0 # z mínimo da reação no rosto para anotar/reforçar um momento
face_bonus: float = 0.08 # nota extra por unidade de z do rosto num momento do chat/áudio…
face_bonus_max: float = 0.6 # …limitada a isto (o rosto reforça, não manda)
# Momento NOVO de fonte "face" (calibrado na sessão 3: com z ≥ 3 e apoio fraco saíam 32 momentos em 72 min,
# mais que os 21 do chat): reação forte no rosto E apoio de verdade no mesmo trecho.
face_source_threshold: float = 6.0 # z mínimo (= "forte")
face_support_audio_z: float = 1.5 # sinal do áudio suavizado (3 s) acima disto…
face_support_reactions: int = 2 # …ou pelo menos isto de mensagens de reação (texto ou emote) no chat
face_chat_after_s: float = 10.0 # o chat reage depois: conta até X s após o pico do rosto
face_score_scale: float = 0.4 # nota do momento "face" = z do rosto (até 10) × isto, na escala da razão do chat
@dataclass(frozen=True)
class ChatMessage:
t: float
text: str
user: str = ""
emotes: tuple[str, ...] = () # emotes da mensagem (Twitch, 7TV, BTTV, FFZ, Kick, emoji)
bonus: float = 0.0 # peso extra pelos emotes (base + aprendido do canal; ver emotes.py)
@dataclass(frozen=True)
class Word:
start: float
end: float
word: str
# Quem falou (doc/clipador/FALANTES.md): "" ou "streamer" = o streamer; "other1", "other2"… = outra pessoa (colega no
# Discord, voz do jogo). Vazio = não atribuído — conta como streamer (o comportamento de antes).
speaker: str = ""
@dataclass
class Moment:
peak_s: float
start_s: float
end_s: float
score: float
source: str # "chat" ou "audio"
reasons: dict = field(default_factory=dict)
def message_weight(text: str) -> tuple[float, list[str]]:
weight, tags = 1.0, []
for tag, (pattern, bonus) in REACTION_PATTERNS.items():
if pattern.search(text):
weight += bonus
tags.append(tag)
return weight, tags
def per_second(duration_s: float, chat: list[ChatMessage]) -> list[float]:
n = max(0, int(math.ceil(duration_s)))
series = [0.0] * n
for message in chat:
i = int(message.t)
if 0 <= i < n:
series[i] += message_weight(message.text)[0] + message.bonus
return series
def smooth(series: list[float], window: int) -> list[float]:
"""Média móvel para trás (só usa o passado: o valor em t não depende do futuro)."""
out, acc = [], 0.0
for i, value in enumerate(series):
acc += value
if i >= window:
acc -= series[i - window]
out.append(acc / min(i + 1, window))
return out
def chat_ratio(series: list[float], p: Params) -> list[float]:
"""Razão entre a empolgação suavizada e o normal recente (mediana dos últimos `baseline_s`, sem os últimos 10 s)."""
smoothed = smooth(series, p.smooth_s)
ratio = []
for t, value in enumerate(smoothed):
window = smoothed[max(0, t - p.baseline_s): max(0, t - 10)]
if len(window) < 30: # começo da gravação: usa o que tiver
window = smoothed[: t + 1]
base = max(p.min_rate, statistics.median(window) if window else p.min_rate)
ratio.append(value / base)
return ratio
def zscores(series: list[float]) -> list[float]:
values = [v for v in series if v is not None and not math.isnan(v)]
if len(values) < 10:
return [0.0] * len(series)
mean = statistics.fmean(values)
sd = statistics.pstdev(values) or 1.0
return [((v - mean) / sd) if v is not None and not math.isnan(v) else 0.0 for v in series]
def audio_signal(duration_s: float, loudness: list[float | None], words: list[Word]) -> list[float]:
n = max(0, int(math.ceil(duration_s)))
loud = (list(loudness) + [None] * n)[:n]
z = zscores([v if v is not None else float("nan") for v in loud])
signal = [max(0.0, v) for v in z]
for word in words:
i = int(word.start)
if 0 <= i < n and SPOKEN_REACTION.match(word.word.strip(" .,!?…").lower()):
signal[i] += 0.5
return smooth(signal, 3)
def pick_peaks(score: list[float], threshold: float, min_gap_s: float, limit_s: float | None = None) -> list[int]:
"""Picos acima do limiar, do maior para o menor, sem dois a menos de `min_gap_s`."""
# Escolhe olhando a série inteira e só depois descarta os não assentados (após `limit_s`): assim, ao vivo,
# um pico maior que ainda está crescendo segura os pontos menores do começo da mesma explosão.
candidates = sorted((i for i in range(len(score)) if score[i] >= threshold), key=lambda i: -score[i])
chosen: list[int] = []
for i in candidates:
if all(abs(i - j) >= min_gap_s for j in chosen):
chosen.append(i)
return sorted(i for i in chosen if limit_s is None or i < limit_s)
def onset(score: list[float], peak: int, below: float, max_back_s: float) -> int:
t = peak
while t > 0 and peak - t < max_back_s and score[t - 1] >= below:
t -= 1
return t
def snap_to_words(start: float, end: float, words: list[Word], gap: float = 0.35, reach: float = 4.0) -> tuple[float, float]:
"""Não corta no meio de uma frase: recua o início até uma pausa e estica o fim até uma pausa (até `reach` s)."""
if not words:
return start, end
ordered = sorted(words, key=lambda w: w.start)
# Começos de frase (palavra depois de uma pausa) perto do início pedido; prefere o mais próximo ANTES dele.
starts = [
w.start for i, w in enumerate(ordered)
if start - reach <= w.start <= start + 0.5 and (i == 0 or w.start - ordered[i - 1].end >= gap)
]
before = [s for s in starts if s <= start]
new_start = (max(before) if before else min(starts)) - 0.15 if starts else start
new_end = end
for i, word in enumerate(ordered):
if end - 0.5 <= word.end <= end + reach:
pause_after = ordered[i + 1].start - word.end if i + 1 < len(ordered) else gap
if pause_after >= gap:
new_end = word.end + 0.25
break
return max(0.0, new_start), max(new_end, new_start + 1)
def fit_window(start: float, end: float, lo: float, hi: float, min_len: float, max_len: float,
keep: str = "end") -> tuple[float, float]:
"""Encaixa [start, end] em [lo, hi] com duração entre `min_len` e `max_len`. Longo demais: corta o lado oposto a
`keep`. Curto demais: cresce PARA TRÁS primeiro (o contexto vem antes da reação) e, se bater em `lo` (começo da
gravação/janela), para a frente até `hi`. Se nem assim couber (material menor que o mínimo), devolve o que der —
quem chama decide o que fazer (não inventa vídeo). Arredonda para fora (centésimos), nunca encurta."""
start, end = max(lo, start), min(hi, end)
if end < start:
end = start
if end - start > max_len:
if keep == "start":
end = start + max_len
else:
start = end - max_len
if end - start < min_len:
start = max(lo, end - min_len)
if end - start < min_len:
end = min(hi, start + min_len)
return math.floor(start * 100) / 100, math.ceil(end * 100 - 1e-6) / 100
def fit_length(start: float, end: float, peak: float, p: Params, duration_s: float) -> tuple[float, float]:
"""Duração do candidato: começa pelo menos 2 s antes do pico e fica entre `min_s` e `max_s` (o motor passa o
mínimo da configuração + 1 s). Antes a ordem permitia passar do máximo e, no fim da gravação, ficar curto."""
start = max(0.0, min(start, peak - 2))
return fit_window(start, end, 0.0, max(duration_s, end), p.min_s, p.max_s, keep="end")
def chat_reasons(chat: list[ChatMessage], start: float, end: float) -> dict:
inside = [m for m in chat if start <= m.t <= end]
tags: Counter[str] = Counter()
phrases: Counter[str] = Counter()
emotes: Counter[str] = Counter()
for message in inside:
tags.update(message_weight(message.text)[1])
emotes.update(set(message.emotes))
normalized = re.sub(r"\s+", " ", message.text.strip())[:40]
if normalized:
phrases[normalized.lower()] += 1
return {
"messages": len(inside),
"tags": dict(tags.most_common()),
"topMessages": [text for text, _ in phrases.most_common(5)],
"emotes": dict(emotes.most_common(8)),
}
def find_moments(
duration_s: float,
chat: list[ChatMessage],
loudness: list[float | None],
words: list[Word],
params: Params | None = None,
live: bool = False,
face: list[reaction.FaceSecond] | None = None,
) -> list[Moment]:
"""Melhores momentos da linha do tempo. `live=True` só devolve picos já "assentados" (fim + settle_s <= duração).
Chat com movimento → picos do chat. Chat fraco (média < `sparse_rate` msg/s) → picos do chat E do áudio
(gritos/risadas/palavras de reação), sem sobrepor; o juiz de IA filtra. Sem chat → só áudio.
`face`: série do rosto alinhada à linha do tempo (índice = segundo; `None`/vazia = sem rosto).
"""
p = params or Params()
use_chat = len(chat) >= 30
moments = _chat_moments(duration_s, chat, loudness, words, p, live) if use_chat else []
sparse = duration_s > 0 and len(chat) / duration_s < p.sparse_rate
if not use_chat or sparse:
for m in _audio_moments(duration_s, loudness, words, p, live):
if not any(overlaps(m.start_s, m.end_s, c.start_s, c.end_s) for c in moments):
moments.append(m)
if face:
moments += _face_moments(duration_s, chat if use_chat else [], loudness, words, face, moments, p, live)
return sorted(moments, key=lambda m: m.peak_s)
def _face_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
face: list[reaction.FaceSecond], moments: list[Moment], p: Params, live: bool) -> list[Moment]:
"""Anota o rosto nos momentos do chat/áudio (bônus limitado) e devolve os momentos novos de fonte "face"."""
reactions = reaction.reaction_moments(face, replace(reaction.ReactionParams(), threshold=p.face_threshold))
if not reactions:
return []
for m in moments:
near = [r for r in reactions if m.start_s - 2 <= r.peak_s <= m.end_s + 3]
if near:
best = max(near, key=lambda r: r.intensity)
m.reasons["face"] = best.to_json()
m.score = round(m.score + min(p.face_bonus_max, p.face_bonus * best.intensity), 3)
n = max(0, int(math.ceil(duration_s)))
# Sinal do áudio suavizado (3 s, igual ao da fonte "audio"): o z cru de 1 segundo passa de 1 por acaso em ~16 %
# dos segundos e não serviria de apoio.
loud = audio_signal(duration_s, loudness, words)
reacting = [m.t for m in chat if message_weight(m.text)[1] or m.emotes]
limit = duration_s - p.post_s - p.settle_s if live else None
out: list[Moment] = []
for r in sorted(reactions, key=lambda r: -r.intensity):
if r.intensity < p.face_source_threshold or (limit is not None and r.peak_s >= limit):
continue
lo, hi = max(0, r.onset_s - 2), min(n, r.peak_s + 4)
audio = max(loud[lo:hi], default=0.0)
chat_hits = sum(1 for t in reacting if r.onset_s - 2 <= t <= r.peak_s + p.face_chat_after_s)
# Rosto sozinho não vira corte: precisa de apoio do áudio (gritou/riu alto) ou do chat no mesmo trecho.
if audio < p.face_support_audio_z and chat_hits < p.face_support_reactions:
continue
start, end = snap_to_words(r.onset_s - p.pre_s, max(r.end_s, r.peak_s) + p.post_s, words)
start, end = fit_length(start, end, r.peak_s, p, duration_s)
if any(overlaps(start, end, m.start_s, m.end_s) for m in moments + out):
continue
if any(abs(r.peak_s - m.peak_s) < p.min_gap_s for m in out):
continue
reasons = {"peakRatio": round(r.intensity, 2), "onsetS": r.onset_s, "face": r.to_json(),
"support": {"audioZ": round(audio, 2), "chatReactions": chat_hits}}
if chat:
reasons |= chat_reasons(chat, r.onset_s - 2, r.peak_s + 3)
out.append(Moment(float(r.peak_s), start, end, round(min(10.0, r.intensity) * p.face_score_scale, 3), "face",
reasons))
return out
def _required_messages(counts_8s: list[int], t: int, p: Params) -> int:
"""Mínimo de mensagens nos 8 s do pico, proporcional ao chat daquela live (mediana recente × 3).
Medido em 17/11/2026: chat de 0,15 msg/s (skipnho) nunca chegava às 12 mensagens fixas e a live inteira ficava
sem corte; chat de ~0,6 msg/s (alanzoka) com 3 mensagens soltas não pode virar pico. Fica entre 4 e 12.
"""
window = counts_8s[max(0, t - p.baseline_s): max(0, t - 10)] or counts_8s[: t + 1]
typical = statistics.median(window) if window else 0
return int(max(p.min_peak_floor, min(p.min_peak_messages, math.ceil(typical * 3))))
def _chat_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
p: Params, live: bool) -> list[Moment]:
score, threshold = chat_ratio(per_second(duration_s, chat), p), p.threshold
loud_z = zscores([v if v is not None else float("nan") for v in (list(loudness) + [None] * len(score))[: len(score)]])
score = [s + 0.15 * max(0.0, z) for s, z in zip(score, loud_z)] # grito junto com o pico do chat soma um pouco
# Falso positivo medido na live real: chat calmo + 3 mensagens (uma com "clip") já dava razão 2,35, e o
# começo da gravação (sem "normal" para comparar) virava pico. Exige gente reagindo (relativo ao chat) e aquecimento.
counts, reacts = [0] * len(score), [0] * len(score)
for message in chat:
i = int(message.t)
if 0 <= i < len(counts):
counts[i] += 1
# Reação = texto de reação OU emote (público pequeno reage com emote em vez de "kkkk").
reacts[i] += 1 if (message_weight(message.text)[1] or message.emotes) else 0
prefix, rprefix = [0], [0]
for c, r in zip(counts, reacts):
prefix.append(prefix[-1] + c)
rprefix.append(rprefix[-1] + r)
counts_8s = [prefix[t + 1] - prefix[max(0, t - 7)] for t in range(len(score))] # mensagens nos últimos 8 s
for t in range(len(score)):
required = _required_messages(counts_8s, t, p)
reactions = rprefix[t + 1] - rprefix[max(0, t - 7)]
# Chat pequeno junta 4 "oi" por acaso: além do volume, exige reação de verdade (ou volume dobrado).
enough = counts_8s[t] >= required and (reactions >= p.min_reactions or counts_8s[t] >= 2 * required)
if t < p.warmup_s or not enough:
score[t] = min(score[t], threshold - 0.01)
return _build(score, threshold, p.onset_ratio, "chat", duration_s, chat, words, p, live)
def _audio_moments(duration_s: float, loudness: list[float | None], words: list[Word], p: Params, live: bool) -> list[Moment]:
score = audio_signal(duration_s, loudness, words)
return _build(score, p.audio_threshold, 0.8, "audio", duration_s, [], words, p, live)
def _build(score: list[float], threshold: float, below: float, source: str, duration_s: float,
chat: list[ChatMessage], words: list[Word], p: Params, live: bool) -> list[Moment]:
limit = duration_s - p.post_s - p.settle_s if live else None
moments = []
for peak in pick_peaks(score, threshold, p.min_gap_s, limit):
begin = onset(score, peak, below, p.max_onset_s)
start, end = begin - p.pre_s, peak + p.post_s
start, end = snap_to_words(start, end, words)
start, end = fit_length(start, end, peak, p, duration_s)
reasons = {"peakRatio": round(score[peak], 2), "onsetS": begin}
if chat:
reasons |= chat_reasons(chat, begin - 2, peak + 3)
moments.append(Moment(float(peak), start, end, round(score[peak], 3), source, reasons))
return moments
def overlaps(a_start: float, a_end: float, b_start: float, b_end: float, tolerance: float = 5.0) -> bool:
return a_start < b_end - tolerance and b_start < a_end - tolerance
def timeline(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], params: Params | None = None) -> dict:
"""Séries por segundo para o gráfico do painel (mensagens/s, razão do chat, volume)."""
p = params or Params()
raw = per_second(duration_s, chat)
counts = [0] * len(raw)
for message in chat:
if 0 <= int(message.t) < len(counts):
counts[int(message.t)] += 1
return {
"messagesPerS": counts,
"ratio": [round(v, 2) for v in chat_ratio(raw, p)] if chat else [],
"loudnessDb": [None if v is None else round(v, 1) for v in loudness[: len(raw)]],
}