CV-Matching / scripts /banc_essai.py
Myz0's picture
Prérequis vérifiés par règles, conditions du poste, sommaire de la fiche, colonnes qui défilent, logos
e01a936 verified
Raw History Blame Contribute Delete
14.5 kB
"""Banc d'essai des paramètres du score, avec des CV générés et une validation croisée.
Pour chacun des 24 AVP, on génère des CV de trois niveaux à partir de ses attendus, reformulés
à la manière d'un CV (« Gérer les stocks » -> « J'ai géré les stocks ») :
parfait toutes les compétences du poste + ses savoir-être
partiel la moitié des compétences, tirées au hasard
faible un quart des compétences, mêlé à des phrases d'un autre métier
et des CV « lambda » : profil de bureau générique, quelques compétences de postes variés, sans
poste cible. Les vrais CV fictifs étiquetés (exemples/) ne servent JAMAIS au réglage : ils sont le
test final.
Paramètres testés : rampe de l'hybride (SIM_BAS, SIM_HAUT), rampe du score global
(CV entier vs AVP entier) et poids du global dans le mélange (0 = hybride seul).
Validation croisée en K plis sur les AVP : on règle sur les CV générés de K-1 groupes d'AVP, on
teste sur le groupe restant, et on tourne. Puis réglage sur tous les CV générés et test sur les
vrais CV.
Limite : les CV générés reprennent le vocabulaire des AVP, ils favorisent l'hybride (qui compare
attendu par attendu). Le test sur les vrais CV, écrits avec d'autres mots, corrige ce biais.
Lancer depuis la racine du projet (dataset complet : $env:DATASET_REVISION=...) :
python -m scripts.banc_essai [--plis 4] [--graine 7]
Écrit resultats/<date>/banc_essai/ : cv_generes.json et resultats.json.
"""
from __future__ import annotations
import argparse
import json
import random
from datetime import date
from itertools import product
from pathlib import Path
import numpy as np
from app import config, scoring
from app.avp_store import AVPStore
from app.cv_texte import phrases_du_cv
from app.encodeur import Encodeur
from scripts.evaluer_classement import charger_attendus, mesurer
RACINE = Path(__file__).resolve().parent.parent
GRILLE_HYBRIDE = [(0.55, 0.75), (0.575, 0.775), (0.60, 0.80)]
GRILLE_GLOBAL = [(0.40, 0.70), (0.45, 0.80), (0.50, 0.80)]
GRILLE_POIDS = [0.0, 0.15, 0.3, 0.5]
ACTUEL = (0.575, 0.775, 0.45, 0.80, 0.0) # hybride seul, réglage du service
GENERIQUE = [
"Maîtrise des outils bureautiques (Word, Excel, messagerie)", "Accueil et orientation du public",
"Classement et archivage de documents", "Travail en équipe dans un service administratif",
"Gestion du courrier entrant et sortant", "Saisie de données dans un logiciel métier",
"Prise de rendez-vous et tenue d'agenda", "Permis B",
]
PARTICIPES = {
"mettre": "mis", "rendre": "rendu", "conduire": "conduit", "prévoir": "prévu", "tenir": "tenu",
"entretenir": "entretenu", "promouvoir": "promu", "faire": "fait", "prendre": "pris",
"suivre": "suivi", "produire": "produit", "maintenir": "maintenu", "recevoir": "reçu",
"détenir": "détenu", "soumettre": "soumis", "transmettre": "transmis", "permettre": "permis",
"construire": "construit", "réduire": "réduit", "traduire": "traduit", "obtenir": "obtenu",
}
PREFIXES_NOM = ["Maîtrise : ", "Connaissances : ", "Pratique : "]
# ---------- Génération des CV ----------
def reformuler(texte: str, rng: random.Random) -> str:
"""Attendu d'AVP -> ligne de CV. Verbe à l'infinitif -> passé composé ; sinon nom préfixé."""
mots = texte.strip().split()
if not mots:
return texte
v, reste = mots[0].lower().strip(",:"), " ".join(mots[1:])
if v.startswith("s'") and len(mots) > 1: # s'exprimer -> je me suis exprimé
base = v[2:]
p = PARTICIPES.get(base) or (base[:-2] + "é" if base.endswith("er") else None)
if p:
return f"Je me suis {p} {reste}".strip()
p = PARTICIPES.get(v)
if not p and len(v) > 4 and v.endswith("er"):
p = v[:-2] + "é"
elif not p and len(v) > 4 and v.endswith("ir") and v not in ("savoir", "avoir", "devoir"):
p = v[:-1]
if p and v not in ("être", "savoir", "avoir", "disposer"):
return f"J'ai {p} {reste}".strip()
return rng.choice(PREFIXES_NOM) + texte[0].lower() + texte[1:]
def cv(titre: str, resume: str, phrases: list[str]) -> dict:
return {"basics": {"label": titre, "summary": resume},
"work": [{"position": titre, "name": "Organisation fictive", "highlights": phrases}]}
def generer(store, rng: random.Random) -> list[dict]:
"""[{cv, niveau, source}] ; source = id de l'AVP visé (None pour lambda)."""
ids = list(store.prepares)
sortie = []
for i in ids:
p = store.prepares[i]
sf = [t for (t, _), se in zip(p.attendus, p.savoir_etre) if not se]
se = [t for (t, _), s in zip(p.attendus, p.savoir_etre) if s]
if len(sf) < 4:
continue
titre = p.titre or "Agent"
autre = store.prepares[rng.choice([x for x in ids if x != i])]
autres_sf = [t for (t, _), s in zip(autre.attendus, autre.savoir_etre) if not s]
qualites = ("Qualités : " + ", ".join(x.lower() for x in se) + ".") if se else ""
k_partiel, k_faible = max(2, len(sf) // 2), max(1, len(sf) // 4)
sortie += [
{"niveau": "parfait", "source": i, "cv": cv(titre, f"Expérience confirmée sur ce métier. {qualites}",
[reformuler(t, rng) for t in sf])},
{"niveau": "partiel", "source": i, "cv": cv(titre, "Expérience sur un poste proche.",
[reformuler(t, rng) for t in rng.sample(sf, k_partiel)]
+ rng.sample(GENERIQUE, 2))},
{"niveau": "faible", "source": i, "cv": cv(autre.titre or "Agent", "Reconversion envisagée.",
[reformuler(t, rng) for t in rng.sample(sf, k_faible)]
+ [reformuler(t, rng) for t in rng.sample(autres_sf, min(4, len(autres_sf)))])},
]
for k in range(len(ids) // 2): # lambda : profil générique
pioche = []
for j in rng.sample(ids, 5):
q = store.prepares[j]
sf = [t for (t, _), s in zip(q.attendus, q.savoir_etre) if not s]
if sf:
pioche.append(reformuler(rng.choice(sf), rng))
sortie.append({"niveau": "lambda", "source": None,
"cv": cv("Employé polyvalent", "Profil généraliste, ouvert à différents postes.",
rng.sample(GENERIQUE, 4) + pioche)})
return sortie
# ---------- Calcul (une seule fois, sur le GPU) ----------
def preparer(store, encodeur, cvs: list[dict]):
"""Pour chaque CV : similarités et notes du reranker par AVP, similarité globale par AVP."""
ids = list(store.prepares)
detail, globale = [], np.zeros((len(cvs), len(ids)))
for c, x in enumerate(cvs):
textes = [t for t, _ in phrases_du_cv(x)]
vecs = encodeur.encoder(textes)
v_cv = encodeur.encoder(["\n".join(textes)])[0]
rr = scoring.probas_reranker_avps(store.prepares, textes, vecs)
detail.append([(store.prepares[i].vecs_attendus @ vecs.T, rr.get(i)) if len(store.prepares[i].attendus)
else None for i in ids])
globale[c] = [float(store.prepares[i].vec_global @ v_cv) for i in ids]
if c % 20 == 0:
print(f" {c + 1}/{len(cvs)} CV calculés", flush=True)
return detail, globale
def matrice_hybride(detail, poids, bas, haut) -> np.ndarray:
m = np.zeros((len(detail), len(poids)))
for c, ligne in enumerate(detail):
for a, (x, w) in enumerate(zip(ligne, poids)):
if x is not None and w.sum() > 0:
d, _ = scoring.couvertures(x[0], x[1], bas, haut)
m[c, a] = float(np.sum(w * d) / w.sum())
return m
# ---------- Mesures ----------
def mesures_generes(m: np.ndarray, gen: list[dict], decalage: int, ids: list[str], avps_test: set[str]) -> dict:
"""m : toutes les lignes (vrais CV puis générés). Mesure sur les CV générés des AVP de test."""
ligne = {(g["niveau"], g["source"]): decalage + k for k, g in enumerate(gen) if g["source"]}
lambdas = [decalage + k for k, g in enumerate(gen) if g["niveau"] == "lambda"]
rang_cand, rec_parfait, ordre, scores = [], [], [], {n: [] for n in ("parfait", "partiel", "faible", "lambda")}
for i in avps_test:
a = ids.index(i)
for niveau in ("parfait", "partiel", "faible"):
if (niveau, i) in ligne:
c = ligne[(niveau, i)]
rang_cand.append((niveau, 1 + int(np.sum(m[c] > m[c, a]))))
scores[niveau].append(100 * m[c, a])
if ("parfait", i) in ligne:
c = ligne[("parfait", i)]
rec_parfait.append(1 + int(np.sum(m[:, a] > m[c, a])))
n = [m[ligne[(x, i)], a] for x in ("parfait", "partiel", "faible") if (x, i) in ligne]
ordre.append(all(n[k] > n[k + 1] for k in range(len(n) - 1)) and n[-1] > max(m[l, a] for l in lambdas))
scores["lambda"] = [100 * m[l].max() for l in lambdas]
r = {f"cand_top1_{n}": float(np.mean([x == 1 for niv, x in rang_cand if niv == n])) for n in ("parfait", "partiel", "faible")}
r["cand_mrr"] = float(np.mean([1 / x for _, x in rang_cand]))
r["rec_top1_parfait"] = float(np.mean([x == 1 for x in rec_parfait]))
r["ordre_respecte"] = float(np.mean(ordre))
r["scores_affiches"] = {n: [round(float(np.percentile(v, q)), 1) for q in (10, 50, 90)] for n, v in scores.items() if v}
return r
def objectif(r: dict) -> float:
return r["cand_mrr"] + r["rec_top1_parfait"] + r["ordre_respecte"]
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--plis", type=int, default=4)
ap.add_argument("--graine", type=int, default=7)
args = ap.parse_args()
rng = random.Random(args.graine)
sortie = RACINE / "resultats" / date.today().isoformat() / "banc_essai"
sortie.mkdir(parents=True, exist_ok=True)
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]
vrais = json.loads((RACINE / "exemples/cv_list.json").read_text(encoding="utf-8"))
attendus_vrais = charger_attendus(ids)
gen = generer(store, rng)
(sortie / "cv_generes.json").write_text(json.dumps(gen, ensure_ascii=False, indent=1), encoding="utf-8")
compte = {n: sum(g["niveau"] == n for g in gen) for n in ("parfait", "partiel", "faible", "lambda")}
print(f"{len(ids)} AVP · {len(vrais)} vrais CV fictifs (test final) · CV générés : {compte}")
print("Calcul des similarités (une fois)…")
detail, globale = preparer(store, encodeur, vrais + [g["cv"] for g in gen])
hybrides = {h: matrice_hybride(detail, poids, *h) for h in GRILLE_HYBRIDE}
reglages = [(*h, *g, w) for h, g, w in product(GRILLE_HYBRIDE, GRILLE_GLOBAL, GRILLE_POIDS)
if w > 0 or g == GRILLE_GLOBAL[0]] # w = 0 : la rampe globale n'a pas d'effet
def matrice(r):
hb, hh, gb, gh, w = r
return w * np.clip((globale - gb) / (gh - gb), 0, 1) + (1 - w) * hybrides[(hb, hh)]
# Validation croisée en K plis sur les AVP
avps_cibles = sorted({g["source"] for g in gen if g["source"]})
rng.shuffle(avps_cibles)
plis = [set(avps_cibles[k::args.plis]) for k in range(args.plis)]
resultats_plis, nv = [], len(vrais)
print(f"\nValidation croisée en {args.plis} plis ({len(reglages)} réglages) :")
for k, test in enumerate(plis):
entrainement = set(avps_cibles) - test
meilleur = max(reglages, key=lambda r: objectif(mesures_generes(matrice(r), gen, nv, ids, entrainement)))
r_test = mesures_generes(matrice(meilleur), gen, nv, ids, test)
r_actuel = mesures_generes(matrice(ACTUEL), gen, nv, ids, test)
resultats_plis.append({"pli": k + 1, "reglage": meilleur, "test": r_test, "actuel": r_actuel})
print(f" pli {k + 1} : réglage {meilleur} | test : objectif {objectif(r_test):.3f} (actuel {objectif(r_actuel):.3f})")
def moyenne(cle, quoi):
return round(float(np.mean([p[quoi][cle] for p in resultats_plis])), 3)
cles = ("cand_top1_parfait", "cand_top1_partiel", "cand_top1_faible", "cand_mrr", "rec_top1_parfait", "ordre_respecte")
print("\nMoyenne sur les plis de test (CV générés jamais vus au réglage) :")
print(f" {'mesure':20s} {'actuel (hybride)':>17s} {'réglé':>8s}")
for c in cles:
print(f" {c:20s} {moyenne(c, 'actuel'):17.3f} {moyenne(c, 'test'):8.3f}")
# Réglage final sur tous les CV générés, test sur les vrais CV
final = max(reglages, key=lambda r: objectif(mesures_generes(matrice(r), gen, nv, ids, set(avps_cibles))))
print(f"\nRéglage final (tous les CV générés) : {final}")
vrais_final = mesurer(matrice(final)[:nv], ids, attendus_vrais)
vrais_actuel = mesurer(matrice(ACTUEL)[:nv], ids, attendus_vrais)
print("Test sur les vrais CV fictifs (jamais utilisés pour régler) :")
print(" actuel :", vrais_actuel)
print(" réglé :", vrais_final)
tous = mesures_generes(matrice(final), gen, nv, ids, set(avps_cibles))
actuel_tous = mesures_generes(matrice(ACTUEL), gen, nv, ids, set(avps_cibles))
print("\nScores affichés /100 sur leur poste (10e · médiane · 90e centile ; lambda = meilleur poste) :")
for n in ("parfait", "partiel", "faible", "lambda"):
print(f" {n:8s} actuel {actuel_tous['scores_affiches'].get(n)} réglé {tous['scores_affiches'].get(n)}")
(sortie / "resultats.json").write_text(json.dumps({
"graine": args.graine, "plis": resultats_plis, "reglage_final": final, "actuel": ACTUEL,
"vrais_cv": {"actuel": vrais_actuel, "regle": vrais_final},
"generes": {"actuel": actuel_tous, "regle": tous}}, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"\n-> {sortie}")
if __name__ == "__main__":
main()