CV-Matching / scripts /comparer_systemes.py
Myz0's picture
Libellé lu sur le pourcentage, limites de taille, clé API sur Gradio et MCP, API /v1, versions figées, journal
6044352 verified
Raw History Blame Contribute Delete
8.21 kB
"""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()