CV-Matching / scripts /comparer_modeles.py
Myz0's picture
Avis calibré sur des notes humaines : Profil adapté / à étudier / peu adapté
a462430 verified
Raw History Blame Contribute Delete
8.11 kB
"""Compare un modèle d'embeddings (et/ou de reranker) au service actuel, sans tricher sur la rampe.
Pour le modèle testé (variables MODEL_NAME, MODEL_PROMPT, RERANKER_MODEL) :
1. la rampe SIM_BAS / SIM_HAUT est réglée sur le jeu de RÉGLAGE (exemples/cv_list.json, 23 CV,
comme pour bge-m3) : chaque modèle a sa propre échelle de similarité ;
2. il est mesuré sur le jeu d'ÉVALUATION n° 2 (exemples/cv_eval.json, 68 CV notés 0..3), jamais
utilisé pour régler ;
3. comparaison APPARIÉE avec le service actuel : mêmes CV, bootstrap sur la différence. Un écart
dont l'intervalle contient 0 n'est pas un progrès démontré.
Le service actuel doit avoir été mesuré avant (python -m scripts.evaluer_jeu). Les similarités
sont gardées dans resultats/jeu_eval/ : relancer ne recalcule rien.
Exemple (PowerShell) :
$env:MODEL_NAME="Qwen/Qwen3-Embedding-0.6B"
$env:MODEL_PROMPT="Instruct: Retrieve semantically similar text`nQuery: "
python -m scripts.comparer_modeles
"""
from __future__ import annotations
import hashlib
import json
import os
import pickle
import numpy as np
os.environ.setdefault("DATASET_REVISION", "1bb92a09a4ff6aa6e9488ee954085019abba7747")
from app import config, scoring # noqa: E402
from scripts.evaluer_classement import charger_attendus, matrice # noqa: E402
from scripts.evaluer_jeu import CACHE, JEU, RACINE, mesures, notes # noqa: E402
REFERENCE = "BAAI_bge-m3+BAAI_bge-reranker-v2-m3"
def etiquette() -> str:
import re
nom = f"{config.MODEL_NAME}+{config.RERANKER_MODEL or 'sans-reranker'}"
if config.MODEL_PROMPT:
nom += "+p" + hashlib.sha1(config.MODEL_PROMPT.encode()).hexdigest()[:6]
return re.sub(r"[^\w.+-]", "_", nom)
def calculer(jeux: dict[str, list[dict]]):
"""{nom du jeu: CV} -> {nom: (ids, poids, poids_sf, sims)} ; modèles chargés une seule fois."""
CACHE.mkdir(parents=True, exist_ok=True)
fichiers = {n: CACHE / (f"{etiquette()}.pkl" if n == "eval" else f"{etiquette()}_{n}.pkl") for n in jeux}
sortie, a_faire = {}, {}
for n, cvs in jeux.items():
if fichiers[n].exists():
d = pickle.loads(fichiers[n].read_bytes())
if d["cvs"] == [c.get("_id", k) for k, c in enumerate(cvs)]:
sortie[n] = (d["ids"], d["poids"], d["poids_sf"], d["sims"])
continue
a_faire[n] = cvs
if not a_faire:
return sortie
from app.avp_store import AVPStore
from app.cv_texte import phrases_du_cv
from app.encodeur import Encodeur
from app.outils import textes_pour_calcul
if config.RERANKER_MODEL:
from app.reranker import Reranker
scoring.RERANKER = Reranker(config.RERANKER_MODEL)
encodeur = Encodeur(config.MODEL_NAME)
store = AVPStore(encodeur)
store.charger()
ids = list(store.prepares)
poids = [store.prepares[i].poids for i in ids]
poids_sf = [store.prepares[i].poids * ~store.prepares[i].savoir_etre for i in ids]
for n, cvs in a_faire.items():
sims = []
for k, cv in enumerate(cvs, 1):
phrases = phrases_du_cv(cv)
textes = textes_pour_calcul(phrases)
vecs = encodeur.encoder(textes) if phrases else None
rr = scoring.probas_reranker_avps(store.prepares, textes, vecs) if vecs is not None else {}
sims.append([(store.prepares[i].vecs_attendus @ vecs.T, rr.get(i))
if vecs is not None and len(store.prepares[i].attendus) else None for i in ids])
print(f"\r {n} : CV {k}/{len(cvs)}", end="", flush=True)
print()
fichiers[n].write_bytes(pickle.dumps({"cvs": [c.get("_id", k) for k, c in enumerate(cvs)], "ids": ids,
"poids": poids, "poids_sf": poids_sf, "sims": sims}))
sortie[n] = (ids, poids, poids_sf, sims)
return sortie
def mesurer_strict(m, ids, attendus) -> dict:
"""Comme evaluer_classement.mesurer, mais un ex aequo compte comme une défaite : sinon une rampe
très basse (tous les scores à 100, tous ex aequo) passe pour parfaite."""
hors = [c for c, a in attendus.items() if a is None]
rr, rc, marges = [], [], []
for c, cibles in attendus.items():
if cibles is None:
continue
cols = [ids.index(a) for a in cibles]
for a in cols:
rr.append(int(np.sum(m[:, a] >= m[c, a])))
marges += [float(m[c, a] - max(m[h, a] for h in hors))] if hors else []
rc.append(min(int(np.sum(m[c] >= m[c, a])) for a in cols))
rr, rc = np.array(rr), np.array(rc)
return {"rec_top1": round(float(np.mean(rr == 1)), 3), "rec_mrr": round(float(np.mean(1 / rr)), 3),
"cand_top1": round(float(np.mean(rc == 1)), 3), "cand_mrr": round(float(np.mean(1 / rc)), 3),
"marge_min": round(min(marges), 3) if marges else None, "faux_positifs": int(sum(x <= 0 for x in marges))}
def regler_rampe(ids, poids, sims) -> tuple[float, float, dict]:
"""Même recherche que scripts/evaluer_classement, sur le jeu de réglage (ex aequo = défaite)."""
attendus = charger_attendus(ids)
essais = []
for bas in np.arange(0.20, 0.96, 0.025):
for haut in np.arange(bas + 0.025, 1.0, 0.0125):
res = mesurer_strict(matrice(sims, poids, bas, haut), ids, attendus)
essais.append(((res["rec_mrr"] + res["cand_mrr"], res["marge_min"] or 0), round(float(bas), 3),
round(float(haut), 3), res))
essais.sort(key=lambda e: e[0], reverse=True)
return essais[0][1], essais[0][2], essais[0][3]
def compare(m_ref, m_new, R, poste_avp, n=1000, graine=11) -> dict:
"""Différence appariée nouveau - référence, intervalle à 95 % (bootstrap sur les CV)."""
rng = np.random.default_rng(graine)
diffs = []
for _ in range(n):
lignes = rng.integers(0, len(R), len(R))
a, b = mesures(m_ref, R, poste_avp, lignes), mesures(m_new, R, poste_avp, lignes)
diffs.append({k: b[k] - a[k] for k in a})
return {k: (float(np.mean([d[k] for d in diffs])), float(np.percentile([d[k] for d in diffs], 2.5)),
float(np.percentile([d[k] for d in diffs], 97.5))) for k in diffs[0]}
def main():
jeu = json.loads(JEU.read_text(encoding="utf-8"))
reglage = json.loads((RACINE / "exemples/cv_list.json").read_text(encoding="utf-8"))
print(f"Modèle testé : {config.MODEL_NAME} · instruction {config.MODEL_PROMPT!r} · "
f"reranker {config.RERANKER_MODEL or 'aucun'}")
d = calculer({"reglage": reglage, "eval": jeu["cvs"]})
ids_r, poids_r, _, sims_r = d["reglage"]
bas, haut, res_r = regler_rampe(ids_r, poids_r, sims_r)
print(f"\nRampe réglée sur le jeu de réglage : {bas} / {haut} -> {res_r}")
ids, poids, _, sims = d["eval"]
R, poste_avp = notes(jeu, ids)
m_new = matrice(sims, poids, bas, haut)
ref = pickle.loads((CACHE / f"{REFERENCE}.pkl").read_bytes())
assert ref["ids"] == ids, "AVP différents de la référence"
m_ref = matrice(ref["sims"], ref["poids"], 0.575, 0.775)
a, b = mesures(m_ref, R, poste_avp), mesures(m_new, R, poste_avp)
diff = compare(m_ref, m_new, R, poste_avp)
print(f"\nJeu d'évaluation n° 2 (68 CV) : service actuel -> modèle testé, écart [IC 95 % apparié]")
for k in a:
moy, lo, hi = diff[k]
verdict = "MIEUX" if lo > 0 else "MOINS BIEN" if hi < 0 else "pas de différence démontrée"
print(f" {k:20s} {a[k]:.3f} -> {b[k]:.3f} {moy:+.3f} [{lo:+.3f} ; {hi:+.3f}] {verdict}")
(CACHE / f"{etiquette()}_comparaison.json").write_text(json.dumps(
{"modele": config.MODEL_NAME, "prompt": config.MODEL_PROMPT, "reranker": config.RERANKER_MODEL,
"rampe": [bas, haut], "reglage": res_r, "reference": a, "teste": b, "ecarts": diff}, indent=1,
ensure_ascii=False), encoding="utf-8")
if __name__ == "__main__":
main()