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