rahim237cm Claude Opus 5.5 commited on
Commit
df97adf
·
1 Parent(s): 0a62da7

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 CHANGED
@@ -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
scripts/eval/comparer_mistral.py CHANGED
@@ -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("citoyen", "fr")
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 = [(modele, consignes) for modele in args.modeles for consignes in args.consignes]
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(questions_relues(args.questions), start=1):
160
- chunks = await rag._retrieve_chunks(item["question"], "fr")
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": f"{item['expected_law_id']}/{item['expected_article_number']}",
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(modele, prompt, systeme_pour(consignes))
 
 
178
  reponse["consignes"] = consignes
179
- reponse["variante"] = f"{modele}|{consignes}"
 
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 et consignes) ; les comparaisons, par 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 main(argv: Optional[Sequence[str]] = None) -> int:
 
 
 
 
 
 
 
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
- args = parseur.parse_args(argv)
 
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"], ensure_ascii=False, indent=2))
 
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
 
tests/test_eval/test_comparer_mistral.py CHANGED
@@ -9,7 +9,25 @@ Usage:
9
  pytest tests/test_eval/test_comparer_mistral.py -v
10
  """
11
 
12
- from scripts.eval.comparer_mistral import citations, numeros_cites, synthese
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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"]