CV-Matching / scripts /evaluer_jeu.py
Myz0's picture
Avis calibré sur des notes humaines : Profil adapté / à étudier / peu adapté
a462430 verified
Raw History Blame Contribute Delete
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()