Spaces:
Running on Zero
Running on Zero
Download scripts/banc_essai.py from Myz0/CV-Matching: direct link, hf CLI and curl.
- Browser
- Download file 14.5 kB
-
https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/scripts/banc_essai.py
- Command line
-
hf download hf://spaces/Myz0/CV-Matching/scripts/banc_essai.py
-
curl -L -o banc_essai.py https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/scripts/banc_essai.py
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() | |