Spaces:
Running on Zero
Running on Zero
Download app/scoring.py from Myz0/CV-Matching: direct link, hf CLI and curl.
- Browser
- Download file 13.2 kB
-
https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/app/scoring.py
- Command line
-
hf download hf://spaces/Myz0/CV-Matching/app/scoring.py
-
curl -L -o scoring.py https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/app/scoring.py
13.2 kB
| """Moteur de score commun aux deux sens du matching : | |
| - un CV face à tous les AVP (matching.py, côté candidat) | |
| - un AVP face à un vivier de CV (classement.py, côté recruteur) | |
| Le score d'adéquation, en trois étapes : | |
| 1. Pour chaque attendu de l'AVP, on cherche les phrases du CV les plus proches | |
| (similarité cosinus bge-m3). | |
| 2. On en tire un "degré de couverture" entre 0 et 1, en gardant la meilleure de deux notes : | |
| - la rampe bge-m3 : | |
| sim <= BAS -> 0 (rien à voir) | |
| sim >= HAUT -> 1 (compétence clairement présente) | |
| entre les deux -> progression linéaire | |
| bge-m3 donne ~0.45 pour deux phrases sans rapport et ~0.90 pour deux synonymes : | |
| la rampe étale cette plage étroite sur 0..1. Elle repère bien les reformulations. | |
| - le reranker (si chargé) : il relit l'attendu avec les K phrases les plus proches et | |
| donne une probabilité tranchée (~0 sans rapport, ~1 prouvé). Il écarte le bruit. | |
| Garder la meilleure des deux = un attendu est couvert si l'un OU l'autre le voit. | |
| 3. Moyenne pondérée des degrés. Le poids de chaque attendu = poids du champ x spécificité | |
| (une compétence présente dans tous les AVP, comme "Maîtrise de soi", pèse presque 0). | |
| adequation = somme(poids x degré) / somme(poids) -> entre 0 et 1 | |
| Mesuré sur 24 AVP et 23 CV fictifs (scripts/evaluer_classement.py) : la combinaison classe | |
| mieux que chacune des deux notes seule, sans faux positif. | |
| """ | |
| from __future__ import annotations | |
| import math | |
| import re | |
| from dataclasses import dataclass | |
| import numpy as np | |
| from app import config | |
| from app.prerequis import FACULTATIF, plat, verifier_par_regles | |
| SIM_BAS = getattr(config, "SIM_BAS", 0.575) # [à calibrer] scripts/evaluer_classement.py | |
| SIM_HAUT = getattr(config, "SIM_HAUT", 0.775) | |
| SIM_PREREQUIS = getattr(config, "SIM_PREREQUIS", 0.70) | |
| MIN_PHRASES_CV = getattr(config, "MIN_PHRASES_CV", 5) | |
| MIN_ATTENDUS_AVP = getattr(config, "MIN_ATTENDUS_AVP", 3) | |
| RERANKER_TOP_K = getattr(config, "RERANKER_TOP_K", 3) | |
| SEUILS_LIBELLE = getattr(config, "SEUILS_LIBELLE", [22, 17]) | |
| # Reranker chargé au démarrage du service (app/main.py). None = bge-m3 seul (tests, CPU lent). | |
| RERANKER = None | |
| def degre(sims: np.ndarray, bas: float | None = None, haut: float | None = None) -> np.ndarray: | |
| """Rampe linéaire : similarité -> degré de couverture entre 0 et 1. | |
| Les bornes sont lues à l'appel (et non figées à l'import) pour que le script | |
| de calibration puisse les faire varier.""" | |
| bas = SIM_BAS if bas is None else bas | |
| haut = SIM_HAUT if haut is None else haut | |
| return np.clip((sims - bas) / (haut - bas), 0.0, 1.0) | |
| def probas_reranker_avps(prepares: dict, textes_cv: list[str], | |
| vecs_cv: np.ndarray) -> dict[str, tuple[np.ndarray, np.ndarray]]: | |
| """Notes du reranker d'un CV pour plusieurs AVP, en UN seul appel : le GPU travaille | |
| par gros lots au lieu d'un petit lot par AVP (bien plus rapide). | |
| Pour chaque attendu, le reranker relit les RERANKER_TOP_K phrases du CV les plus proches | |
| selon bge-m3. Retourne {id_avp: (meilleure probabilité, indice de la phrase)}, vide sans | |
| reranker. Ne dépend pas de la rampe : calculé une fois, réutilisable.""" | |
| if RERANKER is None or len(vecs_cv) == 0: | |
| return {} | |
| tops, paires = {}, [] | |
| for id_avp, p in prepares.items(): | |
| if not len(p.attendus): | |
| continue | |
| top = np.argsort(-(p.vecs_attendus @ vecs_cv.T), axis=1)[:, :RERANKER_TOP_K] | |
| tops[id_avp] = top | |
| paires += [(p.attendus[i][0], textes_cv[j]) for i, ligne in enumerate(top) for j in ligne] | |
| probas = RERANKER.probas(paires) | |
| res, debut = {}, 0 | |
| for id_avp, top in tops.items(): | |
| p = probas[debut:debut + top.size].reshape(top.shape) | |
| debut += top.size | |
| meilleure = p.argmax(axis=1) | |
| lignes = np.arange(len(top)) | |
| res[id_avp] = (p[lignes, meilleure], top[lignes, meilleure]) | |
| return res | |
| def couvertures(sims: np.ndarray, rr: tuple[np.ndarray, np.ndarray] | None, | |
| bas: float | None = None, haut: float | None = None | |
| ) -> tuple[np.ndarray, np.ndarray]: | |
| """Degré de couverture de chaque attendu = max(rampe bge-m3, probabilité reranker), | |
| et l'indice de la phrase du CV qui l'a obtenu (pour l'explication).""" | |
| idx = sims.argmax(axis=1) | |
| d = degre(sims[np.arange(len(sims)), idx], bas, haut) | |
| if rr is not None: | |
| p, idx_rr = rr | |
| mieux = p > d | |
| d = np.where(mieux, p, d) | |
| idx = np.where(mieux, idx_rr, idx) | |
| return d, idx | |
| # Le libellé est un AVIS, réglé sur des notes humaines (scripts/calibrer_libelles.py), pas une | |
| # lecture du pourcentage : même un CV qui fait le métier ne prouve mot pour mot qu'un quart à la | |
| # moitié des compétences d'un AVP. Le pourcentage reste affiché à côté, avec son sens propre. | |
| NIVEAUX = {"adapte": "Profil adapté", "a_etudier": "Profil à étudier", "peu_adapte": "Profil peu adapté"} | |
| def pourcentage_entier(pourcentage: float) -> int: | |
| """Pourcentage 0..1 -> entier affiché, arrondi comme sur la page : l'API donne le pourcentage | |
| à une décimale, le front l'arrondit au plus proche (Math.round : 32,5 -> 33).""" | |
| return math.floor(round(100 * pourcentage, 1) + 0.5) | |
| def niveau(pourcentage: float) -> str: | |
| """Pourcentage des compétences 0..1 (Score.pourcentage_competences) -> code de niveau. | |
| Comparé à l'entier AFFICHÉ : « 22 % » est toujours « adapté » si le seuil est 22.""" | |
| adapte, a_etudier = SEUILS_LIBELLE | |
| score = pourcentage_entier(pourcentage) | |
| if score >= adapte: | |
| return "adapte" | |
| if score >= a_etudier: | |
| return "a_etudier" | |
| return "peu_adapte" | |
| def libelle(pourcentage: float) -> str: | |
| """Pourcentage des compétences 0..1 -> libellé affiché aux candidats et aux recruteurs.""" | |
| return NIVEAUX[niveau(pourcentage)] | |
| class Detail: | |
| """Une ligne d'explication : un attendu de l'AVP et ce que le CV y répond.""" | |
| attendu: str | |
| champ: str | |
| poids: float | |
| similarite: float # cosinus bge-m3 entre l'attendu et la phrase retenue | |
| degre: float # couverture 0..1 retenue (rampe ou reranker) | |
| phrase_cv: str | |
| source_cv: str | |
| couverte: bool | |
| savoir_etre: bool = False # affiché "à vérifier en entretien", compte quand même | |
| # Les deux notes dont 'degre' est le maximum (pour l'explication seulement) | |
| similarite_max: float = 0.0 # meilleur cosinus bge-m3 parmi les phrases du CV | |
| degre_rampe: float = 0.0 # ce cosinus passé dans la rampe, 0..1 | |
| proba_reranker: float | None = None # meilleure probabilité du reranker, None sans reranker | |
| class Score: | |
| adequation: float # 0..1, score principal (soft, pondéré) | |
| couverture: float # 0..1, part pondérée des attendus au-dessus du seuil | |
| details: list[Detail] | |
| fiable: bool | |
| avertissement: str | None | |
| def nb_savoir_faire(self) -> int: | |
| return sum(not d.savoir_etre for d in self.details) | |
| def nb_savoir_faire_couverts(self) -> int: | |
| return sum(d.couverte and not d.savoir_etre for d in self.details) | |
| def pourcentage_competences(self) -> float: | |
| """Part des compétences du poste couvertes par le CV, pondérées par leur importance, | |
| 0..1. Même calcul que le score, sans les savoir-être (qu'un CV écrit rarement) : | |
| c'est le pourcentage à afficher. Le score (adequation) reste le critère de tri.""" | |
| sf = [d for d in self.details if not d.savoir_etre] | |
| total = sum(d.poids for d in sf) | |
| return sum(d.poids * d.degre for d in sf) / total if total > 0 else 0.0 | |
| def scorer( | |
| attendus: list[tuple[str, str]], | |
| vecs_attendus: np.ndarray, | |
| poids: np.ndarray, | |
| phrases_cv: list[tuple[str, str]], | |
| vecs_cv: np.ndarray, | |
| seuil: float, | |
| savoir_etre: np.ndarray | None = None, | |
| rr: tuple[np.ndarray, np.ndarray] | None = None, | |
| ) -> Score: | |
| """Score d'un CV face à un AVP. Aucun arrondi ici : on arrondit à l'affichage. | |
| rr : notes du reranker pour cet AVP, calculées d'avance avec probas_reranker_avps | |
| (None = bge-m3 seul).""" | |
| raisons = [] | |
| if len(phrases_cv) < MIN_PHRASES_CV: | |
| raisons.append(f"CV court ({len(phrases_cv)} éléments exploitables) : " | |
| "le score repose sur peu d'informations.") | |
| if len(attendus) < MIN_ATTENDUS_AVP: | |
| raisons.append(f"AVP peu détaillé ({len(attendus)} attendus extraits).") | |
| if not attendus or len(phrases_cv) == 0 or float(np.sum(poids)) <= 0: | |
| return Score(0.0, 0.0, [], False, | |
| " ".join(raisons) or "Aucun attendu exploitable dans l'AVP.") | |
| sims = vecs_attendus @ vecs_cv.T # (n_attendus, n_phrases_cv) | |
| d, idx = couvertures(sims, rr) | |
| couvertes = d >= seuil | |
| sim_max = sims.max(axis=1) | |
| d_rampe = degre(sim_max) | |
| if savoir_etre is None: | |
| savoir_etre = np.zeros(len(attendus), dtype=bool) | |
| w = poids | |
| adequation = float(np.sum(w * d) / np.sum(w)) | |
| couverture = float(np.sum(w * couvertes) / np.sum(w)) | |
| details = [ | |
| Detail( | |
| attendu=attendus[i][0], champ=attendus[i][1], poids=float(w[i]), | |
| similarite=float(sims[i, idx[i]]), degre=float(d[i]), | |
| phrase_cv=phrases_cv[idx[i]][0], source_cv=phrases_cv[idx[i]][1], | |
| couverte=bool(couvertes[i]), savoir_etre=bool(savoir_etre[i]), | |
| similarite_max=float(sim_max[i]), degre_rampe=float(d_rampe[i]), | |
| proba_reranker=float(rr[0][i]) if rr is not None else None, | |
| ) | |
| for i in range(len(attendus)) | |
| ] | |
| return Score(adequation, couverture, details, not raisons, " ".join(raisons) or None) | |
| def adequations_tous_avps(prepares, vecs_cv: np.ndarray, | |
| rr: dict | None = None) -> dict[str, float]: | |
| """Adéquation d'un CV avec chaque AVP (sans détails), pour situer un score. | |
| rr : notes du reranker par AVP (probas_reranker_avps) ; sans, bge-m3 seul.""" | |
| rr = rr or {} | |
| res = {} | |
| for id_avp, p in prepares.items(): | |
| if len(p.attendus) == 0 or float(np.sum(p.poids)) <= 0 or len(vecs_cv) == 0: | |
| res[id_avp] = 0.0 | |
| continue | |
| d, _ = couvertures(p.vecs_attendus @ vecs_cv.T, rr.get(id_avp)) | |
| res[id_avp] = float(np.sum(p.poids * d) / np.sum(p.poids)) | |
| return res | |
| def forces_et_ecarts(details: list[Detail], top: int = 3) -> tuple[list[Detail], list[Detail]]: | |
| """Forces : savoir-faire couverts qui pèsent le plus. Écarts : savoir-faire non couverts | |
| qui pèsent le plus (= ceux qui font le plus baisser le score). Les savoir-être sont | |
| présentés à part (à vérifier en entretien).""" | |
| savoir_faire = [x for x in details if not x.savoir_etre] | |
| forces = sorted((x for x in savoir_faire if x.couverte), | |
| key=lambda x: -x.poids * x.degre)[:top] | |
| ecarts = sorted((x for x in savoir_faire if not x.couverte), | |
| key=lambda x: -x.poids * (1 - x.degre))[:top] | |
| return forces, ecarts | |
| def savoir_etre(details: list[Detail]) -> list[dict]: | |
| """Savoir-être de l'AVP : un CV les écrit rarement, le recruteur les vérifie en entretien. | |
| 'mention_probable' si une phrase du CV semble y répondre.""" | |
| return [{"attendu": d.attendu, | |
| "statut": "mention_probable" if d.couverte else "a_verifier", | |
| "indice_cv": d.phrase_cv if d.couverte else None} | |
| for d in details if d.savoir_etre] | |
| def verifier_prerequis(prerequis, vecs_prerequis, phrases_cv, vecs_cv, cv: dict | None = None) -> list[dict]: | |
| """Les prérequis (diplôme, permis, années d'expérience) ne sont pas notés ni éliminatoires : | |
| des règles disent s'ils sont remplis (app/prerequis.py) ; une condition qu'aucune règle ne | |
| reconnaît est rapprochée du CV par bge-m3 (« mention probable »). Le recruteur décide.""" | |
| if not prerequis: | |
| return [] | |
| sims = vecs_prerequis @ vecs_cv.T if len(phrases_cv) else None | |
| sortie = [] | |
| for i, (texte, _) in enumerate(prerequis): | |
| regle = verifier_par_regles(texte, cv, phrases_cv) | |
| if regle: | |
| sortie.append(regle) | |
| continue | |
| j = int(sims[i].argmax()) if sims is not None else None | |
| mentionne = j is not None and float(sims[i, j]) >= SIM_PREREQUIS | |
| sortie.append({ | |
| "prerequis": texte, | |
| "statut": "mention_probable" if mentionne else "a_verifier", | |
| "indice_cv": phrases_cv[j][0] if mentionne else None, | |
| "motif": "Une ligne du CV semble l'évoquer" if mentionne else "Non trouvé dans le CV", | |
| "obligatoire": not re.search(FACULTATIF, plat(texte)), | |
| }) | |
| return sortie | |