CV-Matching / scripts /calibrer_libelles.py
Myz0's picture
Avis calibré sur des notes humaines : Profil adapté / à étudier / peu adapté
a462430 verified
Raw History Blame Contribute Delete
4.32 kB
"""Calibre les seuils des libellés sur le jeu d'évaluation n° 2 (notes humaines 0..3).
Décision attendue par couple (CV, poste type) : note 3 -> « à convoquer », 2 -> « à étudier »,
0-1 -> « non ». Décision du service : son pourcentage (meilleur AVP du poste) comparé à deux seuils :
>= t_haut « Très bonne / Excellente » (à convoquer)
>= t_bas « Bonne / Partielle » (à étudier)
sinon « Faible » (non)
On cherche (t_bas, t_haut) qui maximisent le kappa pondéré (quadratique) entre les deux décisions.
Validation : poste mis de côté (on règle sur 19 postes types, on applique au 20e, pour chacun).
Lancer depuis la racine (après scripts.evaluer_jeu, qui met les similarités en cache) :
python -m scripts.calibrer_libelles
"""
from __future__ import annotations
import json
import numpy as np
from app import config, scoring
from scripts.evaluer_classement import matrice
from scripts.evaluer_jeu import JEU, notes, similarites
NOMS = ["non", "à étudier", "à convoquer"]
def kappa(a: np.ndarray, b: np.ndarray, k: int = 3) -> float:
"""Kappa de Cohen à pondération quadratique."""
o = np.zeros((k, k))
for x, y in zip(a, b):
o[x, y] += 1
w = np.array([[(i - j) ** 2 for j in range(k)] for i in range(k)]) / (k - 1) ** 2
e = np.outer(o.sum(1), o.sum(0)) / o.sum()
return 1 - (w * o).sum() / (w * e).sum()
def decider(pct: np.ndarray, bas: float, haut: float) -> np.ndarray:
return np.where(pct >= haut, 2, np.where(pct >= bas, 1, 0))
def regler(pct, verite, grille):
return max(grille, key=lambda s: (kappa(verite, decider(pct, *s)), -s[1]))
def matrice_confusion(verite, dec) -> str:
lignes = [f" {'note humaine':14s} " + " ".join(f"{n:>12s}" for n in NOMS)]
for v in (2, 1, 0):
lignes.append(f" {NOMS[v]:14s} " + " ".join(f"{int(np.sum((verite == v) & (dec == d))):12d}" for d in range(3)))
return "\n".join(lignes)
def main():
jeu = json.loads(JEU.read_text(encoding="utf-8"))
ids, poids, poids_sf, sims = similarites(jeu["cvs"])
R, poste_avp = notes(jeu, ids)
m_pct = 100 * matrice(sims, poids_sf, scoring.SIM_BAS, scoring.SIM_HAUT)
postes = sorted({p for p in poste_avp if p})
couples = [] # (poste, pourcentage, décision attendue)
for c in range(len(R)):
for k in postes:
cols = [a for a, q in enumerate(poste_avp) if q == k]
g = int(R[c, cols[0]])
couples.append((k, max(m_pct[c, a] for a in cols), {3: 2, 2: 1}.get(g, 0)))
poste = np.array([k for k, _, _ in couples])
pct = np.array([x for _, x, _ in couples])
verite = np.array([v for _, _, v in couples])
seuils = sorted(config.SEUILS_LIBELLE) # [20, 33, 50]
actuel = (seuils[0], seuils[-1]) # partielle dès 20, très bonne dès 50
grille = [(b, h) for b in np.arange(5, 40, 1.0) for h in np.arange(b + 2, 60, 1.0)]
print(f"{len(couples)} couples (CV, poste type) : {np.sum(verite == 2)} à convoquer, "
f"{np.sum(verite == 1)} à étudier, {np.sum(verite == 0)} non\n")
d0 = decider(pct, *actuel)
print(f"Seuils actuels (étudier >= {actuel[0]:.0f} %, convoquer >= {actuel[1]:.0f} %) : kappa {kappa(verite, d0):.3f}")
print(matrice_confusion(verite, d0))
# Validation : poste mis de côté
dec_cv = np.zeros_like(verite)
choisis = []
for k in postes:
test = poste == k
s = regler(pct[~test], verite[~test], grille)
choisis.append(s)
dec_cv[test] = decider(pct[test], *s)
print(f"\nSeuils réglés, poste mis de côté (validation) : kappa {kappa(verite, dec_cv):.3f}")
print(matrice_confusion(verite, dec_cv))
b, h = np.array(choisis).T
print(f" seuils choisis selon le pli : étudier {b.min():.0f}-{b.max():.0f} %, convoquer {h.min():.0f}-{h.max():.0f} %")
final = regler(pct, verite, grille)
print(f"\nSeuils réglés sur tous les postes (à reporter) : étudier >= {final[0]:.0f} %, convoquer >= {final[1]:.0f} %"
f" (kappa {kappa(verite, decider(pct, *final)):.3f}, optimiste)")
if __name__ == "__main__":
main()