Spaces:
Running on Zero
Running on Zero
Download scripts/evaluer_jeu.py from Myz0/CV-Matching: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/scripts/evaluer_jeu.py
- Command line
-
hf download hf://spaces/Myz0/CV-Matching/scripts/evaluer_jeu.py
-
curl -L -o evaluer_jeu.py https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/scripts/evaluer_jeu.py
11.5 kB
| """Mesure le service sur le jeu d'évaluation n° 2 (exemples/cv_eval.json, 68 CV notés 0..3). | |
| Notes : 3 = à convoquer, 2 = à étudier, 1 = lien faible, 0 = hors sujet, données par POSTE TYPE | |
| (tous les AVP d'un même poste type ont la même note). | |
| Mesures (avec intervalle de confiance à 95 % par bootstrap sur les CV) : | |
| candidat pour chaque CV qui a un poste noté >= 2 : nDCG@5 des AVP proposés, et « 1er pertinent » | |
| (l'AVP en tête est noté >= 2) | |
| recruteur pour chaque AVP : nDCG@10 du vivier de 68 CV, et « 1er au top » (le CV en tête a la | |
| meilleure note du vivier) ; moyenne par poste type, puis sur les postes | |
| séparation AUC : probabilité qu'un CV noté >= 2 ait un meilleur score qu'un CV noté 0 sur le même AVP | |
| pièges CV qui partagent le vocabulaire sans faire le métier : passent-ils devant le CV | |
| partiel de « leur » poste ? | |
| libellés le pourcentage affiché et son libellé, face à la note humaine (3 / 2 / <= 1) | |
| Les similarités sont calculées une fois et gardées dans resultats/jeu_eval/<modèle>.pkl : relancer | |
| avec un autre réglage de rampe ne recalcule rien. Changer de modèle : MODEL_NAME / RERANKER_MODEL. | |
| Lancer depuis la racine : | |
| python -m scripts.evaluer_jeu mesures | |
| python -m scripts.evaluer_jeu --grille + exemples/grille_jeu_eval.csv à vérifier à la main | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import csv | |
| import json | |
| import os | |
| import pickle | |
| import re | |
| from collections import defaultdict | |
| from pathlib import Path | |
| import numpy as np | |
| RACINE = Path(__file__).resolve().parent.parent | |
| os.environ.setdefault("DATASET_REVISION", "1bb92a09a4ff6aa6e9488ee954085019abba7747") | |
| from app import config, scoring # noqa: E402 | |
| from scripts.evaluer_classement import matrice # noqa: E402 | |
| JEU = RACINE / "exemples" / "cv_eval.json" | |
| CACHE = RACINE / "resultats" / "jeu_eval" | |
| def etiquette_modele() -> str: | |
| nom = f"{config.MODEL_NAME}+{config.RERANKER_MODEL or 'sans-reranker'}" | |
| return re.sub(r"[^\w.+-]", "_", nom) | |
| def similarites(cvs: list[dict]): | |
| """(ids des AVP, poids, poids savoir-faire, sims[c][a]) ; en cache par modèle.""" | |
| CACHE.mkdir(parents=True, exist_ok=True) | |
| fichier = CACHE / f"{etiquette_modele()}.pkl" | |
| cle = [c["_id"] for c in cvs] | |
| if fichier.exists(): | |
| d = pickle.loads(fichier.read_bytes()) | |
| if d["cvs"] == cle: | |
| print(f"Similarités relues : {fichier.relative_to(RACINE)}") | |
| return d["ids"], d["poids"], d["poids_sf"], d["sims"] | |
| 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 | |
| print("Chargement des modèles et des AVP...") | |
| 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] | |
| sims = [] | |
| for n, 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 CV {n}/{len(cvs)}", end="", flush=True) | |
| print() | |
| fichier.write_bytes(pickle.dumps({"cvs": cle, "ids": ids, "poids": poids, "poids_sf": poids_sf, "sims": sims})) | |
| return ids, poids, poids_sf, sims | |
| def notes(jeu: dict, ids: list[str]) -> tuple[np.ndarray, list[str | None]]: | |
| """R[c, a] = note du CV c pour l'AVP a ; poste type de chaque AVP.""" | |
| poste_de = {a: k for k, p in jeu["postes"].items() for a in p["avps"]} | |
| poste_avp = [poste_de.get(i) for i in ids] | |
| for i, p in zip(ids, poste_avp): | |
| if p is None: | |
| print(f" ⚠ AVP {i} sans poste type : ignoré dans les mesures") | |
| R = np.zeros((len(jeu["cvs"]), len(ids))) | |
| for c, cv in enumerate(jeu["cvs"]): | |
| for a, p in enumerate(poste_avp): | |
| R[c, a] = cv["_pertinence"].get(p, 0) if p else np.nan | |
| return R, poste_avp | |
| def ndcg(scores: np.ndarray, gains: np.ndarray, k: int) -> float: | |
| ordre = np.argsort(-scores, kind="stable")[:k] | |
| remise = 1 / np.log2(np.arange(2, k + 2)) | |
| dcg = float(np.sum((2 ** gains[ordre] - 1) * remise[:len(ordre)])) | |
| ideal = float(np.sum((2 ** np.sort(gains)[::-1][:k] - 1) * remise[:min(k, len(gains))])) | |
| return dcg / ideal if ideal > 0 else np.nan | |
| def mesures(m: np.ndarray, R: np.ndarray, poste_avp: list, lignes: np.ndarray | None = None) -> dict: | |
| """lignes : indices des CV retenus (bootstrap) ; None = tous.""" | |
| lignes = np.arange(len(m)) if lignes is None else lignes | |
| cols = np.array([p is not None for p in poste_avp]) | |
| mm, rr = m[lignes][:, cols], R[lignes][:, cols] | |
| postes = [p for p in poste_avp if p is not None] | |
| cand = [(ndcg(mm[i], rr[i], 5), rr[i][np.argmax(mm[i])] >= 2) for i in range(len(mm)) if rr[i].max() >= 2] | |
| par_poste = defaultdict(list) | |
| for a, p in enumerate(postes): | |
| if rr[:, a].max() >= 2: | |
| aucs = [float(np.mean(mm[rr[:, a] >= 2, a][:, None] > mm[rr[:, a] == 0, a][None, :]))] | |
| par_poste[p].append((ndcg(mm[:, a], rr[:, a], 10), rr[np.argmax(mm[:, a]), a] == rr[:, a].max(), aucs[0])) | |
| rec = np.array([np.mean(v, axis=0) for v in par_poste.values()]) | |
| return { | |
| "cand_ndcg5": float(np.mean([x for x, _ in cand])), | |
| "cand_1er_pertinent": float(np.mean([y for _, y in cand])), | |
| "rec_ndcg10": float(rec[:, 0].mean()), | |
| "rec_1er_au_top": float(rec[:, 1].mean()), | |
| "auc": float(rec[:, 2].mean()), | |
| } | |
| def bootstrap(m, R, poste_avp, n=500, graine=7) -> dict: | |
| rng = np.random.default_rng(graine) | |
| tirages = [mesures(m, R, poste_avp, rng.integers(0, len(m), len(m))) for _ in range(n)] | |
| return {k: (float(np.percentile([t[k] for t in tirages], 2.5)), float(np.percentile([t[k] for t in tirages], 97.5))) | |
| for k in tirages[0]} | |
| def pieges(jeu, m, p, ids, poste_avp) -> list[str]: | |
| """Pour chaque piège : son meilleur pourcentage sur le poste dont il imite le vocabulaire, | |
| face au partiel et au fort de ce poste ; « PASSE » s'il bat le partiel.""" | |
| par_id = {c["_id"]: i for i, c in enumerate(jeu["cvs"])} | |
| sortie = [] | |
| for c, cv in enumerate(jeu["cvs"]): | |
| if cv["_niveau"] != "piege": | |
| continue | |
| k = cv["_cible"] | |
| cols = [a for a, q in enumerate(poste_avp) if q == k] | |
| f, pa = par_id[f"{k.lower()}_fort"], par_id[f"{k.lower()}_partiel"] | |
| s = {x: max(m[i, a] for a in cols) for x, i in (("piege", c), ("partiel", pa), ("fort", f))} | |
| pct = max(p[c, a] for a in cols) | |
| etat = "PASSE devant le partiel" if s["piege"] > s["partiel"] else "ok" | |
| sortie.append(f" {cv['_id']:14s} {pct * 100:5.1f} % {scoring.libelle(pct):24s} " | |
| f"(fort {s['fort'] * 100:4.1f}, partiel {s['partiel'] * 100:4.1f}, piège {s['piege'] * 100:4.1f}) {etat}") | |
| return sortie | |
| def libelles(m_pct, R, poste_avp) -> list[str]: | |
| """Libellé du service selon la note humaine, sur chaque couple (CV, poste type), avec le | |
| meilleur pourcentage parmi les AVP du poste.""" | |
| noms = list(scoring.NIVEAUX.values()) | |
| table = {g: defaultdict(int) for g in (3, 2, 1, 0)} | |
| valeurs = {g: [] for g in (3, 2, 1, 0)} | |
| postes = sorted({q for q in poste_avp if q}) | |
| for c in range(len(R)): | |
| for k in postes: | |
| cols = [a for a, q in enumerate(poste_avp) if q == k] | |
| g, x = int(R[c, cols[0]]), max(m_pct[c, a] for a in cols) | |
| table[g][scoring.libelle(x)] += 1 | |
| valeurs[g].append(100 * x) | |
| sortie = [f" {'note humaine':16s} " + " ".join(f"{n.replace('Profil ', ''):>12s}" for n in noms) + " médiane (min-max)"] | |
| for g, nom in ((3, "3 convoquer"), (2, "2 étudier"), (1, "1 lien faible"), (0, "0 hors sujet")): | |
| v = valeurs[g] | |
| sortie.append(f" {nom:16s} " + " ".join(f"{table[g][n]:12d}" for n in noms) | |
| + f" {np.median(v):4.0f} % ({min(v):.0f}-{max(v):.0f})") | |
| return sortie | |
| def ecrire_grille(jeu, m_pct, ids, poste_avp): | |
| """Grille de vérification : chaque couple (CV, poste type) noté > 0, plus le meilleur poste | |
| du service quand il est noté 0 (désaccord à trancher).""" | |
| postes = jeu["postes"] | |
| lignes = [] | |
| for c, cv in enumerate(jeu["cvs"]): | |
| meilleur = {} | |
| for a, k in enumerate(poste_avp): | |
| if k: | |
| meilleur[k] = max(meilleur.get(k, 0), m_pct[c, a]) | |
| a_voir = set(cv["_pertinence"]) | {max(meilleur, key=meilleur.get)} | |
| for k in sorted(a_voir, key=lambda k: -meilleur[k]): | |
| lignes.append([cv["_id"], cv["basics"]["label"], cv["_niveau"], k, postes[k]["titre"], | |
| cv["_pertinence"].get(k, 0), f"{100 * meilleur[k]:.0f}", "", ""]) | |
| sortie = RACINE / "exemples" / "grille_jeu_eval.csv" | |
| with sortie.open("w", encoding="utf-8-sig", newline="") as f: | |
| w = csv.writer(f, delimiter=";") | |
| w.writerow(["id_cv", "profil", "niveau", "poste", "titre_poste", "note_proposee", | |
| "pourcentage_service", "note_verifiee", "commentaire"]) | |
| w.writerows(lignes) | |
| print(f"\nGrille à vérifier : {sortie.relative_to(RACINE)} ({len(lignes)} lignes). " | |
| "Remplir note_verifiee (0-3) seulement en cas de désaccord.") | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--grille", action="store_true") | |
| args = ap.parse_args() | |
| jeu = json.loads(JEU.read_text(encoding="utf-8")) | |
| cvs = jeu["cvs"] | |
| ids, poids, poids_sf, sims = similarites(cvs) | |
| R, poste_avp = notes(jeu, ids) | |
| m = matrice(sims, poids, scoring.SIM_BAS, scoring.SIM_HAUT) | |
| m_pct = matrice(sims, poids_sf, scoring.SIM_BAS, scoring.SIM_HAUT) | |
| print(f"\nModèle {config.MODEL_NAME} · reranker {config.RERANKER_MODEL or 'aucun'} · " | |
| f"rampe {scoring.SIM_BAS}/{scoring.SIM_HAUT} · {len(ids)} AVP · {len(cvs)} CV\n") | |
| res, ic = mesures(m, R, poste_avp), bootstrap(m, R, poste_avp) | |
| for k, v in res.items(): | |
| print(f" {k:20s} {v:.3f} [IC 95 % {ic[k][0]:.3f} - {ic[k][1]:.3f}]") | |
| print("\nPièges (pourcentage affiché sur le poste imité) :") | |
| print("\n".join(pieges(jeu, m, m_pct, ids, poste_avp))) | |
| print(f"\nAvis du service (pourcentage, seuils {config.SEUILS_LIBELLE}) " | |
| "selon la note humaine, par couple (CV, poste type) :") | |
| print("\n".join(libelles(m_pct, R, poste_avp))) | |
| CACHE.mkdir(parents=True, exist_ok=True) | |
| (CACHE / f"{etiquette_modele()}.json").write_text(json.dumps( | |
| {"mesures": res, "ic95": ic, "rampe": [scoring.SIM_BAS, scoring.SIM_HAUT]}, indent=1), encoding="utf-8") | |
| if args.grille: | |
| ecrire_grille(jeu, m_pct, ids, poste_avp) | |
| if __name__ == "__main__": | |
| main() | |