Spaces:
Running on Zero
Running on Zero
File size: 8,111 Bytes
a462430 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | """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()
|