Spaces:
Running on Zero
Running on Zero
File size: 8,211 Bytes
e01a936 6044352 e01a936 6044352 e01a936 6044352 e01a936 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | """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()
|