File size: 4,315 Bytes
a462430
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
"""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()