colgora/InkFlow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Voicebank : vraies voix françaises (CML-TTS) + pool anonyme + garde-fou Qwen3

Browse Source 
Remplace la voicebank générée par Kokoro (timbre anglais sur français phonémisé
-> accent que Qwen3 clonait) par 41 vraies voix FR issues de CML-TTS (livres
audio studio) : 1 narrateur dédié, 18F/14M nommées, 4F/4M anonymes réservées.

- scripts/import_voices.py : import multi-shards parquet, 1 clip/locuteur (le
  plus propre via levenshtein), genre estimé par F0 (YIN, anti-octave), filtre
  débit de parole (ref_text aligné sur l'audio).
- VoiceEntry.anonymous + assign_voices : les figurants « anonyme (...) » tirent
  dans un pool réservé, jamais mélangé avec les voix nommées ; narrateur dédié
  (fr_narrator remplace fr_f_siwis).
- dedup._anon_attrs : genre/âge déduits du nom anonyme (bon genre de voix).
- tts/qwen3.py : garde-fou anti-dérive (rejette/réessaie les sorties en boucle
  ou coupées en estimant la durée plausible du chunk).

Limite connue : Qwen3 ne sait pas synthétiser les fragments d'1-2 mots (incises,
titres) -> trous ; à traiter (repli Kokoro ou fusion des incises).

Inclut aussi du travail en cours antérieur (refacto backend LLM pluggable
mlx/lmstudio, benchmark, ajustements frontend/API).

Claude-Session: https://claude.ai/code/session_01XSVvcy1mfb4k1xDgib9vVU
This commit is contained in:
Djeone1
2026-06-21 21:32:31 +02:00
parent 141df5f04e
commit ba1813c583
91 changed files with 2558 additions and 442 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
backend/inkflow/analysis/benchmark.py
View File

@@ -359,6 +359,7 @@ def _build_model_score(model_id: str, per_chapter: list[ChapterScore],
def run_benchmark(slug: str, model_ids: list[str], *,
backend: Optional[str] = None,
chapters: Optional[list[int]] = None,
temperature: Optional[float] = None,
reasoning: Optional[bool] = None,
@@ -414,7 +415,8 @@ def run_benchmark(slug: str, model_ids: list[str], *,
report.models.append(_build_model_score("<cached>", per_chapter, counts, 0.0))
return report
from .gemma import Gemma, _load
from .llm.client import LLM
from .llm.factory import reset_llm_cache
from .segmenter import analyze_chapter
book = load_book(slug)
@@ -435,7 +437,7 @@ def run_benchmark(slug: str, model_ids: list[str], *,
model_err: Optional[str] = None
emit(f"[{mi}/{len(model_ids)}] {model_id} — chargement du modele…")
try:
gemma = Gemma(model_id=model_id)
gemma = LLM(model_id=model_id, backend=backend)
for i in targets:
ch = by_index.get(i)
if ch is None:
@@ -457,7 +459,7 @@ def run_benchmark(slug: str, model_ids: list[str], *,
model_err = f"{type(exc).__name__}: {exc}"
emit(f" ! echec: {model_err[:120]}")
finally:
_load.cache_clear() # libere le modele avant le suivant
reset_llm_cache() # libere le modele avant le suivant
ms = _build_model_score(
model_id, per_chapter, counts, time.perf_counter() - t0)
ms.error = model_err

251
backend/inkflow/analysis/gemma.py
View File

@@ -1,251 +0,0 @@
"""Wrapper mlx-lm autour de Gemma pour l'analyse de texte.
Charge le modele paresseusement (une seule fois par process) et expose des
helpers de generation, dont un `generate_json` tolerant qui extrait le premier
objet/array JSON valide de la sortie du modele.
"""
from __future__ import annotations
import json
import re
from functools import lru_cache
from typing import Any, Optional
from ..settings import get_settings
# Bornes d'un bloc JSON dans une reponse potentiellement bavarde.
_JSON_SPAN_RE = re.compile(r"(\{.*\}|\[.*\])", re.DOTALL)
_FENCE_RE = re.compile(r"```(?:json)?\s*(.*?)```", re.DOTALL)
# Marqueurs de FIN de chaine de pensee : on ne garde que ce qui suit le dernier.
# - balises type DeepSeek-R1 / Qwen-think
# - format a canaux type Gemma 4 / Harmony (la pensee est close par <channel|>)
_REASONING_END_MARKERS = ("</think>", "<channel|>", "<|channel|>")
# Prefixe de canal/think non ferme reste en tete (pensee tronquee) : a retirer.
_REASONING_OPEN_RE = re.compile(r"^\s*(?:<\|?channel\|?>\s*\w*|<think>)", re.IGNORECASE)
@lru_cache(maxsize=2)
def _load(model_id: str):
# Import paresseux : evite de charger mlx tant qu'on n'analyse pas.
from mlx_lm import load
return load(model_id)
# Hook de streaming optionnel. Si defini, `generate()` diffuse chaque morceau de
# texte AU FIL de la generation (pensee comprise, avant tout nettoyage) en
# appelant ce callback. Utilise par `inkflow benchmark --stream` pour voir les
# tokens en temps reel. None -> generation par lot classique (plus rapide).
_TOKEN_SINK: Optional[Any] = None
def set_token_sink(callback) -> None:
"""Definit (ou retire avec None) le callback de streaming des tokens."""
global _TOKEN_SINK
_TOKEN_SINK = callback
def _resolve_chat_template(model_id: str, tokenizer) -> Optional[str]:
"""Renvoie un template de chat a passer explicitement, ou None.
Certaines conversions (Mistral recents...) logent leur template dans un
fichier `chat_template.jinja` que le downloader de mlx-lm n'embarque pas
toujours : `tokenizer.chat_template` est alors vide et `apply_chat_template`
echoue. On recupere alors le fichier officiel du repo. None si le tokenizer
possede deja un template (cas courant) ou si aucun n'est disponible.
"""
if getattr(tokenizer, "chat_template", None):
return None
from pathlib import Path
from huggingface_hub import hf_hub_download
# Selon les conversions : fichier Jinja brut, ou JSON {"chat_template": ...}.
for fname in ("chat_template.jinja", "chat_template.json"):
try:
text = Path(hf_hub_download(model_id, fname)).read_text(encoding="utf-8")
except Exception: # noqa: BLE001 — fichier absent, on tente le suivant
continue
if fname.endswith(".json"):
data = json.loads(text)
return data.get("chat_template") if isinstance(data, dict) else None
return text
return None # aucun template dispo -> apply_chat_template levera une erreur claire
class Gemma:
"""Petite facade autour de mlx-lm pour piloter Gemma."""
def __init__(self, model_id: Optional[str] = None):
self.model_id = model_id or get_settings().gemma_model
self._model = None
self._tokenizer = None
self._chat_template = None # template recupere si absent du tokenizer
def _ensure_loaded(self) -> None:
if self._model is None:
self._model, self._tokenizer = _load(self.model_id)
self._chat_template = _resolve_chat_template(
self.model_id, self._tokenizer)
def generate(
self,
prompt: str,
*,
system: Optional[str] = None,
max_tokens: Optional[int] = None,
temperature: Optional[float] = None,
) -> str:
"""Genere une reponse texte a partir d'un prompt (template de chat).
`max_tokens`/`temperature` non fournis -> valeurs des reglages courants.
"""
self._ensure_loaded()
settings = get_settings()
if max_tokens is None:
max_tokens = settings.gemma_max_tokens
# En mode raisonnement, plafond dedie (garde-fou anti-boucle) ; la
# generation s'arrete de toute facon des que le JSON post-pensee est
# complet (cf. boucle de streaming ci-dessous).
if settings.gemma_reasoning:
max_tokens = max(max_tokens, settings.gemma_reasoning_max_tokens)
if temperature is None:
temperature = settings.gemma_temperature
# Decodage glouton (temp 0) + raisonnement = boucles de pensee sans fin.
# On force un echantillonnage minimal en mode raisonnement.
if settings.gemma_reasoning and temperature == 0.0:
temperature = settings.gemma_reasoning_temperature
from mlx_lm.sample_utils import make_sampler
messages = []
if system:
messages.append({"role": "system", "content": system})
messages.append({"role": "user", "content": prompt})
# Modeles hybrides (Qwen3...) : hors mode raisonnement, on DESACTIVE la
# pensee via enable_thinking=False -> JSON direct, bien plus rapide. Avec
# --reasoning, on laisse penser puis on retire la pensee en aval. Ce
# kwarg est ignore par les templates qui ne l'utilisent pas (Gemma...).
template_kwargs = {}
if not settings.gemma_reasoning:
template_kwargs["enable_thinking"] = False
formatted = self._tokenizer.apply_chat_template(
messages, add_generation_prompt=True, tokenize=False,
chat_template=self._chat_template, # None -> celui du tokenizer
**template_kwargs,
)
sampler = make_sampler(temp=temperature)
# On streame (token par token) si : un sink est branche (--stream) OU on
# est en mode raisonnement (pour pouvoir s'arreter des que la reponse est
# prete, sans subir les boucles de pensee sans fin). Sinon, lot rapide.
if _TOKEN_SINK is not None or settings.gemma_reasoning:
from mlx_lm import stream_generate
parts = []
seen_end = False # marqueur de fin de pensee rencontre
for resp in stream_generate(
self._model, self._tokenizer, prompt=formatted,
max_tokens=max_tokens, sampler=sampler,
):
parts.append(resp.text)
if _TOKEN_SINK is not None:
_TOKEN_SINK(resp.text)
# Arret anticipe : une fois la pensee close, des que le JSON
# post-pensee est complet, inutile de continuer a generer.
if settings.gemma_reasoning and ("}" in resp.text or "]" in resp.text):
buf = "".join(parts)
if not seen_end:
seen_end = any(mk in buf for mk in _REASONING_END_MARKERS)
if seen_end and _has_complete_json(_strip_reasoning(buf)):
break
if _TOKEN_SINK is not None:
_TOKEN_SINK("\n") # separe les generations successives
raw = "".join(parts)
else:
from mlx_lm import generate
raw = generate(
self._model,
self._tokenizer,
prompt=formatted,
max_tokens=max_tokens,
sampler=sampler,
verbose=False,
)
# Retire la chaine de pensee des modeles a raisonnement (sinon des
# fragments de la "pensee" parasitent l'extraction JSON en aval).
if settings.gemma_reasoning:
return _strip_reasoning(raw)
return raw
def generate_json(
self,
prompt: str,
*,
system: Optional[str] = None,
max_tokens: Optional[int] = None,
temperature: Optional[float] = None,
retries: int = 1,
) -> Any:
"""Genere puis parse un JSON. Reessaie en cas d'echec de parsing.
`max_tokens`/`temperature` non fournis -> valeurs des reglages courants.
"""
last_err: Optional[Exception] = None
for attempt in range(retries + 1):
raw = self.generate(
prompt, system=system, max_tokens=max_tokens,
temperature=temperature if attempt == 0 else 0.0,
)
try:
return _extract_json(raw)
except Exception as exc: # noqa: BLE001
last_err = exc
raise ValueError(f"Reponse JSON invalide apres {retries + 1} essais: {last_err}")
def _strip_reasoning(text: str) -> str:
"""Retire la chaine de pensee d'un modele a raisonnement.
Ne conserve que ce qui suit le dernier marqueur de fin de pensee
(`</think>`, `<channel|>`...). Si seul un marqueur d'ouverture non ferme
subsiste (pensee tronquee par le budget de tokens), on le retire en tete
pour eviter de parser la pensee a la place de la reponse.
"""
t = text
for marker in _REASONING_END_MARKERS:
if marker in t:
t = t.rsplit(marker, 1)[-1]
t = _REASONING_OPEN_RE.sub("", t)
return t.strip()
def _has_complete_json(text: str) -> bool:
"""True si `text` contient deja un objet/array JSON complet et parsable.
Sert a stopper la generation des modeles a raisonnement des que la reponse
finale est ecrite (evite de consommer le budget en boucles de pensee).
"""
try:
_extract_json(text)
return True
except Exception: # noqa: BLE001
return False
def _extract_json(text: str) -> Any:
"""Extrait le premier objet/array JSON d'une reponse libre du modele.
Tolere le texte parasite avant/apres (y compris un 2e bloc) grace a
raw_decode, qui s'arrete au premier JSON complet.
"""
text = text.strip()
fence = _FENCE_RE.search(text)
if fence:
text = fence.group(1).strip()
decoder = json.JSONDecoder()
# Cherche le 1er debut de structure JSON et decode a partir de la.
for i, ch in enumerate(text):
if ch in "[{":
try:
obj, _ = decoder.raw_decode(text[i:])
return obj
except json.JSONDecodeError:
continue
raise ValueError("aucun JSON trouve dans la reponse")

14
backend/inkflow/analysis/llm/__init__.py Normal file
View File

@@ -0,0 +1,14 @@
"""Client LLM pluggable pour l'analyse de texte (attribution, personnages...).
La facade `LLM` (client.py) expose `generate` / `generate_json` consommes par
tout le pipeline. Sous elle, un backend pluggable (`base.LLMBackend`) transforme
des messages en texte brut : `mlx_backend` (mlx-lm, defaut) ou `lmstudio_backend`
(API OpenAI locale de LM Studio, sert GGUF *et* MLX). Selection par nom via
`factory.get_llm_backend`.
"""
from __future__ import annotations
from .client import LLM, set_token_sink
from .factory import get_llm_backend, reset_llm_cache
__all__ = ["LLM", "set_token_sink", "get_llm_backend", "reset_llm_cache"]

74
backend/inkflow/analysis/llm/_text.py Normal file
View File

@@ -0,0 +1,74 @@
"""Helpers agnostiques du moteur : extraction JSON tolerante + retrait de la
chaine de pensee des modeles a raisonnement.
Module neutre (aucune dependance a un backend) : partage par la facade `LLM` et
par les backends (qui s'en servent pour l'arret anticipe en streaming), sans
creer de cycle d'import.
"""
from __future__ import annotations
import json
import re
from typing import Any
# Bornes d'un bloc JSON dans une reponse potentiellement bavarde.
_JSON_SPAN_RE = re.compile(r"(\{.*\}|\[.*\])", re.DOTALL)
_FENCE_RE = re.compile(r"```(?:json)?\s*(.*?)```", re.DOTALL)
# Marqueurs de FIN de chaine de pensee : on ne garde que ce qui suit le dernier.
# - balises type DeepSeek-R1 / Qwen-think
# - format a canaux type Gemma 4 / Harmony (la pensee est close par <channel|>)
_REASONING_END_MARKERS = ("</think>", "<channel|>", "<|channel|>")
# Prefixe de canal/think non ferme reste en tete (pensee tronquee) : a retirer.
_REASONING_OPEN_RE = re.compile(r"^\s*(?:<\|?channel\|?>\s*\w*|<think>)", re.IGNORECASE)
def _strip_reasoning(text: str) -> str:
"""Retire la chaine de pensee d'un modele a raisonnement.
Ne conserve que ce qui suit le dernier marqueur de fin de pensee
(`</think>`, `<channel|>`...). Si seul un marqueur d'ouverture non ferme
subsiste (pensee tronquee par le budget de tokens), on le retire en tete
pour eviter de parser la pensee a la place de la reponse.
"""
t = text
for marker in _REASONING_END_MARKERS:
if marker in t:
t = t.rsplit(marker, 1)[-1]
t = _REASONING_OPEN_RE.sub("", t)
return t.strip()
def _has_complete_json(text: str) -> bool:
"""True si `text` contient deja un objet/array JSON complet et parsable.
Sert a stopper la generation des modeles a raisonnement des que la reponse
finale est ecrite (evite de consumer le budget en boucles de pensee).
"""
try:
_extract_json(text)
return True
except Exception: # noqa: BLE001
return False
def _extract_json(text: str) -> Any:
"""Extrait le premier objet/array JSON d'une reponse libre du modele.
Tolere le texte parasite avant/apres (y compris un 2e bloc) grace a
raw_decode, qui s'arrete au premier JSON complet.
"""
text = text.strip()
fence = _FENCE_RE.search(text)
if fence:
text = fence.group(1).strip()
decoder = json.JSONDecoder()
# Cherche le 1er debut de structure JSON et decode a partir de la.
for i, ch in enumerate(text):
if ch in "[{":
try:
obj, _ = decoder.raw_decode(text[i:])
return obj
except json.JSONDecodeError:
continue
raise ValueError("aucun JSON trouve dans la reponse")

43
backend/inkflow/analysis/llm/base.py Normal file
View File

@@ -0,0 +1,43 @@
"""Abstraction des moteurs LLM (backend pluggable).
Calque du pattern TTS (`tts/base.py`) : un backend ne fait *qu'une* chose,
transformer une liste de messages (role/content) en texte brut. Toute la logique
agnostique (calcul des parametres depuis les Settings, retrait de la pensee,
extraction JSON tolerante, retries) vit dans la facade `client.LLM`, jamais
dupliquee par backend.
"""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Callable, Optional
class LLMBackend(ABC):
"""Interface commune a tous les moteurs LLM."""
name: str = "base"
def __init__(self, model_ref: str):
# Reference du modele, interpretee par le backend : id mlx-community
# (mlx) ou nom du modele charge dans LM Studio (lmstudio, vide -> actif).
self.model_ref = model_ref
@abstractmethod
def complete(
self,
messages: list[dict],
*,
max_tokens: int,
temperature: float,
reasoning: bool,
token_sink: Optional[Callable[[str], None]] = None,
) -> str:
"""Genere et renvoie le texte BRUT (chaine de pensee incluse).
- `messages` : liste {role, content} (system optionnel + user).
- `reasoning` : si vrai, le modele peut emettre une chaine de pensee ;
le backend peut s'arreter des que le JSON post-pensee est complet. La
facade retire la pensee en aval (`_strip_reasoning`).
- `token_sink` : si fourni, appele avec chaque morceau de texte au fil de
la generation (streaming pour `inkflow benchmark --stream`).
"""

119
backend/inkflow/analysis/llm/client.py Normal file
View File

@@ -0,0 +1,119 @@
"""Facade LLM pour l'analyse de texte (anciennement `Gemma`).
Charge un backend pluggable (mlx par defaut, ou LM Studio) selon les reglages et
expose `generate` / `generate_json` consommes par tout le pipeline. Toute la
logique agnostique du moteur vit ici : calcul des parametres depuis les Settings,
retrait de la chaine de pensee (modeles a raisonnement) et `generate_json`
tolerant qui extrait le premier objet/array JSON valide de la sortie du modele.
"""
from __future__ import annotations
from typing import Any, Optional
from ...settings import Settings, get_settings
from ._text import _extract_json, _strip_reasoning
from .factory import get_llm_backend
# Hook de streaming optionnel. Si defini, `generate()` diffuse chaque morceau de
# texte AU FIL de la generation (pensee comprise, avant tout nettoyage) en
# appelant ce callback. Utilise par `inkflow benchmark --stream` pour voir les
# tokens en temps reel. None -> generation par lot classique (plus rapide).
_TOKEN_SINK: Optional[Any] = None
def set_token_sink(callback) -> None:
"""Definit (ou retire avec None) le callback de streaming des tokens."""
global _TOKEN_SINK
_TOKEN_SINK = callback
def _model_ref_for(backend: str, settings: Settings) -> str:
"""Reference de modele par defaut pour un backend donne."""
if backend == "lmstudio":
return settings.lmstudio_model
return settings.gemma_model
class LLM:
"""Petite facade multi-backend pour piloter le LLM d'analyse."""
def __init__(self, model_id: Optional[str] = None, backend: Optional[str] = None):
settings = get_settings()
self.backend_name = backend or settings.gemma_backend
self.model_ref = model_id or _model_ref_for(self.backend_name, settings)
self._backend = None
def _ensure_loaded(self) -> None:
if self._backend is None:
self._backend = get_llm_backend(self.backend_name, self.model_ref)
def generate(
self,
prompt: str,
*,
system: Optional[str] = None,
max_tokens: Optional[int] = None,
temperature: Optional[float] = None,
) -> str:
"""Genere une reponse texte a partir d'un prompt (template de chat).
`max_tokens`/`temperature` non fournis -> valeurs des reglages courants.
"""
self._ensure_loaded()
settings = get_settings()
if max_tokens is None:
max_tokens = settings.gemma_max_tokens
# En mode raisonnement, plafond dedie (garde-fou anti-boucle) ; la
# generation s'arrete de toute facon des que le JSON post-pensee est
# complet (cf. arret anticipe des backends).
if settings.gemma_reasoning:
max_tokens = max(max_tokens, settings.gemma_reasoning_max_tokens)
if temperature is None:
temperature = settings.gemma_temperature
# Decodage glouton (temp 0) + raisonnement = boucles de pensee sans fin.
# On force un echantillonnage minimal en mode raisonnement.
if settings.gemma_reasoning and temperature == 0.0:
temperature = settings.gemma_reasoning_temperature
messages = []
if system:
messages.append({"role": "system", "content": system})
messages.append({"role": "user", "content": prompt})
raw = self._backend.complete(
messages,
max_tokens=max_tokens,
temperature=temperature,
reasoning=settings.gemma_reasoning,
token_sink=_TOKEN_SINK,
)
# Retire la chaine de pensee des modeles a raisonnement (sinon des
# fragments de la "pensee" parasitent l'extraction JSON en aval).
if settings.gemma_reasoning:
return _strip_reasoning(raw)
return raw
def generate_json(
self,
prompt: str,
*,
system: Optional[str] = None,
max_tokens: Optional[int] = None,
temperature: Optional[float] = None,
retries: int = 1,
) -> Any:
"""Genere puis parse un JSON. Reessaie en cas d'echec de parsing.
`max_tokens`/`temperature` non fournis -> valeurs des reglages courants.
"""
last_err: Optional[Exception] = None
for attempt in range(retries + 1):
raw = self.generate(
prompt, system=system, max_tokens=max_tokens,
temperature=temperature if attempt == 0 else 0.0,
)
try:
return _extract_json(raw)
except Exception as exc: # noqa: BLE001
last_err = exc
raise ValueError(f"Reponse JSON invalide apres {retries + 1} essais: {last_err}")

36
backend/inkflow/analysis/llm/factory.py Normal file
View File

@@ -0,0 +1,36 @@
"""Selection du backend LLM par nom (pluggable).
Calque de `tts/factory.py` : cache par (nom, reference de modele). Une
sauvegarde des reglages (settings.save_settings) appelle `reset_llm_cache()`
pour que les changements de backend/modele prennent effet sans redemarrage.
"""
from __future__ import annotations
from functools import lru_cache
from .base import LLMBackend
BACKENDS = ("mlx", "lmstudio")
@lru_cache(maxsize=4)
def get_llm_backend(backend: str = "mlx", model_ref: str = "") -> LLMBackend:
backend = backend.lower()
if backend == "mlx":
from .mlx_backend import MLXBackend
return MLXBackend(model_ref)
if backend == "lmstudio":
from .lmstudio_backend import LMStudioBackend
return LMStudioBackend(model_ref)
raise ValueError(
f"Backend LLM inconnu: {backend!r} (dispo: {', '.join(BACKENDS)})")
def reset_llm_cache() -> None:
"""Vide les instances de backend et le cache de chargement mlx."""
get_llm_backend.cache_clear()
try:
from .mlx_backend import _load
_load.cache_clear()
except Exception: # noqa: BLE001
pass

171
backend/inkflow/analysis/llm/lmstudio_backend.py Normal file
View File

@@ -0,0 +1,171 @@
"""Backend LLM via LM Studio (API OpenAI locale).
LM Studio sert indifferemment des modeles GGUF *et* MLX charges depuis sa GUI,
exposes sur un endpoint OpenAI-compatible (`http://127.0.0.1:1234/v1` par
defaut). InkFlow ne fait que parler HTTP : zero dependance native a compiler, et
le modele reste charge entre redemarrages d'InkFlow.
Caveat : `enable_thinking=False` (coupe la pensee des modeles hybrides cote mlx)
n'est pas pilotable de facon fiable via l'API ; le template embarque decide. En
mode non-raisonnement on prend le `content` final et on le strip de toute facon.
"""
from __future__ import annotations
import os
from typing import Callable, Optional
from .base import LLMBackend
from ._text import _has_complete_json, _strip_reasoning
from ...settings import get_settings
def list_models(base_url: str) -> list[dict]:
"""Liste les modeles LLM *telecharges* dans LM Studio (charges ou non).
Utilise l'API REST native (`/api/v0/models`) et non `/v1/models` (qui ne
renvoie que les modeles deja charges) : on peut ainsi proposer n'importe quel
modele telecharge ; LM Studio le charge a la volee (JIT) a la 1re requete.
Renvoie [{id, state, type}] filtre sur les LLM/VLM. Leve en cas d'echec.
"""
import httpx
root = base_url.rstrip("/")
if root.endswith("/v1"):
root = root[:-len("/v1")]
resp = httpx.get(f"{root}/api/v0/models", timeout=5.0)
resp.raise_for_status()
data = resp.json().get("data", [])
return [
{"id": m.get("id"), "state": m.get("state"), "type": m.get("type")}
for m in data if m.get("type") in ("llm", "vlm")
]
class LMStudioBackend(LLMBackend):
"""Moteur LM Studio : client OpenAI pointe sur le serveur local."""
name = "lmstudio"
def __init__(self, model_ref: str):
super().__init__(model_ref)
self._client = None
self._model = None # resolu paresseusement (model_ref vide -> modele actif)
def _ensure_client(self):
if self._client is None:
try:
from openai import OpenAI
except ImportError as exc: # noqa: BLE001
raise RuntimeError(
"Le paquet `openai` est requis pour le backend LM Studio "
"(pip install -e backend)."
) from exc
base_url = get_settings().lmstudio_base_url
# api_key factice : LM Studio n'authentifie pas, mais le SDK l'exige.
self._client = OpenAI(base_url=base_url, api_key="lm-studio")
return self._client
def _resolve_model(self, client) -> str:
"""Renvoie le nom de modele a utiliser (model_ref, ou 1er modele charge)."""
if self.model_ref:
return self.model_ref
if self._model is None:
try:
models = client.models.list()
except Exception as exc: # noqa: BLE001
raise self._connection_error(exc) from exc
ids = [m.id for m in getattr(models, "data", [])]
if not ids:
raise RuntimeError(
"Aucun modele charge dans LM Studio : charge un modele "
"(GGUF ou MLX) dans l'app avant de lancer l'analyse."
)
self._model = ids[0]
return self._model
def _connection_error(self, exc: Exception) -> RuntimeError:
url = get_settings().lmstudio_base_url
return RuntimeError(
f"LM Studio injoignable sur {url} — lance l'application et active le "
f"serveur local (onglet Developer > Start Server). Detail: {exc}"
)
def _sampling(self, max_tokens: int, temperature: float) -> dict:
"""Params de sampling a transmettre a LM Studio.
Par defaut (`lmstudio_defer_config=True`) : dict VIDE -> on delegue
temperature ET plafond de tokens a la config du modele charge dans LM
Studio (ne pas imposer `max_tokens` evite de tronquer la reponse, ce qui
cassait les modeles a raisonnement). Le contexte est de toute facon gere
au chargement cote LM Studio. Si l'utilisateur desactive la delegation,
on reimpose les reglages "Generation Gemma" d'InkFlow.
"""
if get_settings().lmstudio_defer_config:
return {}
return {"temperature": temperature, "max_tokens": max_tokens}
def complete(
self,
messages: list[dict],
*,
max_tokens: int,
temperature: float,
reasoning: bool,
token_sink: Optional[Callable[[str], None]] = None,
) -> str:
client = self._ensure_client()
model = self._resolve_model(client)
sampling = self._sampling(max_tokens, temperature)
# Prefill optionnel de la reponse assistant (INKFLOW_LMSTUDIO_PREFILL) :
# ex. "<think></think>" force les modeles distilles a raisonnement (Qwen)
# a sauter la pensee (seul levier efficace quand enable_thinking/_no_think
# sont ignores). Le modele continue a partir du prefill -> JSON direct.
prefill = os.environ.get("INKFLOW_LMSTUDIO_PREFILL")
if prefill:
messages = messages + [{"role": "assistant", "content": prefill}]
from openai import APIConnectionError
# LM Studio separe la pensee (`reasoning_content`) de la reponse finale
# (`content`, deja propre). On ne renvoie QUE `content` : la facade en
# extrait le JSON. La pensee n'est diffusee qu'au `token_sink` (affichage
# --stream) ; l'inclure dans le retour risquerait de capter un JSON
# d'exemple present dans le raisonnement. Pour les modeles qui mettent au
# contraire la pensee INLINE dans `content` (<think>...), la facade la
# retire via _strip_reasoning quand reasoning=True.
if token_sink is not None or reasoning:
content_parts: list[str] = []
try:
stream = client.chat.completions.create(
model=model, messages=messages, stream=True, **sampling,
)
for chunk in stream:
if not chunk.choices:
continue
delta = chunk.choices[0].delta
rc = getattr(delta, "reasoning_content", None)
if rc and token_sink is not None:
token_sink(rc) # pensee : affichage seulement
piece = delta.content or ""
if piece:
content_parts.append(piece)
if token_sink is not None:
token_sink(piece)
# Arret anticipe en mode raisonnement : des que la reponse
# finale (content) contient un JSON complet, inutile de
# continuer (certains modeles divaguent ensuite).
if reasoning and piece and ("}" in piece or "]" in piece):
if _has_complete_json(_strip_reasoning("".join(content_parts))):
break
except APIConnectionError as exc:
raise self._connection_error(exc) from exc
if token_sink is not None:
token_sink("\n") # separe les generations successives
return "".join(content_parts)
try:
resp = client.chat.completions.create(
model=model, messages=messages, **sampling,
)
except APIConnectionError as exc:
raise self._connection_error(exc) from exc
return resp.choices[0].message.content or ""

127
backend/inkflow/analysis/llm/mlx_backend.py Normal file
View File

@@ -0,0 +1,127 @@
"""Backend LLM mlx-lm (Apple Silicon) — moteur historique d'InkFlow.
Charge un modele mlx-community paresseusement (une fois par process, cache LRU)
et genere via le template de chat du tokenizer. Comportement strictement
identique a l'ancien `Gemma.generate` : controle fin de `enable_thinking`,
streaming avec arret anticipe des que le JSON post-pensee est complet.
"""
from __future__ import annotations
import json
from functools import lru_cache
from typing import Callable, Optional
from .base import LLMBackend
from ._text import _REASONING_END_MARKERS, _has_complete_json, _strip_reasoning
@lru_cache(maxsize=2)
def _load(model_id: str):
# Import paresseux : evite de charger mlx tant qu'on n'analyse pas.
from mlx_lm import load
return load(model_id)
def _resolve_chat_template(model_id: str, tokenizer) -> Optional[str]:
"""Renvoie un template de chat a passer explicitement, ou None.
Certaines conversions (Mistral recents...) logent leur template dans un
fichier `chat_template.jinja` que le downloader de mlx-lm n'embarque pas
toujours : `tokenizer.chat_template` est alors vide et `apply_chat_template`
echoue. On recupere alors le fichier officiel du repo. None si le tokenizer
possede deja un template (cas courant) ou si aucun n'est disponible.
"""
if getattr(tokenizer, "chat_template", None):
return None
from pathlib import Path
from huggingface_hub import hf_hub_download
# Selon les conversions : fichier Jinja brut, ou JSON {"chat_template": ...}.
for fname in ("chat_template.jinja", "chat_template.json"):
try:
text = Path(hf_hub_download(model_id, fname)).read_text(encoding="utf-8")
except Exception: # noqa: BLE001 — fichier absent, on tente le suivant
continue
if fname.endswith(".json"):
data = json.loads(text)
return data.get("chat_template") if isinstance(data, dict) else None
return text
return None # aucun template dispo -> apply_chat_template levera une erreur claire
class MLXBackend(LLMBackend):
"""Moteur mlx-lm : modeles mlx-community (HuggingFace) sur Apple Silicon."""
name = "mlx"
def __init__(self, model_ref: str):
super().__init__(model_ref)
self._model = None
self._tokenizer = None
self._chat_template = None # template recupere si absent du tokenizer
def _ensure_loaded(self) -> None:
if self._model is None:
self._model, self._tokenizer = _load(self.model_ref)
self._chat_template = _resolve_chat_template(
self.model_ref, self._tokenizer)
def complete(
self,
messages: list[dict],
*,
max_tokens: int,
temperature: float,
reasoning: bool,
token_sink: Optional[Callable[[str], None]] = None,
) -> str:
self._ensure_loaded()
from mlx_lm.sample_utils import make_sampler
# Modeles hybrides (Qwen3...) : hors mode raisonnement, on DESACTIVE la
# pensee via enable_thinking=False -> JSON direct, bien plus rapide. Avec
# raisonnement, on laisse penser puis la facade retire la pensee. Ce
# kwarg est ignore par les templates qui ne l'utilisent pas (Gemma...).
template_kwargs = {}
if not reasoning:
template_kwargs["enable_thinking"] = False
formatted = self._tokenizer.apply_chat_template(
messages, add_generation_prompt=True, tokenize=False,
chat_template=self._chat_template, # None -> celui du tokenizer
**template_kwargs,
)
sampler = make_sampler(temp=temperature)
# On streame (token par token) si : un sink est branche (--stream) OU on
# est en mode raisonnement (pour pouvoir s'arreter des que la reponse est
# prete, sans subir les boucles de pensee sans fin). Sinon, lot rapide.
if token_sink is not None or reasoning:
from mlx_lm import stream_generate
parts = []
seen_end = False # marqueur de fin de pensee rencontre
for resp in stream_generate(
self._model, self._tokenizer, prompt=formatted,
max_tokens=max_tokens, sampler=sampler,
):
parts.append(resp.text)
if token_sink is not None:
token_sink(resp.text)
# Arret anticipe : une fois la pensee close, des que le JSON
# post-pensee est complet, inutile de continuer a generer.
if reasoning and ("}" in resp.text or "]" in resp.text):
buf = "".join(parts)
if not seen_end:
seen_end = any(mk in buf for mk in _REASONING_END_MARKERS)
if seen_end and _has_complete_json(_strip_reasoning(buf)):
break
if token_sink is not None:
token_sink("\n") # separe les generations successives
return "".join(parts)
from mlx_lm import generate
return generate(
self._model,
self._tokenizer,
prompt=formatted,
max_tokens=max_tokens,
sampler=sampler,
verbose=False,
)

4
backend/inkflow/analysis/pronunciation.py
View File

@@ -11,7 +11,7 @@ from typing import Iterable
from ..models import Pronunciation, PronunciationEntry
from ..settings import get_settings
from .gemma import Gemma
from .llm.client import LLM
def apply_pronunciation(text: str, pron: Pronunciation) -> str:
@@ -27,7 +27,7 @@ def apply_pronunciation(text: str, pron: Pronunciation) -> str:
# Le prompt systeme est editable dans les reglages (settings.prompt_pronunciation).
def propose_pronunciations(text: str, gemma: Gemma, *, max_chars: int = 16000) -> list[PronunciationEntry]:
def propose_pronunciations(text: str, gemma: LLM, *, max_chars: int = 16000) -> list[PronunciationEntry]:
"""Propose des candidats de prononciation a valider."""
sample = text[:max_chars]
prompt = (

345
backend/inkflow/analysis/segmenter.py
View File

@@ -25,7 +25,7 @@ from ..models import (
SegmentType,
)
from ..settings import get_settings
from .gemma import Gemma
from .llm.client import LLM
# Un paragraphe de dialogue commence par un cadratin (U+2014) ou un tiret long.
_DIALOGUE_LEAD_RE = re.compile(r"^\s*[—―]\s*")
@@ -65,7 +65,7 @@ _CHUNK_MAX_DIALOGUES = 30 # repliques par appel (fiabilite du modele)
def attribute_speakers(
segments: list[Segment],
gemma: Gemma,
gemma: LLM,
*,
characters: Optional[list[Character]] = None,
pov: Optional[str] = None,
@@ -211,7 +211,7 @@ def _chunk_dialogues(
def _refine_unknown_speakers(
segments: list[Segment],
gemma: Gemma,
gemma: LLM,
*,
characters: Optional[list[Character]] = None,
confidence: dict[int, str],
@@ -276,11 +276,237 @@ def _refine_unknown_speakers(
segments[seg_idx].speaker = new
# --- Post-traitement deterministe (sans LLM) --------------------------------
# Traductions FR pour construire l'identite d'un locuteur anonyme.
_ANON_GENDER_FR = {"male": "homme", "female": "femme"}
_ANON_AGE_FR = {"child": "enfant", "young": "jeune", "adult": "adulte", "old": "vieux"}
def _anon_identity(gender: Optional[str], age: Optional[str]) -> str:
"""Identite canonique d'un locuteur anonyme, regroupe par (genre, age).
Ex: ("male", "adult") -> "anonyme (homme, adulte)" ; ("male", None) ->
"anonyme (homme)" ; (None, None) -> "anonyme". Tous les personnages-fonction
d'un meme bucket partagent une voix (genre/age suffisent a la choisir)."""
g = _ANON_GENDER_FR.get((gender or "").lower())
a = _ANON_AGE_FR.get((age or "").lower())
parts = [p for p in (g, a) if p]
return f"anonyme ({', '.join(parts)})" if parts else "anonyme"
def _apply_anonymous_speakers(
segments: list[Segment], *, names=None) -> dict[str, tuple[Optional[str], Optional[str]]]:
"""Rattache les repliques a incise de role a un locuteur ANONYME par genre/age.
Une incise "informa le soldat" -> "anonyme (homme)" : on ne stocke pas la
fonction (garde/marine...), seuls genre+age comptent pour la voix. Genre/age
deduits du nom de role (`_ROLE_GENDER`/`_ROLE_AGE`). Applique APRES le LLM
(autorite deterministe), sans modifier le prompt. Mutation en place.
Renvoie {identite_anonyme: (genre, age)} des buckets utilises, pour que
l'appelant cree les `Character` generiques correspondants (assignation voix)."""
names = names or set()
used: dict[str, tuple[Optional[str], Optional[str]]] = {}
for seg in segments:
if seg.type is not SegmentType.DIALOGUE:
continue
for inc in seg.incises:
role = incise_role(seg.text, inc, names)
if role:
gender = _ROLE_GENDER.get(role)
age = _ROLE_AGE.get(role)
ident = _anon_identity(gender, age)
seg.speaker = ident
used[ident] = (gender, age)
break
return used
def _inversion_gender(text: str) -> Optional[str]:
"""Genre porte par le pronom d'une incise d'inversion ("demanda-t-elle" ->
female, "dit-il" -> male). None si aucune inversion. Signal sur LE locuteur."""
m = _INV_GENDER_RE.search(text)
if not m:
return None
return "female" if m.group("p").lower().startswith("elle") else "male"
def _resolve_anonymous_figurants(
segments: list[Segment]) -> dict[str, tuple[Optional[str], Optional[str]]]:
"""Resout les repliques restees INDETERMINEES (inconnu/?) en figurants anonymes.
Quand une replique non resolue est entouree d'une narration decrivant un
figurant genre ("La femme...", "La jeune marine...", "Le soldat..."), on
l'attribue au bucket anonyme correspondant. Genre : pronom d'inversion de la
replique ("demanda-t-elle") sinon l'article du role dans la narration
(la/une -> femme, le/un -> homme). N'agit QUE sur l'indetermine (jamais sur
une attribution sure) -> sans risque pour les personnages nommes. Mutation en
place ; renvoie les buckets crees (pour creer les Character generiques)."""
used: dict[str, tuple[Optional[str], Optional[str]]] = {}
for idx, seg in enumerate(segments):
if seg.type is not SegmentType.DIALOGUE or _is_resolved(seg.speaker):
continue
narr_gender = role_age = None
found = False
for j in (idx - 1, idx + 1): # narration adjacente (avant puis apres)
if 0 <= j < len(segments) and segments[j].type is SegmentType.NARRATION:
m = _ANON_NARR_RE.search(segments[j].text)
if m:
found = True
art = m.group("art").lower().rstrip("’'")
narr_gender = "female" if art in ("la", "une") else "male"
role_age = _ROLE_AGE.get(m.group("role").lower())
break
if not found:
continue
gender = _inversion_gender(seg.text) or narr_gender
ident = _anon_identity(gender, role_age)
seg.speaker = ident
used[ident] = (gender, role_age)
return used
def _canonicalize_speakers(segments: list[Segment], chars: list[Character]) -> None:
"""Reecrit chaque locuteur variant vers le nom canonique du cast.
Le LLM emet souvent des variantes hors liste ("Amiral Mehmet Sagale" pour
"Sagale", "Elvi Okoye" pour "Elvi"). Non rattachees, elles cassent le rendu
(mauvaise voix -> repli narrateur) et le score. On les recolle au canonique
via `heuristic_match` (primitive sure du dedup) : on n'agit QUE sur un match
certain (`Character`), on s'abstient sur ambiguite/inconnu. Pur, sans LLM,
ne touche pas au prompt. Ordre-independant : `tokfreq` calcule globalement.
Idempotent (un nom deja canonique matche en exact)."""
from ..casting.dedup import heuristic_match, _token_freq
spoken = [s.speaker for s in segments
if s.type is SegmentType.DIALOGUE and _is_resolved(s.speaker)]
if not spoken or not chars:
return
tokfreq = _token_freq(chars, spoken)
for seg in segments:
if seg.type is not SegmentType.DIALOGUE or not _is_resolved(seg.speaker):
continue
match = heuristic_match(seg.speaker, chars, tokfreq)
if isinstance(match, Character):
seg.speaker = match.name
# --- Passe deterministe : reparation de l'alternance des tours ---------------
def _norm_name(name: str) -> str:
return (name or "").strip().casefold()
# Tolerance de narration intercalee entre deux repliques d'un meme run. STRICT
# (0) : seules les repliques d'indices consecutifs forment un run. Toute valeur
# >0 est DANGEREUSE : une narration peut porter une *continuation du meme
# locuteur* ("— …", "Fayez marqua une pause.", "— …") ou il reparle ; verifie
# sur ch06 (runs 66-79 et 83-90 de la reference NON alternes des GAP=1). On
# prefere ne pas reparer une replique isolee que d'inventer une fausse alternance.
_RUN_MAX_NARRATION_GAP = 0
def _dialogue_runs(segments: list[Segment]) -> list[list[int]]:
"""Suites de repliques d'indices consecutifs (aucune narration intercalee).
Hypothese (verifiee sur les references ch05 ET ch06, 0 contre-exemple) : dans
une telle salve ou chaque cadratin marque un changement de locuteur, les
tours alternent strictement. Des qu'une narration s'intercale, l'alternance
n'est plus garantie (continuation possible du meme locuteur) -> nouveau run."""
runs: list[list[int]] = []
cur: list[int] = []
gap = 0
for i, s in enumerate(segments):
if s.type is SegmentType.DIALOGUE:
cur.append(i)
gap = 0
else:
gap += 1
if gap > _RUN_MAX_NARRATION_GAP:
if len(cur) >= 2:
runs.append(cur)
cur = []
if len(cur) >= 2:
runs.append(cur)
return runs
def _repair_alternation(segments: list[Segment], *, names=None) -> None:
"""Force l'alternance des tours dans les echanges a exactement 2 locuteurs.
Pour chaque suite de repliques consecutives a deux locuteurs, on retient,
parmi les deux motifs alternes possibles (A/B/A… ou B/A/B…), celui qui :
1. ne contredit aucune ancre sure (locuteur explicite d'incise nominale) ;
2. exige le moins de corrections au resultat de la 1re passe.
On n'agit qu'avec un gagnant STRICT, sinon on s'abstient (on prefere laisser
une erreur qu'en introduire une). En particulier, des qu'un 3e locuteur (meme
minoritaire) apparait dans le run, on ne touche a rien : un echange a >=3
n'alterne pas forcement. Pur, sans appel LLM ; comble aussi les repliques
indeterminees du run.
"""
names = names or set()
for run in _dialogue_runs(segments):
speakers = [segments[i].speaker for i in run]
resolved = {_norm_name(s) for s in speakers if _is_resolved(s)}
if len(resolved) != 2:
continue
# Noms canoniques (1re occurrence de chaque forme normalisee).
order: list[str] = []
for s in speakers:
n = _norm_name(s)
if n in resolved and n not in order:
order.append(n)
name_a, name_b = order[0], order[1]
canon_of = {}
for s in speakers:
n = _norm_name(s)
if n in resolved:
canon_of.setdefault(n, s.strip())
# Ancres sures : locuteur explicite d'une incise nominale.
anchors: dict[int, str] = {}
for k, idx in enumerate(run):
seg = segments[idx]
for inc in seg.incises:
spk = incise_speaker(seg.text, inc, names)
if spk:
anchors[k] = _norm_name(spk)
break
# Une ancre nommant un tiers (hors paire) -> run suspect, on s'abstient.
if any(a not in (name_a, name_b) for a in anchors.values()):
continue
def pattern(start: str) -> list[str]:
other = name_b if start == name_a else name_a
return [start if k % 2 == 0 else other for k in range(len(run))]
candidates = [pattern(name_a), pattern(name_b)]
admissible = [p for p in candidates
if all(p[k] == a for k, a in anchors.items())]
if not admissible:
continue
def cost(p: list[str]) -> int: # corrections sur les repliques resolues
return sum(1 for k, idx in enumerate(run)
if _is_resolved(segments[idx].speaker)
and _norm_name(segments[idx].speaker) != p[k])
admissible.sort(key=cost)
if len(admissible) == 2 and cost(admissible[0]) == cost(admissible[1]):
continue # ex aequo sans ancre discriminante -> trop ambigu
chosen = admissible[0]
for k, idx in enumerate(run):
segments[idx].speaker = canon_of[chosen[k]]
# --- Extraction du casting (Gemma) ------------------------------------------
# Le prompt systeme est editable dans les reglages (settings.prompt_characters).
def extract_characters(text: str, gemma: Gemma) -> list[Character]:
def extract_characters(text: str, gemma: LLM) -> list[Character]:
"""Extrait les personnages et leurs attributs (genre, age) d'un texte."""
prompt = (
"A partir de l'extrait suivant, liste les personnages qui parlent ou "
@@ -374,17 +600,52 @@ _SPEECH_VERBS = {
"tempeta", "rétorque", "lâche", "informa", "renseigna", "indiqua",
"rappela", "avertit", "prévint", "prevint", "intima", "rétorquait",
"lançait", "questionnait", "reconnut", "constata", "répéta", "repeta",
"intervint", "intervient", "renchérissait",
}
# Noms de role pouvant etre sujet d'une incise ("informa le soldat").
# Noms de role (FONCTION) pouvant etre sujet d'une incise ("informa le soldat").
# On EXCLUT volontairement les rangs/titres (amiral, capitaine, lieutenant...) :
# ils precedent presque toujours un nom propre ("dit l'amiral Sagale") -> ce
# n'est pas un figurant anonyme mais une personne nommee ; les laisser ici ferait
# capter le titre au lieu du nom. Le nom propre est alors capte normalement.
_ROLE_NOUNS = {
"garde", "soldat", "sentinelle", "gardien", "prêtre", "pretre", "homme",
"femme", "fille", "garçon", "garcon", "vieille", "vieillard", "capitaine",
"lieutenant", "sergent", "général", "general", "amiral", "officier", "voix",
"femme", "fille", "garçon", "garcon", "vieille", "vieillard", "voix",
"inconnu", "inconnue", "étranger", "etranger", "enfant", "serviteur",
"servante", "messager", "domestique", "médecin", "medecin",
"servante", "messager", "domestique", "médecin", "medecin", "marine", "marin",
}
# Genre/age probables d'un personnage-fonction, pour l'attribuer a un locuteur
# anonyme regroupe (voix par genre/age). On ne mappe QUE les cas ou le genre de
# la PERSONNE est fortement implique (roles militaires/masculins, feminins
# explicites) ; les cas ambigus (medecin, officier, voix, sentinelle...) restent
# inconnus -> bucket "anonyme" generique. Mieux vaut un genre inconnu qu'errone.
_ROLE_GENDER = {
"soldat": "male", "garde": "male", "gardien": "male", "marine": "male",
"marin": "male", "homme": "male", "garçon": "male", "garcon": "male",
"vieillard": "male", "serviteur": "male", "messager": "male",
"prêtre": "male", "pretre": "male",
"femme": "female", "fille": "female", "servante": "female",
"vieille": "female", "inconnue": "female",
}
# Age probable (rare : seul "enfant" le donne nettement).
_ROLE_AGE = {
"enfant": "child", "garçon": "child", "garcon": "child",
"fille": "child", "vieillard": "old", "vieille": "old",
}
# Genre du pronom d'une incise d'inversion ("-t-elle"/"-il"). "-" => inversion.
_INV_GENDER_RE = re.compile(r"-(?:t-)?(?P<p>ils?|elles?)\b", re.IGNORECASE)
# Figurant genre decrit dans la narration : article (genre) + nom de role proche.
# Ex: "La femme", "La jeune marine", "Le soldat". Sert a resoudre une replique
# indeterminee en anonyme (cf. `_resolve_anonymous_figurants`).
_ANON_NARR_RE = re.compile(
r"\b(?P<art>la|le|une|un)\s+(?:[\wÀ-ÿ’'-]+\s+){0,2}?"
r"(?P<role>" + "|".join(re.escape(r) for r in sorted(_ROLE_NOUNS, key=len, reverse=True)) + r")\b",
re.IGNORECASE,
)
# Mots vides ignores quand on indexe les tokens d'un nom de personnage.
_NAME_STOP = {
"le", "la", "les", "un", "une", "de", "du", "des", "monsieur", "madame",
@@ -446,12 +707,14 @@ _REJECT = object() # le sujet n'en est pas un -> pas une incise
def _classify_subject(subj: str, idx: dict[str, str]):
"""Locuteur porte par le sujet d'une incise nominale.
"""Locuteur NOMME porte par le sujet d'une incise nominale.
- personnage connu -> nom canonique ;
- nom propre (capitalise) inconnu -> nom de surface (seed quand meme : le
texte le nomme, independamment de la fiabilite de l'extraction) ;
- nom de role generique ("le soldat") -> None (incise reelle, pas de seed) ;
- nom de role ("le soldat") -> None : pas un locuteur NOMME. L'incise reste
detectee (narration), et le rattachement a un anonyme (par genre/age) se
fait en post-traitement (cf. `_apply_anonymous_speakers` / `incise_role`) ;
- mot quelconque -> _REJECT (pas une incise).
"""
low = subj.lower()
@@ -464,11 +727,14 @@ def _classify_subject(subj: str, idx: dict[str, str]):
return _REJECT
def _nominal_matches(text: str, names) -> list[tuple[int, int, Optional[str]]]:
"""Passe 2 : (start, end, locuteur) pour chaque incise nominale.
def _nominal_matches(text: str, names
) -> list[tuple[int, int, Optional[str], str]]:
"""Passe 2 : (start, end, locuteur, sujet) pour chaque incise nominale.
Une incise nominale = verbe de parole + sujet (nom du casting, nom propre,
ou nom de role). Le sujet nom propre est seede meme absent du casting.
Le 4e champ est le sujet (minuscule) : sert a reconnaitre un nom de role
(`incise_role`) pour rattacher un locuteur anonyme par genre/age.
"""
idx = _name_token_index(names)
literals = sorted(set(idx) | _ROLE_NOUNS, key=len, reverse=True)
@@ -486,13 +752,15 @@ def _nominal_matches(text: str, names) -> list[tuple[int, int, Optional[str]]]:
r"[^.!?…»\",;]*?)"
r"(?P<close>[.!?…,])",
)
out: list[tuple[int, int, Optional[str]]] = []
out: list[tuple[int, int, Optional[str], str]] = []
for m in pat.finditer(text):
spk = _classify_subject(m.group("subj"), idx)
subj = m.group("subj")
spk = _classify_subject(subj, idx)
if spk is _REJECT:
continue
out.append((m.start("inc"),
_incise_end(text, m.end("close"), m.group("lead")), spk))
_incise_end(text, m.end("close"), m.group("lead")),
spk, subj.lower()))
return out
@@ -511,18 +779,33 @@ def _merge_spans(spans: list[tuple[int, int]]) -> list[Incise]:
def detect_incises(text: str, *, names=None) -> list[Incise]:
"""Bornes des incises dans une replique (inversion + nominale cast-aware)."""
spans = _inversion_spans(text)
spans += [(s, e) for s, e, _ in _nominal_matches(text, names or set())]
spans += [(s, e) for s, e, _, _ in _nominal_matches(text, names or set())]
return _merge_spans(spans)
def incise_speaker(text: str, incise: Incise, names) -> Optional[str]:
"""Locuteur explicite porte par une incise nominale ("compatit Holden")."""
for s, e, spk in _nominal_matches(text, names):
"""Locuteur NOMME explicite porte par une incise nominale ("compatit Holden").
None pour une incise de role ("informa le soldat") : un role n'est pas un
locuteur nomme (cf. `incise_role` pour le rattachement anonyme).
"""
for s, e, spk, _ in _nominal_matches(text, names):
if s == incise.start and e == incise.end:
return spk
return None
def incise_role(text: str, incise: Incise, names) -> Optional[str]:
"""Nom de role (minuscule) sujet d'une incise ("informa le soldat" -> "soldat").
Renvoie None si l'incise n'est pas une incise de role. Sert a rattacher la
replique a un locuteur anonyme regroupe par genre/age (cf. `_anon_identity`)."""
for s, e, _spk, subj in _nominal_matches(text, names):
if s == incise.start and e == incise.end and subj in _ROLE_NOUNS:
return subj
return None
def iter_incise_pieces(
text: str, incises: list[Incise]
) -> list[tuple[bool, str]]:
@@ -552,10 +835,10 @@ def iter_incise_pieces(
def analyze_chapter(
chapter: Chapter,
ct: ChapterText,
gemma: Gemma,
gemma: LLM,
*,
book_chars: Optional[list[Character]] = None,
dedup_gemma: Optional[Gemma] = None,
dedup_gemma: Optional[LLM] = None,
) -> tuple[ChapterAnalysis, list[Character]]:
"""Analyse complete d'un chapitre.
@@ -594,12 +877,18 @@ def analyze_chapter(
# Annotation deterministe des incises (bornes, non destructif) + seeding :
# une incise nominale qui nomme un personnage fixe le locuteur avec certitude
# AVANT l'appel LLM (corrige les cas que le petit modele rate).
# NB: ne PAS inclure les alias ici -> mesure : ca change trop le prompt et
# provoque de gros effets papillon (ch06 12B: 96% -> 80%). Les epithetes sont
# rattaches en post-traitement par la canonicalisation (sur le cast complet).
names = {c.name for c in chars}
for seg in segments:
if seg.type is not SegmentType.DIALOGUE:
continue
seg.incises = detect_incises(seg.text, names=names)
for inc in seg.incises:
# PRE-LLM : seuls les noms propres seedent (les incises de role
# renvoient None -> pas de seed, donc prompt inchange ; les roles
# sont rattaches en anonymes en post-traitement, sans effet papillon).
spk = incise_speaker(seg.text, inc, names)
if spk:
seg.speaker = spk
@@ -611,6 +900,22 @@ def analyze_chapter(
_refine_unknown_speakers(segments, gemma, characters=chapter_chars,
confidence=conf)
# Post-traitement deterministe (sans LLM). Ordre important :
# 1. rattache les incises de role a un locuteur anonyme par genre/age ;
# 2. repare l'alternance des tours dans les echanges a deux ;
# 3. recolle les variantes de noms au canonique du cast (rendu + score) ;
# 4. resout les figurants restes indetermines via la narration adjacente.
anon = _apply_anonymous_speakers(segments, names=names)
_repair_alternation(segments, names=names)
_canonicalize_speakers(segments, chars)
anon.update(_resolve_anonymous_figurants(segments))
# Cree les Character generiques des buckets anonymes (assignation de voix).
known = {c.name for c in chars}
for ident, (gender, age) in anon.items():
if ident not in known:
chars.append(Character(name=ident, gender=gender, age=age))
known.add(ident)
# Absorbe les locuteurs residuels (hors liste) en aliases (heuristique seule).
chars, _ = reconcile_characters(
chars, [], None, speaker_names=[s.speaker for s in segments])