"""Titelgelijkenis en reekstitel, in de geest van hfydl (niet die code). hfydl gebruikt model2vec (minishlab/potion-base-8M) en cosine ≥ temperature (standaard 0.5) om te beslissen of een next-link nog bij dezelfde reeks hoort. De serietitel is het gemeenschappelijke woord-voorvoegsel van de titels. Wij doen hetzelfde principe, maar: - embeddings op de post-titel (stabieler dan het label "Next"); - tags en part-nummers gaan er eerst af, anders faalt het voorvoegsel op '[OC]'; - zonder model2vec valt de indexer terug op een lexicale embedder, zodat tests en CI zonder modeldownload werken. """ from __future__ import annotations import math import os import re from typing import Iterable, Protocol from .normalize import normalize_title DEFAULT_TEMPERATURE = 0.5 MODEL_NAME = "minishlab/potion-base-8M" class Embedder(Protocol): name: str def encode(self, texts: list[str]) -> list[list[float]]: ... def cosine(a: list[float] | tuple[float, ...], b: list[float] | tuple[float, ...]) -> float: if not a or not b or len(a) != len(b): return 0.0 dot = 0.0 na = 0.0 nb = 0.0 for x, y in zip(a, b): dot += x * y na += x * x nb += y * y if na <= 0 or nb <= 0: return 0.0 return dot / math.sqrt(na * nb) def mean_vec(vectors: Iterable[list[float]]) -> list[float]: items = list(vectors) if not items: return [] n = len(items) dim = len(items[0]) acc = [0.0] * dim for v in items: if len(v) != dim: continue for i, x in enumerate(v): acc[i] += x return [x / n for x in acc] class LexicalEmbedder: """Lichte, deterministische embedder op woord- en karakter-n-grams.""" name = "lexical" def encode(self, texts: list[str]) -> list[list[float]]: return [self._one(t) for t in texts] def _one(self, text: str) -> list[float]: key = normalize_title(text) or (text or "").strip().lower() tokens = re.findall(r"[a-z0-9]+", key) grams: dict[str, float] = {} for tok in tokens: grams[f"w:{tok}"] = grams.get(f"w:{tok}", 0.0) + 2.0 padded = f"#{tok}#" for i in range(len(padded) - 2): g = padded[i : i + 3] grams[f"c:{g}"] = grams.get(f"c:{g}", 0.0) + 1.0 if not grams: return [1.0] # Vaste dimensie-volgorde: sorteer de sleutels en maak een compacte # hash-bag, zodat twee titels in één gemeenschappelijke ruimte liggen. dim = 256 vec = [0.0] * dim for k, val in grams.items(): idx = (hash(k) % dim + dim) % dim # hash() is per proces stabiel, niet per machine. Voor tests in # één proces is dat genoeg; voor model2vec geldt die zorg niet. # We gebruiken een stabiele FNV-achtige hash in plaats van hash(). idx = _stable_hash(k) % dim vec[idx] += val return _l2(vec) def _stable_hash(text: str) -> int: h = 2166136261 for ch in text.encode("utf-8"): h ^= ch h = (h * 16777619) & 0xFFFFFFFF return h def _l2(vec: list[float]) -> list[float]: n = math.sqrt(sum(x * x for x in vec)) if n <= 0: return vec return [x / n for x in vec] class Model2VecEmbedder: name = "model2vec" def __init__(self, model: object) -> None: self._model = model def encode(self, texts: list[str]) -> list[list[float]]: cleaned = [normalize_title(t) or t for t in texts] raw = self._model.encode(cleaned) # type: ignore[attr-defined] out: list[list[float]] = [] for row in raw: out.append(_l2([float(x) for x in row])) return out def load_embedder(kind: str | None = None) -> Embedder: """kind: auto | lexical | model2vec. auto probeert model2vec en valt terug.""" choice = (kind or os.environ.get("HFY_EMBEDDER") or "auto").strip().lower() if choice in {"lexical", "lex"}: return LexicalEmbedder() if choice in {"auto", "model2vec", "m2v"}: try: from model2vec import StaticModel model = StaticModel.from_pretrained(MODEL_NAME) return Model2VecEmbedder(model) except Exception: if choice in {"model2vec", "m2v"}: raise return LexicalEmbedder() return LexicalEmbedder() def guess_title(titles: list[str]) -> str: """Gemeenschappelijk woord-voorvoegsel, ná het strippen van tags en part-nummers.""" split = [normalize_title(t).split() for t in titles] split = [s for s in split if s] if not split: return "Untitled" first = split[0] end = 0 for i, word in enumerate(first): if any(len(s) <= i or s[i] != word for s in split): break end = i + 1 if end == 0: # Geen gemeenschappelijk voorvoegsel: val terug op de langste genormaliseerde titel. longest = max((normalize_title(t) for t in titles), key=len, default="") return longest.title() if longest else "Untitled" return " ".join(first[:end]).title()