"""Compare le service à des systèmes plus simples, sur un jeu de réglage et un jeu de test. Systèmes (du plus simple au service) : 1. Mots-clés, CV entier TF-IDF du CV entier contre TF-IDF de l'AVP entier (comme un ATS classique) 2. Mots-clés par compétence pour chaque compétence de l'AVP, la phrase du CV la plus proche en TF-IDF ; même moyenne pondérée que le service 3. Embeddings, CV entier bge-m3, CV entier contre AVP entier (recette de l'OPT-NC) 4. Embeddings par compétence bge-m3 phrase à phrase avec la rampe, sans reranker 5. Reranker seul bge-reranker-v2-m3 sur les 3 phrases les plus proches 6. Service meilleure note entre 4 et 5 (le service en ligne) 7. Service + mots-clés (max) par compétence, meilleure note entre le service et les mots-clés 8. Service + mots-clés (moy.) par compétence, moyenne des deux notes (7 et 8 : combinaisons fixées à l'avance, sans réglage, comme le « mots-clés + embeddings » du guide) Jeux : réglage exemples/cv_list.json + attendus.json : 23 CV, ont servi à régler la rampe et les seuils des libellés (résultat optimiste pour le service) test exemples/cv_banc.json : 18 CV écrits avec leurs propres mots, JAMAIS utilisés pour régler (champs _cible et _niveau : parfait, bon, partiel, hors) Aucun réglage n'est fait ici : chaque système est mesuré tel quel, une seule fois. Lancer depuis la racine du projet (archive des 24 AVP) : $env:DATASET_REVISION="1bb92a09a4ff6aa6e9488ee954085019abba7747"; $env:DATASET_DERNIERE="false" python -m scripts.comparer_systemes """ import json from pathlib import Path import numpy as np from sklearn.feature_extraction.text import TfidfVectorizer from app import config, scoring from app.avp_store import AVPStore, texte_embedding from app.cv_texte import phrases_du_cv from app.encodeur import Encodeur from app.outils import textes_pour_calcul from app.reranker import Reranker from scripts.evaluer_classement import charger_attendus, mesurer RACINE = Path(__file__).resolve().parent.parent MOTS_VIDES = ("de du des la le les l d et à a au aux en par pour sur dans un une avec sans ou est sont son sa ses " "leur leurs ce cette ces qui que dont il elle ils elles se ne pas plus tout tous toute toutes être " "avoir faire afin selon lors ainsi etre").split() def ligne(nom, r): return (f" {nom:30s} | {r['cand_top1']:.2f} {r['cand_top3']:.2f} {r['cand_mrr']:.2f} | " f"{r['rec_top1']:.2f} {r['rec_mrr']:.2f} | {r['marge_min']:+.3f} {r['faux_positifs']}") NOMS = ["Mots-clés, CV entier", "Mots-clés par compétence", "Embeddings, CV entier", "Embeddings par compétence", "Reranker seul", "Service (embeddings + reranker)", "Service + mots-clés (max)", "Service + mots-clés (moy.)"] def charger(): scoring.RERANKER = Reranker(config.RERANKER_MODEL) enc = Encodeur(config.MODEL_NAME) store = AVPStore(enc) store.charger() return store, enc def apprendre_tfidf(store, cvs): """TF-IDF appris sur tout le vocabulaire (AVP + CV), sans accents ni mots vides.""" textes = [texte_embedding(p.avp) for p in store.prepares.values()] textes += [t for cv in cvs for t, _ in phrases_du_cv(cv)] return TfidfVectorizer(strip_accents="unicode", lowercase=True, stop_words=MOTS_VIDES, token_pattern=r"(?u)\b\w\w+\b", sublinear_tf=True).fit(textes) def calculer(store, enc, tfidf, cvs) -> dict[str, np.ndarray]: """m[système][c, a] = score du CV c pour l'AVP a (ordre de store.prepares), pour chaque système. En plus : m["Service, pourcentage"], le pourcentage affiché (sans les savoir-être), qui fixe le libellé.""" ids = list(store.prepares) avec = [i for i in ids if len(store.prepares[i].attendus)] m = {n: np.zeros((len(cvs), len(ids))) for n in NOMS + ["Service, pourcentage"]} t_avp = tfidf.transform([texte_embedding(store.prepares[i].avp) for i in ids]) for c, cv in enumerate(cvs): ph = phrases_du_cv(cv) textes = [t for t, _ in ph] calcul = textes_pour_calcul(ph) vecs = enc.encoder(calcul) v_global = enc.encoder(["\n".join(textes)])[0] t_cv = tfidf.transform(["\n".join(textes)]) t_ph = tfidf.transform(textes) rr = scoring.probas_reranker_avps({i: store.prepares[i] for i in avec}, calcul, vecs) m["Mots-clés, CV entier"][c] = (t_avp @ t_cv.T).toarray().ravel() for a, i in enumerate(ids): p = store.prepares[i] m["Embeddings, CV entier"][c, a] = float(p.vec_global @ v_global) if not len(p.attendus): continue w = p.poids kw = (tfidf.transform([t for t, _ in p.attendus]) @ t_ph.T).toarray().max(axis=1) sims = p.vecs_attendus @ vecs.T rampe = scoring.degre(sims.max(axis=1)) proba = rr[i][0] service, _ = scoring.couvertures(sims, rr.get(i)) for nom, d in [("Mots-clés par compétence", kw), ("Embeddings par compétence", rampe), ("Reranker seul", proba), ("Service (embeddings + reranker)", service), ("Service + mots-clés (max)", np.maximum(service, kw)), ("Service + mots-clés (moy.)", (service + kw) / 2)]: m[nom][c, a] = float(np.sum(w * d) / w.sum()) w_sf = w * ~p.savoir_etre m["Service, pourcentage"][c, a] = float(np.sum(w_sf * service) / w_sf.sum()) if w_sf.sum() > 0 else 0.0 print(".", end="", flush=True) print() return m def main(): store, enc = charger() ids = list(store.prepares) cvs = json.loads((RACINE / "exemples/cv_list.json").read_text(encoding="utf-8")) banc = json.loads((RACINE / "exemples/cv_banc.json").read_text(encoding="utf-8")) m = calculer(store, enc, apprendre_tfidf(store, cvs + banc), cvs + banc) noms = NOMS # ---------------------------------------------------------------- jeu de réglage attendus = charger_attendus(ids) n = len(cvs) print(f"\nJEU DE RÉGLAGE : {n} CV (exemples/cv_list.json), {sum(v is not None for v in attendus.values())} avec bon poste connu, " f"{sum(v is None for v in attendus.values())} hors domaine ; a servi à régler le service") print(f" {'système':30s} | candidat : 1er top 3 MRR | recruteur : 1er MRR | marge faux positifs") for nom in noms: print(ligne(nom, mesurer(m[nom][:n], ids, attendus))) # ---------------------------------------------------------------- jeu de test print(f"\nJEU DE TEST : {len(banc)} CV (exemples/cv_banc.json), jamais utilisés pour régler") print(f" {'système':30s} | poste visé 1er top 3 MRR | parfaits 1er | pire parfait / bon > meilleur hors domaine ?") for nom in noms: mt = m[nom][n:] rangs, parfaits, ok = [], [], [] for k, cv in enumerate(banc): if not cv["_cible"]: continue cols = [a for a, i in enumerate(ids) if any(i.startswith(x) for x in cv["_cible"])] r = min(1 + int(np.sum(mt[k] > mt[k, a])) for a in cols) rangs.append(r) if cv["_niveau"] in ("parfait", "bon"): parfaits.append(r) ok.append(max(mt[k, a] for a in cols)) hors = [mt[k].max() for k, cv in enumerate(banc) if cv["_niveau"] == "hors"] rangs = np.array(rangs) print(f" {nom:30s} | {np.mean(rangs == 1):.2f} {np.mean(rangs <= 3):.2f} {np.mean(1 / rangs):.2f} | " f"{sum(r == 1 for r in parfaits)}/{len(parfaits)} | {min(ok):.3f} / {max(hors):.3f} " f"{'oui' if min(ok) > max(hors) else 'NON'}") print("\nNB : les scores des systèmes n'ont pas la même échelle (TF-IDF, cosinus, moyenne de degrés) : on compare" " des rangs et des séparations, pas les valeurs.") if __name__ == "__main__": main()