Spaces:
Running on Zero
Running on Zero
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()
|