CV-Matching / scripts /evaluer_classement.py
Myz0's picture
Avis calibré sur des notes humaines : Profil adapté / à étudier / peu adapté
a462430 verified
Raw History Blame Contribute Delete
7.88 kB
"""Évalue le score dans les deux sens et calibre la rampe SIM_BAS / SIM_HAUT.
Utilise les 23 CV fictifs de exemples/cv_list.json et les réponses attendues de
exemples/attendus.json :
{"0": ["3134-26-1419"], "3": ["3134-26-1386", "3134-26-1388"], "9": null, ...}
- une liste : le ou les AVP sur lesquels ce CV devrait sortir (préfixe d'id accepté)
- null : profil hors domaine, ne devrait être en tête nulle part
- CV absent : cas ambigu (match partiel), ignoré dans les mesures
Mesures :
sens recruteur : pour un AVP, le bon CV est-il en tête du vivier ? (top1, MRR)
sens candidat : pour un CV, son bon AVP est-il en tête ? (top1, top3, MRR)
marge : score du bon CV moins le meilleur score d'un hors-domaine sur le même
AVP. Négatif = faux positif (un hors-domaine passe devant).
Le score est calculé comme dans le service : meilleure note entre la rampe bge-m3 et le
reranker (si RERANKER_MODEL est défini). Les notes du reranker ne dépendent pas de la rampe :
elles sont calculées une fois, puis la rampe est calibrée par-dessus.
Lancer depuis la racine du projet : python -m scripts.evaluer_classement
Sans reranker (pour comparer) : $env:RERANKER_MODEL=""; python -m scripts.evaluer_classement
"""
import json
from pathlib import Path
import numpy as np
from app import config, scoring
from app.avp_store import AVPStore
from app.cv_texte import phrases_du_cv
from app.outils import textes_pour_calcul
from app.encodeur import Encodeur
RACINE = Path(__file__).resolve().parent.parent
def charger_attendus(ids_avp: list[str]) -> dict[int, list[str] | None]:
brut = json.loads((RACINE / "exemples/attendus.json").read_text(encoding="utf-8"))
sortie = {}
for k, v in brut.items():
if v is None:
sortie[int(k)] = None
continue
trouves = [i for x in v for i in ids_avp if i == x or i.startswith(x + "/")]
if not trouves:
print(f" ⚠ CV {k} : AVP attendu(s) {v} absent(s) du dataset, CV ignoré")
continue
sortie[int(k)] = trouves
return sortie
def matrice(sims_cv, poids, bas, haut) -> np.ndarray:
"""scores[c, a] = adéquation du CV c pour l'AVP a, pour une rampe donnée.
sims_cv[c][a] = (similarités attendus x phrases, notes du reranker ou None)."""
m = np.zeros((len(sims_cv), len(poids)))
for c, ligne in enumerate(sims_cv):
for a, (x, w) in enumerate(zip(ligne, poids)):
if x is not None and w.sum() > 0:
d, _ = scoring.couvertures(x[0], x[1], bas, haut)
m[c, a] = float(np.sum(w * d) / w.sum())
return m
def mesurer(m: np.ndarray, ids: list[str], attendus: dict) -> dict:
hors = [c for c, a in attendus.items() if a is None]
rangs_rec, rangs_cand, marges = [], [], []
for c, cibles in attendus.items():
if cibles is None:
continue
cols = [ids.index(a) for a in cibles]
for a in cols: # sens recruteur
rangs_rec.append(1 + int(np.sum(m[:, a] > m[c, a])))
if hors:
marges.append(float(m[c, a] - max(m[h, a] for h in hors)))
rangs_cand.append(min(1 + int(np.sum(m[c] > m[c, a])) for a in cols)) # sens candidat
rr, rc = np.array(rangs_rec), np.array(rangs_cand)
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_top3": round(float(np.mean(rc <= 3)), 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 main():
cvs = json.loads((RACINE / "exemples/cv_list.json").read_text(encoding="utf-8"))
print("Chargement des modèles et des AVP (tous, y compris clos)...")
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)
attendus = charger_attendus(ids)
# Similarités et notes du reranker ne dépendent pas de la rampe : calculées une seule fois
poids = [store.prepares[i].poids for i in ids]
sims_cv = []
for cv in cvs:
phrases = phrases_du_cv(cv)
textes = textes_pour_calcul(phrases) # comme le service (app/outils.py)
vecs = encodeur.encoder(textes) if phrases else None
rr = scoring.probas_reranker_avps(store.prepares, textes, vecs) if vecs is not None else {}
sims_cv.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])
n_hors = sum(v is None for v in attendus.values())
print(f"\n{len(ids)} AVP, {len(cvs)} CV, {len(attendus) - n_hors} avec réponse attendue, "
f"{n_hors} hors domaine")
print(f"Reranker : {scoring.RERANKER.nom if scoring.RERANKER else 'aucun (bge-m3 seul)'}\n")
bas0, haut0 = scoring.SIM_BAS, scoring.SIM_HAUT
m0 = matrice(sims_cv, poids, bas0, haut0)
print(f"Réglage actuel SIM_BAS={bas0} SIM_HAUT={haut0}")
print(" ", mesurer(m0, ids, attendus))
print("\nDétail par CV (réglage actuel) :")
for c, cv in enumerate(cvs):
nom = (cv.get("_profil") or f"CV {c}")[:45]
a = int(np.argmax(m0[c]))
cibles = attendus.get(c, "ignoré") if c in attendus else "ignoré"
ok = " " if cibles in ("ignoré", None) else ("✓ " if ids[a] in cibles else "✗ ")
print(f" {ok}{c:2d} {nom:45s} en tête : {ids[a]:18s} {100 * m0[c, a]:5.1f}/100")
# Seuils des libellés, lus sur le POURCENTAGE affiché (sans les savoir-être) : où tombent les
# bons CV sur leur AVP, et les hors domaine sur l'AVP où ils ont leur meilleur pourcentage ?
poids_sf = [store.prepares[i].poids * ~store.prepares[i].savoir_etre for i in ids]
m_pct = matrice(sims_cv, poids_sf, bas0, haut0)
bons = sorted(100 * m_pct[c, ids.index(a)] for c, cib in attendus.items() if cib for a in cib)
hors = sorted(100 * m_pct[c].max() for c, cib in attendus.items() if cib is None)
print("\nRépartition des pourcentages (pour SEUILS_LIBELLE) :")
print(f" bons CV sur leur AVP : {' '.join(f'{x:.0f}' for x in bons)}")
print(f" hors domaine, meilleur AVP : {' '.join(f'{x:.0f}' for x in hors)}")
print(f" avec SEUILS_LIBELLE={config.SEUILS_LIBELLE} :")
for nom in scoring.NIVEAUX.values():
nb_bons = sum(scoring.libelle(x / 100) == nom for x in bons)
nb_hors = sum(scoring.libelle(x / 100) == nom for x in hors)
print(f" {nom:22s} {nb_bons:2d} bons CV {nb_hors} hors domaine")
print("\nRecherche de la meilleure rampe...")
essais = []
for bas in np.arange(0.35, 0.61, 0.025):
for haut in np.arange(bas + 0.10, 0.86, 0.025):
res = mesurer(matrice(sims_cv, poids, bas, haut), ids, attendus)
cle = (res["rec_mrr"] + res["cand_mrr"], res["marge_min"] or 0)
essais.append((cle, round(float(bas), 3), round(float(haut), 3), res))
essais.sort(key=lambda e: e[0], reverse=True)
for _, bas, haut, res in essais[:5]:
print(f" SIM_BAS={bas} SIM_HAUT={haut} -> {res}")
print("\nReporte le meilleur couple dans app/config.py (ou en variables d'environnement).")
print("Attention : avec ~20 CV, un écart de MRR inférieur à ~0.05 n'est pas significatif.")
if __name__ == "__main__":
main()