CV-Matching / app /scoring.py
Myz0's picture
Avis calibré sur des notes humaines : Profil adapté / à étudier / peu adapté
a462430 verified
Raw History Blame Contribute Delete
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)]
@dataclass
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
@dataclass
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
@property
def nb_savoir_faire(self) -> int:
return sum(not d.savoir_etre for d in self.details)
@property
def nb_savoir_faire_couverts(self) -> int:
return sum(d.couverte and not d.savoir_etre for d in self.details)
@property
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