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