"""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()