"""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//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()