"""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