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