Spaces:
Running on Zero
Running on Zero
Download scripts/comparer_modeles.py from Myz0/CV-Matching: direct link, hf CLI and curl.
- Browser
- Download file 8.11 kB
-
https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/scripts/comparer_modeles.py
- Command line
-
hf download hf://spaces/Myz0/CV-Matching/scripts/comparer_modeles.py
-
curl -L -o comparer_modeles.py https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/scripts/comparer_modeles.py
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() | |