Spaces:
Runtime error
feat(eval): comparer_mistral mesure les profils, avec temoin de bruit et budget borne
Browse files- --personas : chaque question posee sous chaque profil, avec le MEME
contexte ; alias acceptes, profil sans prompt refuse (sinon le repli de
get_system_prompt ferait mesurer un autre profil).
- --temoin : le premier profil rejoue, plancher de bruit a 0,7.
- --budget : au-dela, rien n'est lance, avant meme la cle d'API.
- --questions-libres avec --dry-run : la recherche du chat, sans appel au
modele, montre si une suggestion a une reponse dans le corpus.
- Mesures : forme_relue (citations que le chat sait relire en sources),
traits (listes, renvois, definitions), similarite et distinction entre
profils.
La regle de decision des nouveaux prompts est ecrite dans la docstring,
avant la mesure.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- README.md +11 -0
- scripts/eval/comparer_mistral.py +210 -14
- tests/test_eval/test_comparer_mistral.py +106 -1
|
@@ -424,6 +424,17 @@ bougé depuis la génération font **échouer** la mesure plutôt que produire d
|
|
| 424 |
chiffres faux. Avec 60 questions, l'erreur type est d'environ 6 points : un
|
| 425 |
écart de 2 points entre deux configurations n'est pas un résultat.
|
| 426 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 427 |
## Tests
|
| 428 |
|
| 429 |
La suite tourne sur un **vrai PostgreSQL** — le cœur du produit est du SQL
|
|
|
|
| 424 |
chiffres faux. Avec 60 questions, l'erreur type est d'environ 6 points : un
|
| 425 |
écart de 2 points entre deux configurations n'est pas un résultat.
|
| 426 |
|
| 427 |
+
Le chat lui-même (modèle, prompt, profil) se mesure avec `comparer_mistral`.
|
| 428 |
+
Son protocole et sa règle de décision sont écrits dans sa docstring, avant
|
| 429 |
+
toute mesure. `--budget` refuse de lancer plus d'appels que prévu.
|
| 430 |
+
|
| 431 |
+
```bash
|
| 432 |
+
python -m scripts.eval.comparer_mistral --modeles ministral-14b-2512 --questions 8 \
|
| 433 |
+
--personas citoyen avocat entrepreneur etudiant --temoin --comparaisons 0 --label personas
|
| 434 |
+
# Une suggestion du chat a-t-elle une réponse dans le corpus ? Aucun appel au modèle :
|
| 435 |
+
python -m scripts.eval.comparer_mistral --dry-run --questions-libres "Quel est le rôle du Conseil constitutionnel ?"
|
| 436 |
+
```
|
| 437 |
+
|
| 438 |
## Tests
|
| 439 |
|
| 440 |
La suite tourne sur un **vrai PostgreSQL** — le cœur du produit est du SQL
|
|
@@ -24,11 +24,42 @@ systeme du chat : « actuelles » (celui de la production) ou « renforcees »
|
|
| 24 |
(des regles de fond en tete, pour un petit modele qui s'ecarte des extraits).
|
| 25 |
Les comparaisons de regimes passent une fois par modele, avec leur prompt.
|
| 26 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 27 |
Usage:
|
| 28 |
python -m scripts.eval.comparer_mistral --dry-run # contextes seuls, aucun appel
|
| 29 |
python -m scripts.eval.comparer_mistral
|
| 30 |
python -m scripts.eval.comparer_mistral --modeles ministral-3b-2512 \
|
| 31 |
--consignes actuelles renforcees --label 3b
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 32 |
"""
|
| 33 |
|
| 34 |
import argparse
|
|
@@ -36,6 +67,7 @@ import asyncio
|
|
| 36 |
import json
|
| 37 |
import random
|
| 38 |
import re
|
|
|
|
| 39 |
import sys
|
| 40 |
import time
|
| 41 |
from datetime import datetime
|
|
@@ -47,11 +79,12 @@ sys.path.insert(0, str(RACINE))
|
|
| 47 |
|
| 48 |
from app.core.config import settings
|
| 49 |
from app.core.database import AsyncSessionLocal
|
|
|
|
| 50 |
from app.schemas.comparison import CRITERES_PAR_DEFAUT, mention_absence
|
| 51 |
from app.services.article_reference import normalize_number
|
| 52 |
from app.services.comparison_service import ComparisonError, ComparisonService
|
| 53 |
from app.services.mistral_service import MistralService
|
| 54 |
-
from app.services.prompts import get_system_prompt
|
| 55 |
from app.services.rag_service import ANSWER_MAX_TOKENS, RAGService
|
| 56 |
|
| 57 |
JEU = RACINE / "tests" / "fixtures" / "eval" / "retrieval_eval_v1.json"
|
|
@@ -71,10 +104,14 @@ REGLES_DE_FOND = """RÈGLES DE FOND — elles passent avant toutes les autres.
|
|
| 71 |
"""
|
| 72 |
|
| 73 |
|
| 74 |
-
def systeme_pour(consignes: str) -> str:
|
| 75 |
-
base = get_system_prompt(
|
| 76 |
return REGLES_DE_FOND + base if consignes == "renforcees" else base
|
| 77 |
|
|
|
|
|
|
|
|
|
|
|
|
|
| 78 |
COMPARAISONS = [
|
| 79 |
("permis de recherche minière", "permis d'exploitation minière"),
|
| 80 |
("contrat de travail à durée déterminée", "contrat de travail à durée indéterminée"),
|
|
@@ -148,23 +185,121 @@ def citations(texte: str, numeros_du_contexte: set) -> Dict[str, Any]:
|
|
| 148 |
return {"cites": cites, "presents": presents, "absents": [n for n in cites if n not in presents]}
|
| 149 |
|
| 150 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 151 |
async def evaluer(args) -> Dict[str, Any]:
|
| 152 |
resultats: Dict[str, Any] = {"questions": [], "comparaisons": []}
|
| 153 |
-
variantes =
|
| 154 |
etiquettes = [chr(ord("X") + i) if i < 3 else f"R{i}" for i in range(len(variantes))]
|
| 155 |
hasard = random.Random(args.graine)
|
| 156 |
|
| 157 |
async with AsyncSessionLocal() as session:
|
| 158 |
rag = RAGService(session)
|
| 159 |
-
for position, item in enumerate(
|
| 160 |
-
chunks = await rag._retrieve_chunks(item["question"],
|
| 161 |
prompt = rag._build_prompt(
|
| 162 |
question=item["question"], search_results=chunks, history=[], persona="citoyen"
|
| 163 |
)
|
| 164 |
contexte = {normalize_number(str(c.number or "")) for c in chunks if c.number}
|
|
|
|
|
|
|
| 165 |
entree = {
|
| 166 |
"question": item["question"],
|
| 167 |
-
"attendu":
|
| 168 |
"extraits": [
|
| 169 |
{"loi": c.reference, "numero": c.number, "texte": (c.content or "")[:600]}
|
| 170 |
for c in chunks
|
|
@@ -172,12 +307,23 @@ async def evaluer(args) -> Dict[str, Any]:
|
|
| 172 |
"reponses": [],
|
| 173 |
}
|
| 174 |
print(f"[{position}] {item['question'][:80]} ({len(chunks)} extraits)", flush=True)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 175 |
if not args.dry_run:
|
| 176 |
-
for modele, consignes in variantes:
|
| 177 |
-
reponse = await repondre(
|
|
|
|
|
|
|
| 178 |
reponse["consignes"] = consignes
|
| 179 |
-
reponse["
|
|
|
|
| 180 |
reponse["citations"] = citations(reponse["texte"], contexte)
|
|
|
|
|
|
|
| 181 |
entree["reponses"].append(reponse)
|
| 182 |
print(f" {reponse['variante']}: {reponse['duree_s']} s, fin={reponse['fin']}, "
|
| 183 |
f"cites={len(reponse['citations']['cites'])}, "
|
|
@@ -221,7 +367,7 @@ async def evaluer(args) -> Dict[str, Any]:
|
|
| 221 |
|
| 222 |
|
| 223 |
def synthese(resultats: Dict[str, Any]) -> Dict[str, Any]:
|
| 224 |
-
"""Par variante (modele
|
| 225 |
par_modele: Dict[str, Dict[str, Any]] = {}
|
| 226 |
variantes = []
|
| 227 |
for q in resultats["questions"]:
|
|
@@ -238,15 +384,29 @@ def synthese(resultats: Dict[str, Any]) -> Dict[str, Any]:
|
|
| 238 |
premiers = sorted(r["premier_morceau_s"] for r in reponses if r["premier_morceau_s"] is not None)
|
| 239 |
durees = sorted(r["duree_s"] for r in reponses)
|
| 240 |
comparaisons = [m for c in resultats["comparaisons"] for m in c["reponses"] if m["modele"] == modele]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 241 |
par_modele[variante] = {
|
| 242 |
"reponses": len(reponses),
|
| 243 |
"erreurs": sum(1 for r in reponses if r["erreur"]),
|
| 244 |
"incompletes": sum(1 for r in reponses if r["fin"] not in (None, "STOP")),
|
| 245 |
"justesse_citations": round(presents / cites, 3) if cites else None,
|
| 246 |
"citations": cites,
|
|
|
|
| 247 |
"premier_morceau_median_s": premiers[len(premiers) // 2] if premiers else None,
|
| 248 |
"duree_mediane_s": durees[len(durees) // 2] if durees else None,
|
| 249 |
"jetons_sortie": sum(r["jetons_sortie"] or 0 for r in reponses),
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 250 |
"comparaisons_json": sum(1 for m in comparaisons if m.get("json")),
|
| 251 |
"comparaisons_7_sur_7": sum(1 for m in comparaisons if m.get("lignes_remplies") == 7),
|
| 252 |
# Une case remplie ne vaut que si ses citations tiennent : le 3b
|
|
@@ -274,7 +434,14 @@ def fichier_a_l_aveugle(resultats: Dict[str, Any], chemin: Path) -> None:
|
|
| 274 |
chemin.write_text("\n".join(lignes), encoding="utf-8")
|
| 275 |
|
| 276 |
|
| 277 |
-
def
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 278 |
parseur = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
| 279 |
parseur.add_argument("--questions", type=int, default=20)
|
| 280 |
parseur.add_argument("--comparaisons", type=int, default=4)
|
|
@@ -282,10 +449,37 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
|
|
| 282 |
parseur.add_argument("--modeles", nargs="+", default=list(MODELES))
|
| 283 |
parseur.add_argument("--consignes", nargs="+", default=["actuelles"],
|
| 284 |
choices=["actuelles", "renforcees"])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 285 |
parseur.add_argument("--label", default="14b_8b")
|
| 286 |
parseur.add_argument("--dry-run", action="store_true", help="Recherche seule, aucun appel a Mistral")
|
| 287 |
-
|
|
|
|
| 288 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 289 |
if not args.dry_run and not settings.MISTRAL_API_KEY:
|
| 290 |
print("MISTRAL_API_KEY absente du .env.")
|
| 291 |
return 2
|
|
@@ -296,12 +490,14 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
|
|
| 296 |
if args.dry_run:
|
| 297 |
return 0
|
| 298 |
resultats["synthese"] = synthese(resultats)
|
|
|
|
| 299 |
horodatage = datetime.now().strftime("%Y%m%d_%H%M")
|
| 300 |
SORTIES.mkdir(parents=True, exist_ok=True)
|
| 301 |
chemin = SORTIES / f"mistral_{args.label}_{horodatage}.json"
|
| 302 |
chemin.write_text(json.dumps(resultats, ensure_ascii=False, indent=2), encoding="utf-8")
|
| 303 |
fichier_a_l_aveugle(resultats, chemin.with_suffix(".aveugle.md"))
|
| 304 |
-
print(json.dumps(resultats["synthese"],
|
|
|
|
| 305 |
print(f"Ecrit : {chemin} et {chemin.with_suffix('.aveugle.md')}")
|
| 306 |
return 0
|
| 307 |
|
|
|
|
| 24 |
(des regles de fond en tete, pour un petit modele qui s'ecarte des extraits).
|
| 25 |
Les comparaisons de regimes passent une fois par modele, avec leur prompt.
|
| 26 |
|
| 27 |
+
PROFILS (--personas). Meme protocole, un seul modele : chaque question est
|
| 28 |
+
posee sous chaque profil, avec le MEME contexte. --temoin rejoue le premier
|
| 29 |
+
profil une seconde fois : l'ecart entre deux tirages du meme prompt, a
|
| 30 |
+
temperature 0,7, est le plancher de bruit auquel comparer l'ecart entre
|
| 31 |
+
profils. --budget borne le nombre d'appels AVANT le premier.
|
| 32 |
+
|
| 33 |
+
REGLE DE DECISION DES PROFILS, ECRITE AVANT LA MESURE. Les nouveaux prompts
|
| 34 |
+
sont gardes si, sur la mesure APRES :
|
| 35 |
+
1. justesse des citations cumulee >= 0,94, et aucun profil sous 0,90 parmi
|
| 36 |
+
ceux qui citent au moins 8 fois (reference : 0,962 sur 26 citations,
|
| 37 |
+
ministral-14b-2512, prompts actuels, 2026-10-07) ;
|
| 38 |
+
2. forme_relue >= 0,90 pour chaque profil (les sources affichees sous la
|
| 39 |
+
reponse dependent de CITATION_REGEX) ;
|
| 40 |
+
3. 0 erreur, 0 reponse incomplete, duree mediane <= 1,5 fois celle de citoyen ;
|
| 41 |
+
4. similarite mediane entre profils inferieure a celle du temoin, et plus
|
| 42 |
+
basse que sur la mesure AVANT ;
|
| 43 |
+
5. l'avocat ne renvoie jamais vers un avocat ; aucun profil ne cite de
|
| 44 |
+
jurisprudence ;
|
| 45 |
+
6. relecture a l'aveugle de 15 reponses (5 profils x 3 questions) : profil
|
| 46 |
+
devine au moins 9 fois sur 15 (le hasard en donne 3).
|
| 47 |
+
|
| 48 |
+
SUGGESTIONS (--questions-libres). Avec --dry-run, chaque question passe par
|
| 49 |
+
la recherche du chat, sans aucun appel au modele : nombre d'extraits et trois
|
| 50 |
+
meilleurs textes, pour juger qu'une suggestion du front a une reponse dans le
|
| 51 |
+
corpus. Sans --dry-run, ces questions remplacent le jeu relu.
|
| 52 |
+
|
| 53 |
Usage:
|
| 54 |
python -m scripts.eval.comparer_mistral --dry-run # contextes seuls, aucun appel
|
| 55 |
python -m scripts.eval.comparer_mistral
|
| 56 |
python -m scripts.eval.comparer_mistral --modeles ministral-3b-2512 \
|
| 57 |
--consignes actuelles renforcees --label 3b
|
| 58 |
+
python -m scripts.eval.comparer_mistral --modeles ministral-14b-2512 --questions 8 \
|
| 59 |
+
--personas citoyen avocat entrepreneur etudiant --temoin --comparaisons 0 \
|
| 60 |
+
--label personas_avant
|
| 61 |
+
python -m scripts.eval.comparer_mistral --dry-run --questions-libres \
|
| 62 |
+
"Quel est le role du Conseil constitutionnel ?" "Comment obtenir un titre foncier ?"
|
| 63 |
"""
|
| 64 |
|
| 65 |
import argparse
|
|
|
|
| 67 |
import json
|
| 68 |
import random
|
| 69 |
import re
|
| 70 |
+
import statistics
|
| 71 |
import sys
|
| 72 |
import time
|
| 73 |
from datetime import datetime
|
|
|
|
| 79 |
|
| 80 |
from app.core.config import settings
|
| 81 |
from app.core.database import AsyncSessionLocal
|
| 82 |
+
from app.core.personas import normaliser_profil
|
| 83 |
from app.schemas.comparison import CRITERES_PAR_DEFAUT, mention_absence
|
| 84 |
from app.services.article_reference import normalize_number
|
| 85 |
from app.services.comparison_service import ComparisonError, ComparisonService
|
| 86 |
from app.services.mistral_service import MistralService
|
| 87 |
+
from app.services.prompts import SYSTEM_PROMPTS, get_system_prompt
|
| 88 |
from app.services.rag_service import ANSWER_MAX_TOKENS, RAGService
|
| 89 |
|
| 90 |
JEU = RACINE / "tests" / "fixtures" / "eval" / "retrieval_eval_v1.json"
|
|
|
|
| 104 |
"""
|
| 105 |
|
| 106 |
|
| 107 |
+
def systeme_pour(consignes: str, persona: str = "citoyen") -> str:
|
| 108 |
+
base = get_system_prompt(persona, "fr")
|
| 109 |
return REGLES_DE_FOND + base if consignes == "renforcees" else base
|
| 110 |
|
| 111 |
+
|
| 112 |
+
# Suffixe de la variante temoin : le premier profil, rejoue a l'identique.
|
| 113 |
+
TEMOIN = "#2"
|
| 114 |
+
|
| 115 |
COMPARAISONS = [
|
| 116 |
("permis de recherche minière", "permis d'exploitation minière"),
|
| 117 |
("contrat de travail à durée déterminée", "contrat de travail à durée indéterminée"),
|
|
|
|
| 185 |
return {"cites": cites, "presents": presents, "absents": [n for n in cites if n not in presents]}
|
| 186 |
|
| 187 |
|
| 188 |
+
# Les citations que le chat sait relire : ce sont elles qui deviennent les
|
| 189 |
+
# sources affichees sous la reponse. « art. 33 » ou « l'article 33 alinéa 2 du
|
| 190 |
+
# Code Minier » sont vus par numeros_cites, mais pas relus par le chat.
|
| 191 |
+
_CITATION_CHAT = re.compile(RAGService.CITATION_REGEX)
|
| 192 |
+
_RENVOI_AVOCAT = re.compile(
|
| 193 |
+
r"consult(?:ez|er|e)\s+(?:un|une|votre)\s+(?:avocat|juriste|professionnel du droit)"
|
| 194 |
+
r"|faire appel à un avocat|consult(?:ing)?\s+a\s+lawyer",
|
| 195 |
+
re.IGNORECASE,
|
| 196 |
+
)
|
| 197 |
+
_JURISPRUDENCE = re.compile(r"jurisprudence|case[- ]law", re.IGNORECASE)
|
| 198 |
+
_DEFINITION = re.compile(
|
| 199 |
+
r"\b(?:désigne|se définit|on entend par|est défini|signifie|means|is defined as|refers to)\b",
|
| 200 |
+
re.IGNORECASE,
|
| 201 |
+
)
|
| 202 |
+
|
| 203 |
+
|
| 204 |
+
def forme_relue(texte: str) -> Dict[str, int]:
|
| 205 |
+
"""Numeros d'article cites, et parmi eux ceux que le chat sait relire."""
|
| 206 |
+
vus = set(numeros_cites(texte))
|
| 207 |
+
relus = {normalize_number(m.group(2)) for m in _CITATION_CHAT.finditer(texte or "")}
|
| 208 |
+
return {"vus": len(vus), "relus": len(vus & relus)}
|
| 209 |
+
|
| 210 |
+
|
| 211 |
+
def traits(texte: str) -> Dict[str, Any]:
|
| 212 |
+
"""Ce qui distingue une reponse de profil : longueur, forme, renvois."""
|
| 213 |
+
lignes = (texte or "").splitlines()
|
| 214 |
+
return {
|
| 215 |
+
"mots": len(re.findall(r"\w+", texte or "")),
|
| 216 |
+
"liste_numerotee": any(re.match(r"\s*\d+[.)]\s", ligne) for ligne in lignes),
|
| 217 |
+
"puces": any(re.match(r"\s*[-*•]\s", ligne) for ligne in lignes),
|
| 218 |
+
"renvoi_avocat": bool(_RENVOI_AVOCAT.search(texte or "")),
|
| 219 |
+
# Une MENTION : « les textes ne contiennent pas de jurisprudence » en est
|
| 220 |
+
# une aussi. A relire avant de conclure.
|
| 221 |
+
"jurisprudence": bool(_JURISPRUDENCE.search(texte or "")),
|
| 222 |
+
"definition": bool(_DEFINITION.search(texte or "")),
|
| 223 |
+
}
|
| 224 |
+
|
| 225 |
+
|
| 226 |
+
def _trigrammes(texte: str) -> set:
|
| 227 |
+
mots = re.findall(r"\w+", (texte or "").lower())
|
| 228 |
+
return {tuple(mots[i:i + 3]) for i in range(len(mots) - 2)}
|
| 229 |
+
|
| 230 |
+
|
| 231 |
+
def similarite(a: str, b: str) -> float:
|
| 232 |
+
"""Jaccard sur les trigrammes de mots : 1 pour deux textes identiques."""
|
| 233 |
+
ta, tb = _trigrammes(a), _trigrammes(b)
|
| 234 |
+
if not ta and not tb:
|
| 235 |
+
return 1.0
|
| 236 |
+
return len(ta & tb) / len(ta | tb)
|
| 237 |
+
|
| 238 |
+
|
| 239 |
+
def distinction(resultats: Dict[str, Any]) -> Dict[str, Any]:
|
| 240 |
+
"""
|
| 241 |
+
Par question, la similarite mediane entre profils differents, et celle du
|
| 242 |
+
temoin (le meme profil rejoue). Des profils vraiment distincts se
|
| 243 |
+
ressemblent MOINS entre eux que deux tirages du meme prompt.
|
| 244 |
+
"""
|
| 245 |
+
entre, temoin = [], []
|
| 246 |
+
for question in resultats["questions"]:
|
| 247 |
+
textes = {r["variante"]: r["texte"] for r in question["reponses"]
|
| 248 |
+
if r.get("variante") and not r.get("erreur")}
|
| 249 |
+
profils = [cle for cle in textes if not cle.endswith(TEMOIN)]
|
| 250 |
+
paires = [similarite(textes[a], textes[b])
|
| 251 |
+
for i, a in enumerate(profils) for b in profils[i + 1:]]
|
| 252 |
+
if paires:
|
| 253 |
+
entre.append(statistics.median(paires))
|
| 254 |
+
for cle in textes:
|
| 255 |
+
if cle.endswith(TEMOIN) and cle[: -len(TEMOIN)] in textes:
|
| 256 |
+
temoin.append(similarite(textes[cle], textes[cle[: -len(TEMOIN)]]))
|
| 257 |
+
|
| 258 |
+
def mediane(valeurs):
|
| 259 |
+
return round(statistics.median(valeurs), 3) if valeurs else None
|
| 260 |
+
|
| 261 |
+
return {"entre_profils": mediane(entre), "temoin": mediane(temoin), "questions": len(entre)}
|
| 262 |
+
|
| 263 |
+
|
| 264 |
+
def variantes_de(args) -> List[tuple]:
|
| 265 |
+
"""(modele, consignes, profil) ; le temoin rejoue la premiere sous TEMOIN."""
|
| 266 |
+
variantes = [(m, c, p) for m in args.modeles for c in args.consignes for p in args.personas]
|
| 267 |
+
if args.temoin and variantes:
|
| 268 |
+
m, c, p = variantes[0]
|
| 269 |
+
variantes.append((m, c, p + TEMOIN))
|
| 270 |
+
return variantes
|
| 271 |
+
|
| 272 |
+
|
| 273 |
+
def appels_prevus(n_questions: int, n_variantes: int, n_comparaisons: int, n_modeles: int) -> int:
|
| 274 |
+
return n_questions * n_variantes + n_comparaisons * n_modeles
|
| 275 |
+
|
| 276 |
+
|
| 277 |
+
def questions_de(args) -> List[dict]:
|
| 278 |
+
if args.questions_libres:
|
| 279 |
+
return [{"question": q, "expected_law_id": None, "expected_article_number": None}
|
| 280 |
+
for q in args.questions_libres]
|
| 281 |
+
return questions_relues(args.questions)
|
| 282 |
+
|
| 283 |
+
|
| 284 |
async def evaluer(args) -> Dict[str, Any]:
|
| 285 |
resultats: Dict[str, Any] = {"questions": [], "comparaisons": []}
|
| 286 |
+
variantes = variantes_de(args)
|
| 287 |
etiquettes = [chr(ord("X") + i) if i < 3 else f"R{i}" for i in range(len(variantes))]
|
| 288 |
hasard = random.Random(args.graine)
|
| 289 |
|
| 290 |
async with AsyncSessionLocal() as session:
|
| 291 |
rag = RAGService(session)
|
| 292 |
+
for position, item in enumerate(questions_de(args), start=1):
|
| 293 |
+
chunks = await rag._retrieve_chunks(item["question"], args.langue)
|
| 294 |
prompt = rag._build_prompt(
|
| 295 |
question=item["question"], search_results=chunks, history=[], persona="citoyen"
|
| 296 |
)
|
| 297 |
contexte = {normalize_number(str(c.number or "")) for c in chunks if c.number}
|
| 298 |
+
attendu = (f"{item['expected_law_id']}/{item['expected_article_number']}"
|
| 299 |
+
if item.get("expected_law_id") else None)
|
| 300 |
entree = {
|
| 301 |
"question": item["question"],
|
| 302 |
+
"attendu": attendu,
|
| 303 |
"extraits": [
|
| 304 |
{"loi": c.reference, "numero": c.number, "texte": (c.content or "")[:600]}
|
| 305 |
for c in chunks
|
|
|
|
| 307 |
"reponses": [],
|
| 308 |
}
|
| 309 |
print(f"[{position}] {item['question'][:80]} ({len(chunks)} extraits)", flush=True)
|
| 310 |
+
if args.dry_run and args.questions_libres:
|
| 311 |
+
# Validation d'une suggestion : y a-t-il une reponse dans le corpus ?
|
| 312 |
+
if not chunks:
|
| 313 |
+
print(" REJETEE : aucun extrait", flush=True)
|
| 314 |
+
for c in chunks[:3]:
|
| 315 |
+
print(f" - {c.reference} art. {c.number} : {(c.law_title or '')[:80]}", flush=True)
|
| 316 |
if not args.dry_run:
|
| 317 |
+
for modele, consignes, persona in variantes:
|
| 318 |
+
reponse = await repondre(
|
| 319 |
+
modele, prompt, systeme_pour(consignes, persona.removesuffix(TEMOIN))
|
| 320 |
+
)
|
| 321 |
reponse["consignes"] = consignes
|
| 322 |
+
reponse["persona"] = persona
|
| 323 |
+
reponse["variante"] = f"{modele}|{consignes}|{persona}"
|
| 324 |
reponse["citations"] = citations(reponse["texte"], contexte)
|
| 325 |
+
reponse["forme"] = forme_relue(reponse["texte"])
|
| 326 |
+
reponse["traits"] = traits(reponse["texte"])
|
| 327 |
entree["reponses"].append(reponse)
|
| 328 |
print(f" {reponse['variante']}: {reponse['duree_s']} s, fin={reponse['fin']}, "
|
| 329 |
f"cites={len(reponse['citations']['cites'])}, "
|
|
|
|
| 367 |
|
| 368 |
|
| 369 |
def synthese(resultats: Dict[str, Any]) -> Dict[str, Any]:
|
| 370 |
+
"""Par variante (modele, consignes, profil) ; les comparaisons, par modele."""
|
| 371 |
par_modele: Dict[str, Dict[str, Any]] = {}
|
| 372 |
variantes = []
|
| 373 |
for q in resultats["questions"]:
|
|
|
|
| 384 |
premiers = sorted(r["premier_morceau_s"] for r in reponses if r["premier_morceau_s"] is not None)
|
| 385 |
durees = sorted(r["duree_s"] for r in reponses)
|
| 386 |
comparaisons = [m for c in resultats["comparaisons"] for m in c["reponses"] if m["modele"] == modele]
|
| 387 |
+
formes = [r["forme"] for r in reponses if r.get("forme")]
|
| 388 |
+
vus = sum(f["vus"] for f in formes)
|
| 389 |
+
lus = [r["traits"] for r in reponses if r.get("traits")]
|
| 390 |
+
|
| 391 |
+
def part(trait, lus=lus):
|
| 392 |
+
return round(sum(1 for t in lus if t[trait]) / len(lus), 2) if lus else None
|
| 393 |
+
|
| 394 |
par_modele[variante] = {
|
| 395 |
"reponses": len(reponses),
|
| 396 |
"erreurs": sum(1 for r in reponses if r["erreur"]),
|
| 397 |
"incompletes": sum(1 for r in reponses if r["fin"] not in (None, "STOP")),
|
| 398 |
"justesse_citations": round(presents / cites, 3) if cites else None,
|
| 399 |
"citations": cites,
|
| 400 |
+
"forme_relue": round(sum(f["relus"] for f in formes) / vus, 3) if vus else None,
|
| 401 |
"premier_morceau_median_s": premiers[len(premiers) // 2] if premiers else None,
|
| 402 |
"duree_mediane_s": durees[len(durees) // 2] if durees else None,
|
| 403 |
"jetons_sortie": sum(r["jetons_sortie"] or 0 for r in reponses),
|
| 404 |
+
"mots_median": statistics.median([t["mots"] for t in lus]) if lus else None,
|
| 405 |
+
"part_liste_numerotee": part("liste_numerotee"),
|
| 406 |
+
"part_puces": part("puces"),
|
| 407 |
+
"part_renvoi_avocat": part("renvoi_avocat"),
|
| 408 |
+
"part_jurisprudence": part("jurisprudence"),
|
| 409 |
+
"part_definition": part("definition"),
|
| 410 |
"comparaisons_json": sum(1 for m in comparaisons if m.get("json")),
|
| 411 |
"comparaisons_7_sur_7": sum(1 for m in comparaisons if m.get("lignes_remplies") == 7),
|
| 412 |
# Une case remplie ne vaut que si ses citations tiennent : le 3b
|
|
|
|
| 434 |
chemin.write_text("\n".join(lignes), encoding="utf-8")
|
| 435 |
|
| 436 |
|
| 437 |
+
def _profil(valeur: str) -> str:
|
| 438 |
+
try:
|
| 439 |
+
return normaliser_profil(valeur)
|
| 440 |
+
except ValueError as exc:
|
| 441 |
+
raise argparse.ArgumentTypeError(str(exc)) from exc
|
| 442 |
+
|
| 443 |
+
|
| 444 |
+
def _parseur() -> argparse.ArgumentParser:
|
| 445 |
parseur = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
| 446 |
parseur.add_argument("--questions", type=int, default=20)
|
| 447 |
parseur.add_argument("--comparaisons", type=int, default=4)
|
|
|
|
| 449 |
parseur.add_argument("--modeles", nargs="+", default=list(MODELES))
|
| 450 |
parseur.add_argument("--consignes", nargs="+", default=["actuelles"],
|
| 451 |
choices=["actuelles", "renforcees"])
|
| 452 |
+
parseur.add_argument("--personas", nargs="+", type=_profil, default=["citoyen"],
|
| 453 |
+
help="Profils compares, alias acceptes (etudiant, general)")
|
| 454 |
+
parseur.add_argument("--temoin", action="store_true",
|
| 455 |
+
help="Rejoue le premier profil : plancher de bruit")
|
| 456 |
+
parseur.add_argument("--budget", type=int, default=48,
|
| 457 |
+
help="Nombre maximal d'appels ; au-dela, rien n'est lance")
|
| 458 |
+
parseur.add_argument("--questions-libres", nargs="+", default=None,
|
| 459 |
+
help="Remplace le jeu relu ; avec --dry-run, valide des suggestions")
|
| 460 |
+
parseur.add_argument("--langue", default="fr", choices=["fr", "en"],
|
| 461 |
+
help="Langue de la recherche (questions libres)")
|
| 462 |
parseur.add_argument("--label", default="14b_8b")
|
| 463 |
parseur.add_argument("--dry-run", action="store_true", help="Recherche seule, aucun appel a Mistral")
|
| 464 |
+
return parseur
|
| 465 |
+
|
| 466 |
|
| 467 |
+
def main(argv: Optional[Sequence[str]] = None) -> int:
|
| 468 |
+
args = _parseur().parse_args(argv)
|
| 469 |
+
|
| 470 |
+
sans_prompt = [p for p in args.personas if p.removesuffix(TEMOIN) not in SYSTEM_PROMPTS["fr"]]
|
| 471 |
+
if sans_prompt:
|
| 472 |
+
# get_system_prompt se replierait en silence : on mesurerait un autre profil.
|
| 473 |
+
print(f"Profil sans prompt : {sans_prompt}")
|
| 474 |
+
return 2
|
| 475 |
+
|
| 476 |
+
n_questions = len(questions_de(args))
|
| 477 |
+
prevus = appels_prevus(n_questions, len(variantes_de(args)),
|
| 478 |
+
min(args.comparaisons, len(COMPARAISONS)), len(args.modeles))
|
| 479 |
+
print(f"Appels prevus : {prevus} (budget {args.budget})")
|
| 480 |
+
if not args.dry_run and prevus > args.budget:
|
| 481 |
+
print("Budget depasse : rien n'est lance. Reduire --questions, --personas ou --modeles.")
|
| 482 |
+
return 2
|
| 483 |
if not args.dry_run and not settings.MISTRAL_API_KEY:
|
| 484 |
print("MISTRAL_API_KEY absente du .env.")
|
| 485 |
return 2
|
|
|
|
| 490 |
if args.dry_run:
|
| 491 |
return 0
|
| 492 |
resultats["synthese"] = synthese(resultats)
|
| 493 |
+
resultats["distinction"] = distinction(resultats)
|
| 494 |
horodatage = datetime.now().strftime("%Y%m%d_%H%M")
|
| 495 |
SORTIES.mkdir(parents=True, exist_ok=True)
|
| 496 |
chemin = SORTIES / f"mistral_{args.label}_{horodatage}.json"
|
| 497 |
chemin.write_text(json.dumps(resultats, ensure_ascii=False, indent=2), encoding="utf-8")
|
| 498 |
fichier_a_l_aveugle(resultats, chemin.with_suffix(".aveugle.md"))
|
| 499 |
+
print(json.dumps({"synthese": resultats["synthese"], "distinction": resultats["distinction"]},
|
| 500 |
+
ensure_ascii=False, indent=2))
|
| 501 |
print(f"Ecrit : {chemin} et {chemin.with_suffix('.aveugle.md')}")
|
| 502 |
return 0
|
| 503 |
|
|
@@ -9,7 +9,25 @@ Usage:
|
|
| 9 |
pytest tests/test_eval/test_comparer_mistral.py -v
|
| 10 |
"""
|
| 11 |
|
| 12 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 13 |
|
| 14 |
|
| 15 |
def test_numeros_cites_sous_toutes_leurs_formes():
|
|
@@ -56,3 +74,90 @@ def test_synthese_justesse_des_citations():
|
|
| 56 |
assert bilan["ministral-8b-latest"]["justesse_citations"] == 0.5
|
| 57 |
assert bilan["ministral-14b-latest"]["comparaisons_7_sur_7"] == 1
|
| 58 |
assert bilan["ministral-8b-latest"]["comparaisons_json"] == 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 9 |
pytest tests/test_eval/test_comparer_mistral.py -v
|
| 10 |
"""
|
| 11 |
|
| 12 |
+
import pytest
|
| 13 |
+
|
| 14 |
+
from app.services.prompts import get_system_prompt
|
| 15 |
+
from scripts.eval.comparer_mistral import (
|
| 16 |
+
REGLES_DE_FOND,
|
| 17 |
+
TEMOIN,
|
| 18 |
+
_parseur,
|
| 19 |
+
appels_prevus,
|
| 20 |
+
citations,
|
| 21 |
+
distinction,
|
| 22 |
+
forme_relue,
|
| 23 |
+
main,
|
| 24 |
+
numeros_cites,
|
| 25 |
+
similarite,
|
| 26 |
+
synthese,
|
| 27 |
+
systeme_pour,
|
| 28 |
+
traits,
|
| 29 |
+
variantes_de,
|
| 30 |
+
)
|
| 31 |
|
| 32 |
|
| 33 |
def test_numeros_cites_sous_toutes_leurs_formes():
|
|
|
|
| 74 |
assert bilan["ministral-8b-latest"]["justesse_citations"] == 0.5
|
| 75 |
assert bilan["ministral-14b-latest"]["comparaisons_7_sur_7"] == 1
|
| 76 |
assert bilan["ministral-8b-latest"]["comparaisons_json"] == 0
|
| 77 |
+
|
| 78 |
+
|
| 79 |
+
# ---------------------------------------------------------------- profils
|
| 80 |
+
|
| 81 |
+
|
| 82 |
+
def test_le_prompt_mesure_est_celui_du_profil():
|
| 83 |
+
assert systeme_pour("actuelles", "avocat") == get_system_prompt("avocat", "fr")
|
| 84 |
+
assert systeme_pour("renforcees", "avocat").startswith(REGLES_DE_FOND)
|
| 85 |
+
|
| 86 |
+
|
| 87 |
+
def test_les_alias_de_profil_sont_acceptes():
|
| 88 |
+
args = _parseur().parse_args(["--personas", "etudiant", "Avocat"])
|
| 89 |
+
|
| 90 |
+
assert args.personas == ["étudiant", "avocat"]
|
| 91 |
+
|
| 92 |
+
|
| 93 |
+
def test_un_profil_inconnu_est_refuse_par_le_parseur():
|
| 94 |
+
with pytest.raises(SystemExit):
|
| 95 |
+
_parseur().parse_args(["--personas", "astronaute"])
|
| 96 |
+
|
| 97 |
+
|
| 98 |
+
def test_le_temoin_rejoue_la_premiere_variante():
|
| 99 |
+
args = _parseur().parse_args(["--modeles", "m", "--personas", "citoyen", "avocat", "--temoin"])
|
| 100 |
+
|
| 101 |
+
assert variantes_de(args) == [
|
| 102 |
+
("m", "actuelles", "citoyen"), ("m", "actuelles", "avocat"),
|
| 103 |
+
("m", "actuelles", "citoyen" + TEMOIN),
|
| 104 |
+
]
|
| 105 |
+
|
| 106 |
+
|
| 107 |
+
def test_le_budget_refuse_avant_tout_appel(capsys):
|
| 108 |
+
"""8 questions x 2 modeles x 5 profils = 80 appels, au-dela des 48 : rien ne part."""
|
| 109 |
+
code = main([
|
| 110 |
+
"--questions", "8", "--comparaisons", "0", "--modeles", "a", "b",
|
| 111 |
+
"--personas", "citoyen", "avocat", "entrepreneur", "étudiant", "citoyen",
|
| 112 |
+
])
|
| 113 |
+
|
| 114 |
+
assert code == 2
|
| 115 |
+
assert "Budget depasse" in capsys.readouterr().out
|
| 116 |
+
assert appels_prevus(8, 10, 0, 2) == 80
|
| 117 |
+
|
| 118 |
+
|
| 119 |
+
def test_un_profil_sans_prompt_n_est_pas_mesure(monkeypatch, capsys):
|
| 120 |
+
"""Sinon get_system_prompt se replierait en silence sur un autre profil."""
|
| 121 |
+
from scripts.eval import comparer_mistral
|
| 122 |
+
|
| 123 |
+
monkeypatch.setattr(comparer_mistral, "SYSTEM_PROMPTS", {"fr": {"citoyen": "x"}})
|
| 124 |
+
|
| 125 |
+
assert main(["--personas", "avocat", "--dry-run"]) == 2
|
| 126 |
+
assert "sans prompt" in capsys.readouterr().out
|
| 127 |
+
|
| 128 |
+
|
| 129 |
+
# ---------------------------------------------------------------- mesures pures
|
| 130 |
+
|
| 131 |
+
|
| 132 |
+
def test_forme_relue_distingue_ce_que_le_chat_sait_relire():
|
| 133 |
+
assert forme_relue("Selon l'article 33 du Code Minier, alinéa 2.") == {"vus": 1, "relus": 1}
|
| 134 |
+
assert forme_relue("Voir art. 33.") == {"vus": 1, "relus": 0}
|
| 135 |
+
assert forme_relue("Aucune citation.") == {"vus": 0, "relus": 0}
|
| 136 |
+
|
| 137 |
+
|
| 138 |
+
def test_traits_d_une_reponse():
|
| 139 |
+
t = traits("1. Premier point\n2. Second point\nConsultez un avocat. La jurisprudence manque.")
|
| 140 |
+
|
| 141 |
+
assert t["liste_numerotee"] and not t["puces"]
|
| 142 |
+
assert t["renvoi_avocat"] and t["jurisprudence"]
|
| 143 |
+
assert t["mots"] > 5
|
| 144 |
+
|
| 145 |
+
|
| 146 |
+
def test_similarite_bornes():
|
| 147 |
+
assert similarite("un deux trois quatre", "un deux trois quatre") == 1.0
|
| 148 |
+
assert similarite("un deux trois", "quatre cinq six") == 0.0
|
| 149 |
+
|
| 150 |
+
|
| 151 |
+
def test_distinction_profils_divergents_temoin_proche():
|
| 152 |
+
base = "la loi prevoit une sanction penale pour ce fait precis selon le code"
|
| 153 |
+
autre = "en pratique vous devez deposer un dossier aupres de la mairie competente"
|
| 154 |
+
resultats = {"questions": [{"reponses": [
|
| 155 |
+
{"variante": "m|actuelles|citoyen", "texte": base, "erreur": None},
|
| 156 |
+
{"variante": "m|actuelles|avocat", "texte": autre, "erreur": None},
|
| 157 |
+
{"variante": "m|actuelles|citoyen" + TEMOIN, "texte": base, "erreur": None},
|
| 158 |
+
]}]}
|
| 159 |
+
|
| 160 |
+
bilan = distinction(resultats)
|
| 161 |
+
|
| 162 |
+
assert bilan["temoin"] == 1.0
|
| 163 |
+
assert bilan["entre_profils"] < bilan["temoin"]
|