File size: 11,506 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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
"""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()