File size: 4,138 Bytes
e01a936
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Tests de robustesse : le score mesure-t-il le fond ou la forme ?



1. Reformulation : les 7 CV parfaits ou bons du banc (exemples/cv_banc.json) réécrits sans le

   vocabulaire de l'AVP (exemples/cv_reformules.json), même parcours. Un système qui mesure le fond

   garde le poste visé en tête ; un système qui compte les mots communs s'effondre.

2. Ordre : les mêmes CV avec les sections et les lignes dans un autre ordre. Le score doit être

   identique (chaque compétence prend la meilleure ligne du CV, où qu'elle soit).

Les systèmes et leur calcul sont ceux de scripts/comparer_systemes.py.



Lancer depuis la racine du projet (archive des 24 AVP) :

  $env:DATASET_REVISION="1bb92a09a4ff6aa6e9488ee954085019abba7747"; $env:DATASET_DERNIERE="false"

  python -m scripts.tester_robustesse

"""
import copy
import json
from pathlib import Path

import numpy as np

from scripts.comparer_systemes import NOMS, apprendre_tfidf, calculer, charger

RACINE = Path(__file__).resolve().parent.parent
SYSTEMES = ["Mots-clés, CV entier", "Mots-clés par compétence", "Embeddings, CV entier",
            "Embeddings par compétence", "Service (embeddings + reranker)"]


def melanger(cv: dict) -> dict:
    """Même contenu, autre ordre : postes, lignes, formations et blocs de compétences inversés.

    (L'ordre des mots-clés À L'INTÉRIEUR d'une ligne n'est pas touché : il change la phrase elle-même,

    ce qui relève de la reformulation ; mesuré à part, il bouge le score de moins d'un point.)"""
    cv = copy.deepcopy(cv)
    for cle in ("work", "education", "skills", "projects", "certificates"):
        if cv.get(cle):
            cv[cle] = cv[cle][::-1]
    for w in cv.get("work") or []:
        if w.get("highlights"):
            w["highlights"] = w["highlights"][::-1]
    return cv


def main():
    store, enc = charger()
    ids = list(store.prepares)
    banc = {c["_id"]: c for c in json.loads((RACINE / "exemples/cv_banc.json").read_text(encoding="utf-8"))}
    reformules = json.loads((RACINE / "exemples/cv_reformules.json").read_text(encoding="utf-8"))
    originaux = [banc[r["_origine"]] for r in reformules]
    melanges = [melanger(c) for c in originaux]
    tfidf = apprendre_tfidf(store, list(banc.values()) + reformules)
    m = calculer(store, enc, tfidf, originaux + reformules + melanges)
    n = len(originaux)

    # ------------------------------------------------------------ 1. reformulation
    print(f"\n1. REFORMULATION : {n} CV réécrits sans le vocabulaire de l'AVP (même parcours)")
    print("   Rang du poste visé (1 = en tête) et score sur ce poste, original -> reformulé\n")
    print(f"   {'CV':28s} | " + " | ".join(f"{s[:24]:>24s}" for s in SYSTEMES))
    resume = {s: [] for s in SYSTEMES}
    for k, cv in enumerate(originaux):
        cols = [a for a, i in enumerate(ids) if any(i.startswith(x) for x in cv["_cible"])]
        cases = []
        for s in SYSTEMES:
            o, r = m[s][k], m[s][n + k]
            ro, rr = (min(1 + int(np.sum(x > x[a])) for a in cols) for x in (o, r))
            so, sr = max(o[a] for a in cols), max(r[a] for a in cols)
            resume[s].append((ro, rr, so, sr))
            cases.append(f"{ro:2d} -> {rr:2d} ({so:.2f}->{sr:.2f})")
        print(f"   {cv['_id'][:28]:28s} | " + " | ".join(f"{c:>24s}" for c in cases))
    print("\n   Bilan par système :")
    for s, x in resume.items():
        x = np.array(x)
        perte = 100 * (1 - x[:, 3].sum() / x[:, 2].sum())
        print(f"   {s:32s} poste visé en tête : {int((x[:, 0] == 1).sum())}/{n} -> {int((x[:, 1] == 1).sum())}/{n} ; "
              f"score sur ce poste : -{perte:.0f} %")

    # ------------------------------------------------------------ 2. ordre
    print(f"\n2. ORDRE : les mêmes {n} CV, sections et lignes dans l'ordre inverse")
    for s in SYSTEMES:
        ecart = float(np.abs(m[s][:n] - m[s][2 * n:]).max())
        print(f"   {s:32s} écart maximal de score : {ecart:.6f} {'(identique)' if ecart < 1e-4 else ''}")


if __name__ == "__main__":
    main()