Myz0 commited on
Commit
482aedd
·
verified ·
1 Parent(s): 8fafe41

Matching CV-AVP : score hybride bge-m3 + reranker, ZeroGPU

Browse files
.dockerignore ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ .git
2
+ .venv
3
+ venv
4
+ __pycache__
5
+ *.pyc
6
+ scores_bruts.json
7
+ .env
.gitignore ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ .venv/
2
+ venv/
3
+ __pycache__/
4
+ *.pyc
5
+ .env
6
+ .gradio/
7
+ flagged/
Dockerfile ADDED
@@ -0,0 +1,26 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Image pour Hugging Face Spaces (SDK "docker") — fonctionne aussi sur n'importe quel serveur.
2
+ FROM python:3.12-slim
3
+
4
+ # Spaces exécute le conteneur avec l'utilisateur 1000
5
+ RUN useradd -m -u 1000 user
6
+ USER user
7
+ ENV HOME=/home/user \
8
+ PATH=/home/user/.local/bin:$PATH \
9
+ HF_HOME=/home/user/.cache/huggingface \
10
+ PYTHONUNBUFFERED=1 \
11
+ GRADIO_ANALYTICS_ENABLED=False
12
+ WORKDIR /home/user/app
13
+
14
+ # torch en version CPU d'abord (~200 Mo au lieu de ~2 Go pour la version CUDA)
15
+ COPY --chown=user requirements.txt .
16
+ RUN pip install --no-cache-dir --user torch --index-url https://download.pytorch.org/whl/cpu \
17
+ && pip install --no-cache-dir --user -r requirements.txt
18
+
19
+ # bge-m3 et le reranker téléchargés une fois à la construction : le démarrage n'attend plus ~4 Go
20
+ RUN python -c "from sentence_transformers import SentenceTransformer, CrossEncoder; \
21
+ SentenceTransformer('BAAI/bge-m3'); CrossEncoder('BAAI/bge-reranker-v2-m3')"
22
+
23
+ COPY --chown=user . .
24
+
25
+ EXPOSE 7860
26
+ CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
README.md CHANGED
@@ -1,13 +1,193 @@
1
  ---
2
- title: CV Matching
3
- emoji: 📉
4
- colorFrom: green
5
- colorTo: purple
6
  sdk: gradio
7
  sdk_version: 6.30.0
8
- python_version: '3.12'
9
- app_file: app.py
10
  pinned: false
 
11
  ---
12
 
13
- Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
  ---
2
+ title: HackAVP Matching CV AVP
3
+ emoji: 🔎
4
+ colorFrom: blue
5
+ colorTo: green
6
  sdk: gradio
7
  sdk_version: 6.30.0
8
+ python_version: "3.10"
9
+ app_file: app_zerogpu.py
10
  pinned: false
11
+ short_description: Matching explicable entre CV et AVP de l'OPT-NC
12
  ---
13
 
14
+ # HackAVP — Microservice de matching CV ↔ AVP
15
+
16
+ Rapproche des CV ([JSON Resume](https://jsonresume.org/schema)) des avis de vacance de poste
17
+ (AVP) de l'OPT-NC publiés en open data ([`opt-nc/odata-avps`](https://huggingface.co/datasets/opt-nc/odata-avps)),
18
+ avec le modèle d'embeddings open source `BAAI/bge-m3`. Le résultat est **explicable** :
19
+ chaque point fort cite la ligne du CV qui répond à l'attendu de l'AVP.
20
+
21
+ Deux sens, un seul moteur de score :
22
+
23
+ | Sens | Question | Route |
24
+ |---|---|---|
25
+ | Candidat | « Quels AVP me correspondent ? » | `POST /match` |
26
+ | Recruteur | « Qui, dans mon vivier, correspond le mieux à cet AVP ? » | `POST /avps/{id_avp}/candidats` |
27
+
28
+ > ⚠️ **Utilisez uniquement des CV fictifs ou le vôtre** (règle du HackAVP). Le service ne lit
29
+ > jamais le nom, l'e-mail ni le téléphone, et n'enregistre aucun CV.
30
+
31
+ ## Lancer en local
32
+
33
+ ```bash
34
+ python -m venv .venv
35
+ .venv\Scripts\activate # Windows (Linux/Mac : source .venv/bin/activate)
36
+ pip install -r requirements.txt
37
+ uvicorn app.main:app --port 8000
38
+ ```
39
+
40
+ Le premier démarrage télécharge `bge-m3` (~2 Go), puis encode tous les AVP : compter
41
+ quelques minutes sur CPU. Le GPU est utilisé automatiquement s'il est disponible.
42
+
43
+ - Interface web : http://localhost:8000/
44
+ - Documentation de l'API (Swagger) : http://localhost:8000/docs
45
+ - Serveur MCP (pour un agent conversationnel) : http://localhost:8000/gradio_api/mcp/sse
46
+
47
+ ```bash
48
+ curl -X POST "http://localhost:8000/match?top=3" \
49
+ -H "Content-Type: application/json" -d @exemples/cv_juriste_fictif.json
50
+ ```
51
+
52
+ ## Endpoints
53
+
54
+ | Méthode | Route | Rôle |
55
+ |---|---|---|
56
+ | GET | `/health` | Modèle, appareil (CPU/GPU), nombre d'AVP et d'AVP ouverts |
57
+ | GET | `/avps` | AVP chargés : ouvert ou clos, date limite, attendus, prérequis |
58
+ | POST | `/match?top=10&tri=qualite\|couverture&inclure_fermes=false` | CV → AVP classés + explications |
59
+ | POST | `/avps/{id_avp}/candidats?top=20` | Corps `{"cvs": [CV, ...]}` → vivier classé + explications |
60
+ | POST | `/avps/refresh` | Relit le dataset (nouveaux AVP, AVP modifiés ou retirés) |
61
+
62
+ ## Comment le score est calculé
63
+
64
+ 1. **Chaque AVP est découpé en trois groupes** :
65
+ - *attendus* (`responsibilities`, `skills`, `educationRequirements.competencyRequired`,
66
+ `experienceRequirements`) : **les seuls notés** ;
67
+ - *prérequis* (`qualifications`, `credentialCategory` : permis, habilitations, diplôme) :
68
+ jamais notés, renvoyés au recruteur « à vérifier » ;
69
+ - *contexte* (titre, famille de métier, description…) : sert au `score_global`.
70
+ 2. **Poids de chaque attendu** = poids du champ × **spécificité**. La spécificité est calculée
71
+ sur l'ensemble des AVP, comme l'IDF d'un moteur de recherche : « Maîtrise de soi », présent
72
+ dans presque tous les AVP, pèse presque 0 ; « Routage BGP et OSPF », présent dans un seul,
73
+ pèse 1. Aucune liste écrite à la main : la méthode s'applique à n'importe quelle administration.
74
+ 3. **Pour chaque attendu**, on calcule un *degré de couverture* entre 0 et 1, en gardant la
75
+ meilleure de deux notes :
76
+ - la **rampe bge-m3** : cosinus avec la phrase du CV la plus proche, 0 sous `SIM_BAS`,
77
+ 1 au-dessus de `SIM_HAUT`, linéaire entre les deux. bge-m3 donne ~0,45 pour deux phrases
78
+ sans rapport : la rampe étale la plage utile sur 0..1. Elle repère bien les reformulations ;
79
+ - le **reranker** `bge-reranker-v2-m3` : il relit l'attendu avec les 3 phrases du CV les plus
80
+ proches et répond « cette phrase prouve-t-elle l'attendu ? » (~0 sans rapport, ~1 prouvé).
81
+ Il écarte le bruit que la rampe laisse passer.
82
+ 4. **Score** = moyenne pondérée des degrés, affiché sur 100, avec un **libellé** pour les
83
+ recruteurs (Très bonne / Bonne / Partielle / Faible adéquation, seuils `SEUILS_LIBELLE`) et
84
+ le décompte **« x / N compétences du poste »**.
85
+ 5. **Savoir-être** (« Autonomie », « Être rigoureux »…) : ils comptent dans le score (les retirer
86
+ dégrade le classement), mais sont affichés à part, *à vérifier en entretien* : un CV les
87
+ écrit rarement.
88
+
89
+ Mesures sur 24 AVP et 23 CV fictifs (`scripts/evaluer_classement.py`) :
90
+
91
+ | Méthode | Bon AVP 1er (candidat) | Bon AVP dans le top 3 | Bon CV 1er (recruteur) | Faux positifs |
92
+ |---|---|---|---|---|
93
+ | bge-m3 seul, rampe 0,45/0,70 (avant) | 78,6 % | 85,7 % | 68,4 % | 0 |
94
+ | bge-m3 seul, rampe 0,55/0,75 | 92,9 % | 100 % | 73,7 % | 0 |
95
+ | bge-m3 seul, rampe 0,575/0,775 | 85,7 % | 100 % | 68,4 % | 0 |
96
+ | reranker seul | 78,6 % | 100 % | 78,9 % | 1 |
97
+ | bge-m3 0,55/0,75 + reranker | 85,7 % | 100 % | 73,7 % | 0 |
98
+ | **bge-m3 0,575/0,775 + reranker (retenu)** | 85,7 % | **100 %** | **84,2 %** | **0** |
99
+
100
+ Avec 14 CV étiquetés, un écart d'un CV (~7 points) n'est pas significatif. Mesures du
101
+ 2026-10-11 sur RTX 3050 (bge-m3 en float16) : graphiques et données dans `resultats/2026-10-11/`.
102
+
103
+ Côté recruteur, chaque candidat a aussi :
104
+ - une **spécificité** : son score sur cet AVP moins son score médian sur les autres AVP.
105
+ Proche de 0 : le CV obtient le même score partout (profil vague, ou fait de savoir-être) ;
106
+ - le **rang de cet AVP pour lui** : 1 = c'est l'AVP qui lui correspond le mieux ;
107
+ - un indicateur **ex aequo** quand l'écart avec le précédent est inférieur à 1 point.
108
+
109
+ Le `score_global` (CV entier contre AVP entier) suit la recette de champs de l'OPT-NC, encodée
110
+ avec bge-m3 et sans la troncature à 7 000 caractères du modèle Google (bge-m3 accepte
111
+ 8 192 tokens). C'est une information d'ensemble, non utilisée pour le tri.
112
+
113
+ ## Configuration (variables d'environnement)
114
+
115
+ | Variable | Défaut | Rôle |
116
+ |---|---|---|
117
+ | `DATASET_REPO` | `opt-nc/odata-avps` | Dataset Hugging Face |
118
+ | `DATASET_REVISION` | *(vide = dernière)* | Version du dataset (commit). Depuis le 2026-10-10, la dernière ne contient que les AVP ouverts ; la version complète (24 AVP) est `1bb92a09a4ff6aa6e9488ee954085019abba7747` |
119
+ | `MODEL_NAME` | `BAAI/bge-m3` | Modèle d'embeddings |
120
+ | `RERANKER_MODEL` | `BAAI/bge-reranker-v2-m3` | Reranker. Vide = bge-m3 seul (bien plus rapide sur CPU) |
121
+ | `RERANKER_TOP_K` | `3` | Phrases du CV relues par le reranker, par attendu |
122
+ | `SIM_BAS` / `SIM_HAUT` | `0.575` / `0.775` | Rampe du score (à calibrer) |
123
+ | `SEUIL_COUVERTURE` | `0.50` | Degré de couverture au-dessus duquel un attendu est « couvert » |
124
+ | `SEUILS_LIBELLE` | voir `app/config.py` | Seuils /100 des libellés Très bonne / Bonne / Partielle |
125
+ | `SIM_PREREQUIS` | `0.70` | Cosinus pour signaler un prérequis comme « mentionné » |
126
+ | `SEUIL_QUASI_IDENTIQUE` | `0.80` | Deux compétences au-dessus = la même (spécificité) |
127
+ | `INCLURE_AVP_FERMES` | `false` | Inclure les AVP dont la date limite est dépassée |
128
+
129
+ ## Tests et calibration
130
+
131
+ ```bash
132
+ python -m tests.test_scoring # moteur de score, sans modèle ni réseau
133
+ python -m tests.test_api # application complète, sans modèle ni réseau
134
+ python -m scripts.inspecter_dataset # AVP ouverts/clos, compétences les plus fréquentes
135
+ python -m scripts.evaluer_classement # mesure top-1 / MRR / faux positifs et calibre la rampe
136
+ python -m scripts.verifier_embeddings # bge-m3 range-t-il les AVP comme le modèle officiel ?
137
+ ```
138
+
139
+ `scripts/evaluer_classement.py` utilise les 23 CV fictifs de `exemples/cv_list.json` et les
140
+ réponses attendues de `exemples/attendus.json`.
141
+
142
+ ### Traces des mesures (vitesse, qualité, captures)
143
+
144
+ ```bash
145
+ pip install -r requirements-dev.txt && python -m playwright install chromium
146
+ python -m scripts.mesurer_performances --device gpu # qualité + durées -> resultats/<date>/
147
+ python -m scripts.mesurer_performances --device cpu # durées sans carte graphique (~20 min)
148
+ python -m scripts.captures resultats/<date> # service lancé : copies d'écran
149
+ python -m scripts.graphiques resultats/<date> # graphiques PNG
150
+ ```
151
+
152
+ Chaque dossier `resultats/<date>/` garde la fiche de la machine (GPU, pilote, versions,
153
+ `pip_freeze.txt`), les mesures brutes (JSON/CSV), les graphiques et les captures.
154
+
155
+ ## Déployer
156
+
157
+ Un seul code (`app/`), deux points d'entrée :
158
+
159
+ | Où | Lancement | Ce qui est servi |
160
+ |---|---|---|
161
+ | Local, Docker, serveur | `uvicorn app.main:app --port 7860` | API REST complète (`/match`, `/avps/...`), interface, MCP |
162
+ | Hugging Face Spaces + **ZeroGPU** | `app_zerogpu.py` (SDK Gradio) | interface, API Gradio et MCP (`matcher_cv`, `classer_candidats`) |
163
+
164
+ ### Hugging Face Spaces (ZeroGPU)
165
+
166
+ Le reranker a besoin d'une carte graphique : sur CPU, un `/match` prend ~4 minutes
167
+ (`resultats/2026-10-11/`). ZeroGPU prête un GPU pendant chaque appel (SDK Gradio uniquement).
168
+
169
+ 1. Créer un Space : SDK **Gradio**, matériel **ZeroGPU** (compte vérifié de plus de 30 jours,
170
+ ou PRO).
171
+ 2. Pousser ce dossier dans le dépôt du Space (l'en-tête de ce README configure le Space).
172
+ 3. *Settings → Variables* : `DATASET_REVISION=1bb92a09a4ff6aa6e9488ee954085019abba7747` (24 AVP)
173
+ et `INCLURE_AVP_FERMES=true`.
174
+ 4. Quota : chaque visiteur dispose d'un temps de GPU quotidien (2 min sans compte, 5 min avec
175
+ un compte gratuit, 40 min en PRO). Un `matcher_cv` en consomme quelques secondes, un
176
+ classement de 23 CV davantage.
177
+ 5. Les secrets (ex. `HF_TOKEN`) vont dans *Settings → Variables and secrets*, jamais dans le code.
178
+
179
+ ### Docker (serveur sans ZeroGPU)
180
+
181
+ Le `Dockerfile` reste valable (`uvicorn app.main:app`). Sans carte graphique, mettre
182
+ `RERANKER_MODEL=` (vide) : bge-m3 seul, réponses en quelques secondes, classement moins bon.
183
+
184
+ ## Licences de la pile
185
+
186
+ | Composant | Licence |
187
+ |---|---|
188
+ | `BAAI/bge-m3` | MIT |
189
+ | `BAAI/bge-reranker-v2-m3` | Apache-2.0 |
190
+ | FastAPI, Pydantic | MIT |
191
+ | Gradio, sentence-transformers | Apache-2.0 |
192
+ | PyTorch, NumPy, SciPy, pandas | BSD |
193
+ | Dataset `opt-nc/odata-avps` | à préciser par l'OPT-NC |
app/__init__.py ADDED
File without changes
app/avp_store.py ADDED
@@ -0,0 +1,305 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Charge les AVP depuis opt-nc/odata-avps et prépare tout ce qu'il faut pour le score.
2
+
3
+ Source de vérité : data/all_avps.jsonl (un objet JobPosting par ligne).
4
+ Tout est encodé localement avec bge-m3 (aucun vecteur officiel Google réutilisé).
5
+
6
+ Chaque AVP est découpé en trois groupes :
7
+ - contexte : ce qui décrit le poste (titre, famille, description...) -> vecteur global
8
+ - attendus : ce qu'il faut savoir faire (missions, compétences, connaissances,
9
+ expérience) -> seuls ces éléments comptent dans le score
10
+ - prerequis : conditions à vérifier (permis, habilitations, niveau de diplôme)
11
+ -> jamais notés, renvoyés au recruteur "à vérifier"
12
+
13
+ Parmi les attendus, les savoir-être ("Autonomie", "Être rigoureux"...) sont repérés pour
14
+ l'affichage seulement ("à vérifier en entretien") : ils restent dans le score, car les
15
+ retirer dégrade le classement (mesuré avec scripts/evaluer_classement.py).
16
+ """
17
+ from __future__ import annotations
18
+
19
+ import hashlib
20
+ import json
21
+ import math
22
+ import re
23
+ from dataclasses import dataclass
24
+ from datetime import date, datetime
25
+
26
+ import numpy as np
27
+ from huggingface_hub import hf_hub_download
28
+
29
+ from app import config
30
+
31
+
32
+ # ---------- Réglages (avec valeurs par défaut si config.py ne les définit pas) ----------
33
+
34
+ # Recette OPT-NC de l'issue : mêmes champs, même ordre, champs administratifs exclus.
35
+ CHAMPS_EMBEDDING_OPT = [
36
+ "title", "additionalType.corpsDomaine", "occupationalCategory",
37
+ "relevantOccupation.name", "description", "responsibilities", "skills",
38
+ "educationRequirements.competencyRequired", "experienceRequirements",
39
+ "qualifications",
40
+ ]
41
+
42
+ CHAMPS_ATTENDUS = [
43
+ "responsibilities", "skills",
44
+ "educationRequirements.competencyRequired", "experienceRequirements",
45
+ ]
46
+ CHAMPS_PREREQUIS = ["qualifications", "educationRequirements.credentialCategory"]
47
+
48
+ # Poids d'un élément selon le champ d'où il vient (à régler avec scripts/evaluer_classement.py)
49
+ POIDS_CHAMP = getattr(config, "POIDS_CHAMP", {
50
+ "skills": 1.0,
51
+ "educationRequirements.competencyRequired": 1.0,
52
+ "experienceRequirements": 1.0,
53
+ "responsibilities": 0.7,
54
+ })
55
+
56
+ # Deux compétences d'AVP différents au-dessus de ce cosinus sont "la même compétence"
57
+ SEUIL_QUASI_IDENTIQUE = getattr(config, "SEUIL_QUASI_IDENTIQUE", 0.80)
58
+
59
+ # Savoir-être, règle tirée des 24 AVP du dataset : une ligne de "skills" qui commence par
60
+ # "Être / Avoir / Faire preuve de", ou qui ne commence pas par un verbe et nomme une qualité.
61
+ # "Savoir rédiger" reste un savoir-faire.
62
+ _SE_VERBE = re.compile(r"^(être|etre|avoir|faire preuve)\b", re.I)
63
+ _VERBE = re.compile(r"^\w+(er|ir|re|oir)\b", re.I)
64
+ _SE_QUALITE = re.compile(
65
+ r"\b(aisance|rigueur|esprit|sens d|r[ée]activit|ma[îi]trise de soi|int[ée]grit|autonomie|"
66
+ r"capacit|facult|relationnel|discr[ée]tion|curiosit|aptitude|initiative|respect|"
67
+ r"travail en [ée]quipe|dynamisme|disponibilit|polyvalence|impartialit|diplomatie|[ée]thique|"
68
+ r"qualit[ée]s? relationnelle|conscience professionnelle|innovation|fiabilit|motivation|"
69
+ r"probit|persuasion|m[ée]thode|^organisation|valeurs|secret professionnel|confidentialit)",
70
+ re.I)
71
+
72
+
73
+ # ---------- Téléchargement ----------
74
+
75
+ def telecharger(nom: str) -> str:
76
+ return hf_hub_download(config.DATASET_REPO, nom, repo_type="dataset",
77
+ revision=config.DATASET_REVISION)
78
+
79
+
80
+ def lire_avps() -> list[dict]:
81
+ """Lit all_avps.jsonl et retourne la liste des AVP."""
82
+ chemin = telecharger(config.AVPS_FILE)
83
+ avps = []
84
+ with open(chemin, encoding="utf-8") as f:
85
+ for ligne in f:
86
+ if ligne.strip():
87
+ avps.append(json.loads(ligne))
88
+ return avps
89
+
90
+
91
+ # ---------- Lecture des champs ----------
92
+
93
+ def _liste(valeur) -> list[str]:
94
+ """Convertit n'importe quelle valeur en liste de strings propres."""
95
+ if valeur is None:
96
+ return []
97
+ if isinstance(valeur, str):
98
+ return [valeur.strip()] if valeur.strip() else []
99
+ if isinstance(valeur, list):
100
+ return [str(v).strip() for v in valeur if v is not None and str(v).strip()]
101
+ return []
102
+
103
+
104
+ def _lire(avp: dict, chemin: str) -> list[str]:
105
+ """Lit un champ imbriqué, ex. 'educationRequirements.competencyRequired'."""
106
+ valeur = avp
107
+ for cle in chemin.split("."):
108
+ valeur = valeur.get(cle) if isinstance(valeur, dict) else None
109
+ if chemin == "title" and not valeur:
110
+ valeur = avp.get("name")
111
+ return _liste(valeur)
112
+
113
+
114
+ def _cle_doublon(texte: str) -> str:
115
+ """'Expérience confirmée...' et 'Expérience confirmée....' sont le même élément."""
116
+ return " ".join(texte.lower().split()).rstrip(" .;")
117
+
118
+
119
+ def _decouper_prerequis(texte: str) -> list[str]:
120
+ """'Permis B, A2 + aptitude au deux roues' -> ['Permis B', 'A2', 'aptitude au deux roues'] :
121
+ chaque condition est vérifiée séparément. 'Bac+3' (sans espaces) n'est pas coupé."""
122
+ return [m.strip() for m in re.split(r"\s*[,;]\s*|\s+\+\s+", texte) if m.strip()]
123
+
124
+
125
+ def extraire(avp: dict, champs: list[str]) -> list[tuple[str, str]]:
126
+ """Retourne [(texte, champ_source), ...] sans doublons, dans l'ordre des champs."""
127
+ vues, sortie = set(), []
128
+ for champ in champs:
129
+ textes = _lire(avp, champ)
130
+ if champ in CHAMPS_PREREQUIS:
131
+ textes = [m for t in textes for m in _decouper_prerequis(t)]
132
+ for texte in textes:
133
+ cle = _cle_doublon(texte)
134
+ if cle and cle not in vues:
135
+ vues.add(cle)
136
+ sortie.append((texte, champ))
137
+ return sortie
138
+
139
+
140
+ def texte_embedding(avp: dict) -> str:
141
+ """Texte de l'AVP entier selon la recette OPT-NC. Pas de troncature à 7000 caractères :
142
+ c'était la limite du modèle Google, bge-m3 accepte 8192 tokens."""
143
+ morceaux = []
144
+ for champ in CHAMPS_EMBEDDING_OPT:
145
+ morceaux += _lire(avp, champ)
146
+ return "\n".join(morceaux)
147
+
148
+
149
+ def est_savoir_etre(texte: str, champ: str) -> bool:
150
+ """'Autonomie', 'Être rigoureux', 'Faire preuve de discrétion' -> True.
151
+ 'Construire un diagnostic', 'Savoir rédiger', 'Droit du travail' -> False."""
152
+ if champ != "skills":
153
+ return False
154
+ if _SE_VERBE.match(texte):
155
+ return True
156
+ return not _VERBE.match(texte) and bool(_SE_QUALITE.search(texte))
157
+
158
+
159
+ def competences_avp(avp: dict) -> list[str]:
160
+ """Conservée pour compatibilité : textes des seuls attendus."""
161
+ return [t for t, _ in extraire(avp, CHAMPS_ATTENDUS)]
162
+
163
+
164
+ # ---------- Métadonnées ----------
165
+
166
+ def hash_avp(avp: dict) -> str:
167
+ """Empreinte de l'AVP : le md5_hash fourni, ou calculé."""
168
+ return avp.get("md5_hash") or hashlib.md5(
169
+ json.dumps(avp, sort_keys=True, ensure_ascii=False).encode()
170
+ ).hexdigest()
171
+
172
+
173
+ def identifiant(avp: dict) -> str:
174
+ return avp.get("id_avp") or avp.get("identifier") or avp.get("name", "inconnu")
175
+
176
+
177
+ def est_ouvert(avp: dict, aujourd_hui: date | None = None) -> bool:
178
+ """Un AVP est ouvert si sa date limite (validThrough) n'est pas dépassée.
179
+ Sans date, on le considère ouvert (on ne peut pas savoir)."""
180
+ fin = avp.get("validThrough")
181
+ if not fin:
182
+ return True
183
+ try:
184
+ fin_date = datetime.fromisoformat(str(fin)).date()
185
+ except ValueError:
186
+ return True
187
+ return fin_date >= (aujourd_hui or date.today())
188
+
189
+
190
+ # ---------- Poids de spécificité (type IDF, calculé sur le corpus) ----------
191
+
192
+ def poids_specificite(vecs_par_avp: dict[str, np.ndarray]) -> dict[str, np.ndarray]:
193
+ """Plus une compétence revient (quasi à l'identique) dans beaucoup d'AVP,
194
+ moins elle aide à distinguer les candidats : son poids baisse.
195
+
196
+ Retourne, pour chaque AVP, un poids entre 0 et 1 par attendu.
197
+ 'Maîtrise de soi' présent dans 20 AVP sur 24 -> poids proche de 0.
198
+ 'Routage BGP et OSPF' présent dans 1 seul AVP -> poids 1.
199
+ """
200
+ ids = list(vecs_par_avp)
201
+ n = len(ids)
202
+ if n <= 1:
203
+ return {a: np.ones(len(vecs_par_avp[a])) for a in ids}
204
+ poids = {}
205
+ for a in ids:
206
+ va = vecs_par_avp[a]
207
+ if len(va) == 0:
208
+ poids[a] = np.zeros(0)
209
+ continue
210
+ freq = np.ones(len(va)) # l'AVP lui-même
211
+ for b in ids:
212
+ vb = vecs_par_avp[b]
213
+ if b == a or len(vb) == 0:
214
+ continue
215
+ freq += (va @ vb.T).max(axis=1) >= SEUIL_QUASI_IDENTIQUE
216
+ poids[a] = np.log((n + 1) / freq) / math.log(n + 1) # entre ~0 et 1
217
+ return poids
218
+
219
+
220
+ # ---------- Le magasin d'AVP ----------
221
+
222
+ @dataclass
223
+ class AVPPrepare:
224
+ """Tout ce dont le score a besoin pour un AVP, prêt à l'emploi."""
225
+ id_avp: str
226
+ avp: dict
227
+ attendus: list[tuple[str, str]] # (texte, champ)
228
+ vecs_attendus: np.ndarray # (n_attendus, dim)
229
+ poids: np.ndarray # (n_attendus,) poids final = champ x spécificité
230
+ savoir_etre: np.ndarray # (n_attendus,) bool, pour l'affichage seulement
231
+ prerequis: list[tuple[str, str]]
232
+ vecs_prerequis: np.ndarray
233
+ vec_global: np.ndarray # (dim,) recette OPT-NC
234
+
235
+ @property
236
+ def titre(self) -> str | None:
237
+ return self.avp.get("title") or self.avp.get("name")
238
+
239
+ @property
240
+ def ouvert(self) -> bool:
241
+ return est_ouvert(self.avp)
242
+
243
+
244
+ class AVPStore:
245
+ def __init__(self, encodeur):
246
+ self.encodeur = encodeur
247
+ self.avps: dict[str, dict] = {}
248
+ self.prepares: dict[str, AVPPrepare] = {}
249
+ # md5 -> (attendus, vecs_attendus, prerequis, vecs_prerequis, vec_global)
250
+ self._cache: dict[str, tuple] = {}
251
+
252
+ def _encoder(self, textes: list[str]) -> np.ndarray:
253
+ if not textes:
254
+ return np.zeros((0, self.encodeur.dimension), dtype=np.float32)
255
+ return self.encodeur.encoder(textes)
256
+
257
+ def _encodages(self, avp: dict) -> tuple:
258
+ """Encodages d'un AVP, réutilisés tant que son md5_hash ne change pas."""
259
+ cle = hash_avp(avp)
260
+ if cle not in self._cache:
261
+ attendus = extraire(avp, CHAMPS_ATTENDUS)
262
+ prerequis = extraire(avp, CHAMPS_PREREQUIS)
263
+ self._cache[cle] = (
264
+ attendus,
265
+ self._encoder([t for t, _ in attendus]),
266
+ prerequis,
267
+ self._encoder([t for t, _ in prerequis]),
268
+ self._encoder([texte_embedding(avp)])[0],
269
+ )
270
+ return self._cache[cle]
271
+
272
+ def charger(self) -> None:
273
+ self.installer(lire_avps())
274
+
275
+ def installer(self, avps_bruts: list[dict]) -> None:
276
+ """Prépare tout dans des variables locales, puis bascule en une seule affectation :
277
+ un /match qui tombe pendant un /avps/refresh voit l'ancien état complet, jamais un
278
+ état à moitié rempli."""
279
+ avps = {identifiant(a): a for a in avps_bruts}
280
+ encodages = {i: self._encodages(a) for i, a in avps.items()}
281
+
282
+ # Les poids de spécificité dépendent de TOUT le corpus : recalculés à chaque chargement
283
+ spec = poids_specificite({i: e[1] for i, e in encodages.items()})
284
+
285
+ prepares = {}
286
+ for i, avp in avps.items():
287
+ attendus, vecs_att, prerequis, vecs_pre, vec_global = encodages[i]
288
+ poids_champ = np.array([POIDS_CHAMP.get(c, 0.5) for _, c in attendus])
289
+ prepares[i] = AVPPrepare(
290
+ id_avp=i, avp=avp,
291
+ attendus=attendus, vecs_attendus=vecs_att,
292
+ poids=poids_champ * spec[i],
293
+ savoir_etre=np.array([est_savoir_etre(t, c) for t, c in attendus], dtype=bool),
294
+ prerequis=prerequis, vecs_prerequis=vecs_pre,
295
+ vec_global=vec_global,
296
+ )
297
+
298
+ cles = {hash_avp(a) for a in avps.values()}
299
+ self._cache = {k: v for k, v in self._cache.items() if k in cles}
300
+ self.avps, self.prepares = avps, prepares # bascule
301
+
302
+ # Compatibilité avec l'ancien code
303
+ def competences(self, avp: dict) -> tuple[list[str], np.ndarray]:
304
+ attendus, vecs, *_ = self._encodages(avp)
305
+ return [t for t, _ in attendus], vecs
app/classement.py ADDED
@@ -0,0 +1,105 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Côté recruteur : pour UN AVP, classe un vivier de CV du plus au moins adapté.
2
+
3
+ C'est la fonction ② de l'article dans le sens "AVP fraîchement publié -> vivier de profils".
4
+ Le score est explicable : pour chaque candidat, ses forces, ses écarts, les prérequis
5
+ à vérifier, et où se situe cet AVP parmi tous ceux qui pourraient lui correspondre.
6
+ """
7
+ from __future__ import annotations
8
+
9
+ import numpy as np
10
+
11
+ from app import config
12
+ from app.cv_texte import phrases_du_cv
13
+ from app.schemas import SavoirEtre
14
+ from app.schemas_classement import (Candidat, CandidatEcarte, LigneExplication,
15
+ Prerequis, ReponseClassement)
16
+ from app.scoring import (adequations_tous_avps, forces_et_ecarts, libelle,
17
+ probas_reranker_avps, savoir_etre, scorer, verifier_prerequis)
18
+
19
+ MARGE_EX_AEQUO = getattr(config, "MARGE_EX_AEQUO", 0.01) # sur l'échelle 0..1
20
+
21
+
22
+ def _ligne(d) -> LigneExplication:
23
+ return LigneExplication(attendu=d.attendu, champ_avp=d.champ, poids=round(d.poids, 3),
24
+ similarite=round(d.similarite, 3), degre=round(d.degre, 3),
25
+ phrase_cv=d.phrase_cv, source_cv=d.source_cv)
26
+
27
+
28
+ def classer_candidats(id_avp: str, cvs: list[dict], store, encodeur,
29
+ seuil: float, top: int = 20) -> ReponseClassement:
30
+ if id_avp not in store.prepares:
31
+ raise KeyError(id_avp)
32
+ p = store.prepares[id_avp]
33
+
34
+ # 1. Extraction des phrases de chaque CV (identité jamais lue par phrases_du_cv)
35
+ ecartes, valides = [], [] # valides : (index, ref, phrases)
36
+ for i, cv in enumerate(cvs):
37
+ ref = str(cv["ref"]) if cv.get("ref") is not None else None
38
+ phrases = phrases_du_cv(cv)
39
+ if not phrases:
40
+ ecartes.append(CandidatEcarte(index=i, ref=ref,
41
+ raison="Aucun texte exploitable dans le CV."))
42
+ else:
43
+ valides.append((i, ref, phrases))
44
+
45
+ # 2. Un seul appel d'encodage pour tout le vivier (beaucoup plus rapide sur CPU)
46
+ tous_textes = [t for _, _, ph in valides for t, _ in ph]
47
+ tous_vecs = encodeur.encoder(tous_textes) if tous_textes else None
48
+
49
+ # Pour situer le candidat, on le compare aux AVP auxquels il pourrait candidater (ouverts),
50
+ # sauf si on inclut les clos ou s'il n'y a presque aucun AVP ouvert.
51
+ comparables = {k: v for k, v in store.prepares.items() if v.ouvert or k == id_avp}
52
+ if config.INCLURE_AVP_FERMES or len(comparables) < 3:
53
+ comparables = store.prepares
54
+
55
+ lignes, debut = [], 0
56
+ for i, ref, phrases in valides:
57
+ vecs_cv = tous_vecs[debut:debut + len(phrases)]
58
+ debut += len(phrases)
59
+
60
+ # Notes du reranker pour tous les AVP comparables (dont celui-ci), en un seul appel
61
+ rr = probas_reranker_avps(comparables, [t for t, _ in phrases], vecs_cv)
62
+ s = scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs_cv, seuil,
63
+ savoir_etre=p.savoir_etre, rr=rr.get(id_avp))
64
+
65
+ # Où se situe cet AVP pour ce candidat, parmi tous les AVP connus ?
66
+ # Même calcul que le score (reranker compris), pour comparer ce qui est comparable.
67
+ autres = adequations_tous_avps(comparables, vecs_cv, rr)
68
+ rang_avp = 1 + sum(1 for k, v in autres.items() if k != id_avp and v > s.adequation)
69
+ valeurs_autres = [v for k, v in autres.items() if k != id_avp]
70
+ mediane = float(np.median(valeurs_autres)) if valeurs_autres else 0.0
71
+
72
+ forces, ecarts = forces_et_ecarts(s.details)
73
+ prerequis = verifier_prerequis(p.prerequis, p.vecs_prerequis, phrases, vecs_cv)
74
+
75
+ lignes.append((s.adequation, s.couverture, dict(
76
+ index=i, ref=ref,
77
+ score=round(100 * s.adequation, 1),
78
+ libelle=libelle(s.adequation),
79
+ couverture=round(100 * s.couverture, 1),
80
+ nb_savoir_faire=s.nb_savoir_faire,
81
+ nb_savoir_faire_couverts=s.nb_savoir_faire_couverts,
82
+ rang_de_cet_avp_pour_le_candidat=rang_avp,
83
+ specificite=round(100 * (s.adequation - mediane), 1),
84
+ fiable=s.fiable, avertissement=s.avertissement,
85
+ forces=[_ligne(d) for d in forces],
86
+ ecarts=[_ligne(d) for d in ecarts],
87
+ savoir_etre=[SavoirEtre(**x) for x in savoir_etre(s.details)],
88
+ prerequis=[Prerequis(**x) for x in prerequis],
89
+ )))
90
+
91
+ # 3. Tri sur les valeurs exactes ; égalités signalées plutôt que tranchées au hasard
92
+ lignes.sort(key=lambda t: (t[0], t[1]), reverse=True)
93
+ candidats, precedent = [], None
94
+ for rang, (adeq, _, champs) in enumerate(lignes[:top], start=1):
95
+ ex_aequo = precedent is not None and (precedent - adeq) < MARGE_EX_AEQUO
96
+ candidats.append(Candidat(rang=rang, ex_aequo_avec_precedent=ex_aequo, **champs))
97
+ precedent = adeq
98
+
99
+ ordre_poids = np.argsort(-p.poids)[:5]
100
+ return ReponseClassement(
101
+ id_avp=id_avp, titre=p.titre, avp_ouvert=p.ouvert,
102
+ modele=encodeur.nom, seuil=seuil, nb_attendus=len(p.attendus),
103
+ attendus_les_plus_discriminants=[p.attendus[k][0] for k in ordre_poids],
104
+ candidats=candidats, ecartes=ecartes,
105
+ )
app/config.py ADDED
@@ -0,0 +1,70 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Réglages du service, modifiables par variables d'environnement.
2
+
3
+ Sur Hugging Face Spaces : Settings > Variables and secrets.
4
+ En local (PowerShell) : $env:INCLURE_AVP_FERMES="true"
5
+ """
6
+ import json
7
+ import os
8
+
9
+
10
+ def _bool(nom: str, defaut: bool) -> bool:
11
+ return os.getenv(nom, str(defaut)).strip().lower() in ("1", "true", "oui", "yes")
12
+
13
+
14
+ # ---------- Données et modèle ----------
15
+ DATASET_REPO = os.getenv("DATASET_REPO", "opt-nc/odata-avps")
16
+ AVPS_FILE = os.getenv("AVPS_FILE", "data/all_avps.jsonl")
17
+ # Version du dataset (commit HF). Vide = dernière version publiée.
18
+ # Le 2026-10-10, OPT-NC n'a plus publié que les AVP ouverts ; la version complète (24 AVP) :
19
+ # $env:DATASET_REVISION="1bb92a09a4ff6aa6e9488ee954085019abba7747"
20
+ DATASET_REVISION = os.getenv("DATASET_REVISION") or None
21
+ MODEL_NAME = os.getenv("MODEL_NAME", "BAAI/bge-m3")
22
+
23
+ # Reranker : relit chaque attendu avec les RERANKER_TOP_K phrases du CV les plus proches
24
+ # (selon bge-m3) et tranche : ~0 sans rapport, ~1 attendu prouvé. Vide = bge-m3 seul
25
+ # (beaucoup plus rapide sur CPU, mais classement moins bon : voir scripts/evaluer_classement).
26
+ RERANKER_MODEL = os.getenv("RERANKER_MODEL", "BAAI/bge-reranker-v2-m3")
27
+ RERANKER_TOP_K = int(os.getenv("RERANKER_TOP_K", "3"))
28
+
29
+ # ---------- Score (voir app/scoring.py) ----------
30
+ # Rampe : similarité <= SIM_BAS -> 0 ; >= SIM_HAUT -> 1 ; linéaire entre les deux.
31
+ # À calibrer avec : python -m scripts.evaluer_classement
32
+ # 0.575 / 0.775 : meilleur couple avec le reranker (24 AVP, 23 CV, 2026-10-11)
33
+ SIM_BAS = float(os.getenv("SIM_BAS", "0.575"))
34
+ SIM_HAUT = float(os.getenv("SIM_HAUT", "0.775"))
35
+
36
+ # Seuil d'affichage, sur le degré de couverture 0..1 (rampe ou reranker) : au-dessus,
37
+ # l'attendu est listé "couvert", sinon "écart". N'influence PAS le score principal
38
+ # (score_qualite), seulement score_couverture et le décompte "x / N compétences".
39
+ SEUIL_COUVERTURE = float(os.getenv("SEUIL_COUVERTURE", "0.50"))
40
+
41
+ # Prérequis (permis, diplôme) : "mention probable" si une phrase du CV dépasse ce cosinus.
42
+ SIM_PREREQUIS = float(os.getenv("SIM_PREREQUIS", "0.70"))
43
+
44
+ # Libellé affiché aux recruteurs selon le score /100 : [très bonne, bonne, partielle].
45
+ # En dessous du dernier seuil : faible. À régler avec scripts/evaluer_classement.
46
+ # Réglage du 2026-10-11 (24 AVP, 23 CV, rampe 0.575/0.775) : tous les hors-domaine sont
47
+ # sous 13, les bons CV sur leur AVP vont de 11 à 45 (18 sur 19 au-dessus de 15).
48
+ # À refaire si la rampe ou le reranker change.
49
+ SEUILS_LIBELLE = json.loads(os.getenv("SEUILS_LIBELLE", "[33, 25, 15]"))
50
+
51
+ # Deux compétences d'AVP différents au-dessus de ce cosinus sont "la même compétence"
52
+ # (sert au poids de spécificité : une compétence présente partout pèse presque 0).
53
+ SEUIL_QUASI_IDENTIQUE = float(os.getenv("SEUIL_QUASI_IDENTIQUE", "0.80"))
54
+
55
+ # Poids selon le champ de l'AVP d'où vient l'attendu
56
+ POIDS_CHAMP = json.loads(os.getenv("POIDS_CHAMP", json.dumps({
57
+ "skills": 1.0,
58
+ "educationRequirements.competencyRequired": 1.0,
59
+ "experienceRequirements": 1.0,
60
+ "responsibilities": 0.7,
61
+ })))
62
+
63
+ # ---------- Fiabilité et affichage ----------
64
+ MIN_PHRASES_CV = int(os.getenv("MIN_PHRASES_CV", "5"))
65
+ MIN_ATTENDUS_AVP = int(os.getenv("MIN_ATTENDUS_AVP", "3"))
66
+ MARGE_EX_AEQUO = float(os.getenv("MARGE_EX_AEQUO", "0.01")) # sur l'échelle 0..1
67
+
68
+ # L'article exige des AVP "réellement ouverts" (validThrough non dépassée).
69
+ # Mettre à true pour une démo si tous les AVP du dataset sont expirés.
70
+ INCLURE_AVP_FERMES = _bool("INCLURE_AVP_FERMES", False)
app/cv_texte.py ADDED
@@ -0,0 +1,54 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Transforme un CV JSON Resume en liste de phrases, chacune avec sa provenance.
2
+
3
+ La provenance (ex. "work[0].highlights[1]") permet d'expliquer un match :
4
+ on sait exactement QUELLE ligne du CV couvre QUELLE compétence de l'AVP.
5
+ """
6
+
7
+
8
+ def phrases_du_cv(cv: dict) -> list[tuple[str, str]]:
9
+ phrases: list[tuple[str, str]] = []
10
+
11
+ def ajouter(texte, source: str) -> None:
12
+ if isinstance(texte, str) and texte.strip():
13
+ phrases.append((texte.strip(), source))
14
+
15
+ def joindre(*morceaux, sep=" ") -> str:
16
+ return sep.join(m.strip() for m in morceaux if isinstance(m, str) and m.strip())
17
+
18
+ basics = cv.get("basics") or {}
19
+ ajouter(basics.get("label"), "basics.label")
20
+ ajouter(basics.get("summary"), "basics.summary")
21
+
22
+ for i, exp in enumerate(cv.get("work") or []):
23
+ ajouter(joindre(exp.get("position"), exp.get("name"), sep=" chez "), f"work[{i}]")
24
+ ajouter(exp.get("summary"), f"work[{i}].summary")
25
+ for j, h in enumerate(exp.get("highlights") or []):
26
+ ajouter(h, f"work[{i}].highlights[{j}]")
27
+
28
+ for i, exp in enumerate(cv.get("volunteer") or []):
29
+ ajouter(joindre(exp.get("position"), exp.get("organization"), sep=" chez "), f"volunteer[{i}]")
30
+ ajouter(exp.get("summary"), f"volunteer[{i}].summary")
31
+ for j, h in enumerate(exp.get("highlights") or []):
32
+ ajouter(h, f"volunteer[{i}].highlights[{j}]")
33
+
34
+ for i, etude in enumerate(cv.get("education") or []):
35
+ ajouter(joindre(etude.get("studyType"), etude.get("area"), etude.get("institution")), f"education[{i}]")
36
+ for j, cours in enumerate(etude.get("courses") or []):
37
+ ajouter(cours, f"education[{i}].courses[{j}]")
38
+
39
+ for i, skill in enumerate(cv.get("skills") or []):
40
+ mots_cles = ", ".join(k for k in (skill.get("keywords") or []) if isinstance(k, str))
41
+ ajouter(joindre(skill.get("name"), mots_cles, sep=" : "), f"skills[{i}]")
42
+
43
+ for i, projet in enumerate(cv.get("projects") or []):
44
+ ajouter(joindre(projet.get("name"), projet.get("description"), sep=" : "), f"projects[{i}]")
45
+ for j, h in enumerate(projet.get("highlights") or []):
46
+ ajouter(h, f"projects[{i}].highlights[{j}]")
47
+
48
+ for i, certif in enumerate(cv.get("certificates") or []):
49
+ ajouter(certif.get("name"), f"certificates[{i}]")
50
+
51
+ for i, langue in enumerate(cv.get("languages") or []):
52
+ ajouter(joindre(langue.get("language"), langue.get("fluency"), sep=" : "), f"languages[{i}]")
53
+
54
+ return phrases
app/encodeur.py ADDED
@@ -0,0 +1,26 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Transforme des textes en vecteurs avec bge-m3."""
2
+ from __future__ import annotations
3
+
4
+ import numpy as np
5
+ import torch
6
+ from sentence_transformers import SentenceTransformer
7
+
8
+
9
+ class Encodeur:
10
+ def __init__(self, nom_modele: str, device: str | None = None):
11
+ self.nom = nom_modele
12
+ # GPU si disponible (ta RTX 3050 en local, ZeroGPU sur Hugging Face), sinon CPU
13
+ self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
14
+ # float16 sur GPU : deux fois moins de mémoire, pour que bge-m3 et le reranker
15
+ # tiennent ensemble dans les 4 Go de la RTX 3050 (sinon Windows déborde en RAM, très lent)
16
+ options = {"torch_dtype": torch.float16} if self.device == "cuda" else {}
17
+ self.modele = SentenceTransformer(nom_modele, device=self.device, model_kwargs=options)
18
+ # On mesure la dimension directement plutôt que de la supposer
19
+ self.dimension = len(self.encoder(["test"])[0])
20
+
21
+ def encoder(self, textes: list[str]) -> np.ndarray:
22
+ # normalize_embeddings=True : chaque vecteur a une longueur de 1,
23
+ # donc le produit scalaire de deux vecteurs = leur similarité cosinus.
24
+ vecs = self.modele.encode(textes, normalize_embeddings=True, convert_to_numpy=True,
25
+ batch_size=16, show_progress_bar=False)
26
+ return vecs.astype(np.float32) # calculs de similarité en pleine précision
app/interface.py ADDED
@@ -0,0 +1,251 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Interface web Gradio, montée sur l'API FastAPI (une seule application, un seul port).
2
+
3
+ Deux onglets, les deux sens du matching :
4
+ - Candidat : un CV -> les AVP qui lui correspondent le mieux
5
+ - Recruteur : un AVP -> le vivier de CV classé du plus au moins adapté
6
+
7
+ Les deux fonctions principales sont aussi exposées en MCP (outils pour un agent
8
+ conversationnel) quand l'application est montée avec mcp_server=True.
9
+ Aucun CV n'est enregistré : pas de "flagging", pas de journalisation du contenu.
10
+ """
11
+ from __future__ import annotations
12
+
13
+ import json
14
+ from pathlib import Path
15
+
16
+ import gradio as gr
17
+
18
+ from app import config
19
+ from app.classement import classer_candidats
20
+ from app.matching import matcher
21
+
22
+ DOSSIER_EXEMPLES = Path(__file__).resolve().parent.parent / "exemples"
23
+
24
+
25
+ # ---------- CV d'exemple (tous fictifs, règle du HackAVP) ----------
26
+
27
+ def _exemples() -> dict[str, dict]:
28
+ """{libellé: cv}. Le champ _profil (réponse attendue) est retiré du CV."""
29
+ chemin = DOSSIER_EXEMPLES / "cv_list.json"
30
+ if not chemin.exists():
31
+ return {}
32
+ sortie = {}
33
+ for i, cv in enumerate(json.loads(chemin.read_text(encoding="utf-8"))):
34
+ cv = dict(cv)
35
+ cv.pop("_profil", None)
36
+ label = (cv.get("basics") or {}).get("label") or f"CV {i}"
37
+ sortie[f"{i:02d} · {label}"] = cv
38
+ return sortie
39
+
40
+
41
+ EXEMPLES = _exemples()
42
+
43
+
44
+ def _vivier_exemple() -> str:
45
+ cvs = [dict(cv, ref=nom) for nom, cv in EXEMPLES.items()]
46
+ return json.dumps(cvs, ensure_ascii=False, indent=1)
47
+
48
+
49
+ def _md(texte: str | None, n: int = 140) -> str:
50
+ """Texte sûr dans un tableau Markdown : pas de |, pas de retour à la ligne, tronqué."""
51
+ t = " ".join(str(texte or "").split()).replace("|", "/")
52
+ return t if len(t) <= n else t[: n - 1] + "…"
53
+
54
+
55
+ _obtenir_etat = None # fixé par construire() : () -> (store, encodeur)
56
+
57
+
58
+ # ---------- Côté candidat ----------
59
+
60
+
61
+ def matcher_cv(cv_json: str, inclure_clos: bool = False) -> str:
62
+ """Trouve les AVP de l'OPT-NC qui correspondent le mieux à un CV, avec explications.
63
+
64
+ Args:
65
+ cv_json: le CV au format JSON Resume (texte JSON).
66
+ inclure_clos: inclure les AVP dont la date limite de candidature est dépassée.
67
+
68
+ Returns:
69
+ Un rapport Markdown : pour chaque AVP, le score sur 100, les points forts
70
+ (attendu de l'AVP et ligne du CV qui y répond) et les écarts principaux.
71
+ """
72
+ store, encodeur = _obtenir_etat()
73
+ try:
74
+ cv = json.loads(cv_json)
75
+ except json.JSONDecodeError as e:
76
+ return f"**CV illisible** : le texte n'est pas du JSON valide ({e.msg}, ligne {e.lineno})."
77
+ if not isinstance(cv, dict):
78
+ return "**CV illisible** : un CV JSON Resume est un objet `{...}`."
79
+ try:
80
+ rep = matcher(cv, store, encodeur, config.SEUIL_COUVERTURE, top=5,
81
+ inclure_fermes=inclure_clos)
82
+ except ValueError as e:
83
+ return f"**{e}**"
84
+
85
+ if not rep.resultats:
86
+ return ("**Aucun AVP ouvert en ce moment.** Toutes les dates limites du dataset "
87
+ "sont dépassées : cochez « Inclure les AVP clos » pour voir le matching "
88
+ "sur les offres récentes.")
89
+
90
+ lignes = [f"*{rep.nb_avps_analyses} AVP analysés · modèle `{rep.modele}`*\n"]
91
+ for k, r in enumerate(rep.resultats, start=1):
92
+ statut = "ouvert" if r.ouvert else "**clos**"
93
+ date = f" jusqu'au {r.date_limite}" if r.date_limite else ""
94
+ lien = f" · [fiche métier {r.code_metier}]({r.fiche_metier_url})" if r.fiche_metier_url else ""
95
+ lignes.append(f"### {k}. {r.titre} — {r.libelle} ({round(100 * r.score_qualite)}/100)")
96
+ lignes.append(f"`{r.id_avp}` · {statut}{date} · **{r.nb_savoir_faire_couverts} / "
97
+ f"{r.nb_savoir_faire} compétences du poste**{lien}")
98
+ if r.avertissement:
99
+ lignes.append(f"\n> ⚠ {r.avertissement}")
100
+ if r.competences_couvertes:
101
+ lignes.append("\n| Point fort (attendu de l'AVP) | Ce qui y répond dans le CV |\n|---|---|")
102
+ lignes += [f"| {_md(c.attendu)} | {_md(c.trouve_dans_cv)} *({c.source_cv})* |"
103
+ for c in r.competences_couvertes[:3]]
104
+ if r.ecarts:
105
+ lignes.append("\n**Écarts principaux** (attendus que le CV ne couvre pas) :")
106
+ lignes += [f"- {_md(e.attendu, 200)}" for e in r.ecarts[:3]]
107
+ if r.savoir_etre:
108
+ lignes.append("\n**Savoir-être attendus** (à montrer en entretien) : " + " ; ".join(
109
+ _md(s.attendu, 60) + (" ✓" if s.statut == "mention_probable" else "")
110
+ for s in r.savoir_etre))
111
+ lignes.append("")
112
+ lignes.append("*✓ = le CV semble déjà l'évoquer. Les savoir-être comptent dans le score.*")
113
+ return "\n".join(lignes)
114
+
115
+ # ---------- Côté recruteur ----------
116
+
117
+ def classer_vivier(id_avp: str, cvs_json: str) -> str:
118
+ """Classe un vivier de CV pour un AVP de l'OPT-NC, du plus au moins adapté.
119
+
120
+ Args:
121
+ id_avp: identifiant de l'AVP, par exemple "3134-26-1264/SR".
122
+ cvs_json: liste de CV au format JSON Resume (texte JSON). Un champ "ref"
123
+ optionnel par CV permet de retrouver le candidat.
124
+
125
+ Returns:
126
+ Un rapport Markdown : classement avec score sur 100, puis forces, écarts et
127
+ prérequis à vérifier pour les premiers candidats.
128
+ """
129
+ store, encodeur = _obtenir_etat()
130
+ try:
131
+ cvs = json.loads(cvs_json)
132
+ except json.JSONDecodeError as e:
133
+ return f"**Vivier illisible** : JSON invalide ({e.msg}, ligne {e.lineno})."
134
+ if not isinstance(cvs, list) or not cvs:
135
+ return "**Vivier illisible** : il faut une liste `[ {...}, {...} ]` d'au moins un CV."
136
+ try:
137
+ r = classer_candidats(id_avp, cvs, store, encodeur,
138
+ seuil=config.SEUIL_COUVERTURE, top=len(cvs))
139
+ except KeyError:
140
+ return f"**AVP inconnu** : `{id_avp}`."
141
+
142
+ lignes = [f"## {r.titre}",
143
+ f"`{r.id_avp}` · {'ouvert' if r.avp_ouvert else '**clos**'} · "
144
+ f"{r.nb_attendus} attendus notés",
145
+ "\n**Attendus les plus discriminants** (rares parmi les AVP, donc décisifs) : "
146
+ + " ; ".join(_md(a, 80) for a in r.attendus_les_plus_discriminants),
147
+ "\n| Rang | Candidat | Adéquation | Score /100 | Compétences | Spécificité | "
148
+ "Cet AVP est son n° | Remarque |",
149
+ "|---|---|---|---|---|---|---|---|"]
150
+ for c in r.candidats:
151
+ remarques = []
152
+ if c.ex_aequo_avec_precedent:
153
+ remarques.append("ex aequo")
154
+ if not c.fiable:
155
+ remarques.append("peu fiable")
156
+ if c.specificite < 0:
157
+ remarques.append("correspond mieux à d'autres AVP")
158
+ elif c.specificite < 5:
159
+ remarques.append("profil peu ciblé")
160
+ lignes.append(f"| {c.rang} | {_md(c.ref or f'CV {c.index}', 50)} | {c.libelle} | "
161
+ f"**{c.score:.0f}** | {c.nb_savoir_faire_couverts} / {c.nb_savoir_faire} | "
162
+ f"{c.specificite:+.0f} | "
163
+ f"{c.rang_de_cet_avp_pour_le_candidat} | {', '.join(remarques)} |")
164
+ if r.ecartes:
165
+ lignes.append("\n**Écartés** : " + " ; ".join(
166
+ f"{_md(e.ref or f'CV {e.index}', 50)} ({e.raison})" for e in r.ecartes))
167
+
168
+ for c in r.candidats[:3]:
169
+ lignes.append(f"\n### {c.rang}. {_md(c.ref or f'CV {c.index}', 80)} — {c.libelle} "
170
+ f"({c.score:.0f}/100, {c.nb_savoir_faire_couverts} / {c.nb_savoir_faire} "
171
+ "compétences)")
172
+ if c.avertissement:
173
+ lignes.append(f"> ⚠ {c.avertissement}")
174
+ # "\n" avant chaque titre : sinon Markdown le rattache au dernier point de la liste
175
+ if c.forces:
176
+ lignes.append("\n**Forces**")
177
+ lignes += [f"- {_md(f.attendu)} ← « {_md(f.phrase_cv)} » *({f.source_cv})*"
178
+ for f in c.forces]
179
+ if c.ecarts:
180
+ lignes.append("\n**Écarts**")
181
+ lignes += [f"- {_md(e.attendu)}" for e in c.ecarts]
182
+ if c.savoir_etre:
183
+ lignes.append("\n**Savoir-être à vérifier en entretien** : " + " ; ".join(
184
+ _md(s.attendu, 60) + (" (évoqué dans le CV)" if s.statut == "mention_probable" else "")
185
+ for s in c.savoir_etre))
186
+ if c.prerequis:
187
+ lignes.append("\n**Prérequis à vérifier par le recruteur** (non notés) : " + " ; ".join(
188
+ f"{_md(p.prerequis, 60)} ({'mentionné' if p.statut == 'mention_probable' else 'à vérifier'})"
189
+ for p in c.prerequis))
190
+ lignes.append("\n*Spécificité = score sur cet AVP moins le score habituel du candidat sur "
191
+ "les autres AVP. Proche de 0 : le CV obtient le même score partout.*")
192
+ return "\n".join(lignes)
193
+
194
+ # ---------- Fonctions d'interface (non exposées en API / MCP) ----------
195
+
196
+ def choix_avps():
197
+ store, _ = _obtenir_etat()
198
+ choix = sorted(
199
+ ((f"{p.titre} — {i}" + ("" if p.ouvert else " (clos)"), i)
200
+ for i, p in store.prepares.items()),
201
+ key=lambda c: (c[0].endswith("(clos)"), c[0]))
202
+ return gr.Dropdown(choices=choix, value=choix[0][1] if choix else None)
203
+
204
+ def charger_exemple(nom: str) -> str:
205
+ return json.dumps(EXEMPLES.get(nom, {}), ensure_ascii=False, indent=2)
206
+
207
+
208
+ def construire(obtenir_etat, gpu=None):
209
+ """obtenir_etat() -> (store, encodeur), disponibles une fois le service démarré.
210
+ gpu : décorateur spaces.GPU sur Hugging Face ZeroGPU (app.py) ; None en local, où le
211
+ GPU, s'il existe, est toujours disponible."""
212
+ global _obtenir_etat
213
+ _obtenir_etat = obtenir_etat
214
+ # Durées maximales demandées à ZeroGPU : classer 23 CV relit ~37 000 paires
215
+ fn_matcher = gpu(duration=60)(matcher_cv) if gpu else matcher_cv
216
+ fn_classer = gpu(duration=180)(classer_vivier) if gpu else classer_vivier
217
+
218
+ # ---------- Mise en page ----------
219
+
220
+ with gr.Blocks(title="HackAVP · Matching CV ↔ AVP", analytics_enabled=False) as demo:
221
+ gr.Markdown(
222
+ "# Matching CV ↔ AVP de l'OPT-NC\n"
223
+ "Rapproche des CV ([JSON Resume](https://jsonresume.org/)) des avis de vacance de "
224
+ "poste publiés en open data. Le score est **explicable** : chaque point fort cite la "
225
+ "ligne du CV qui répond à l'attendu. Le nom, l'e-mail et le téléphone ne sont "
226
+ "jamais lus. **Utilisez uniquement des CV fictifs ou le vôtre.**")
227
+
228
+ with gr.Tab("Je suis candidat"):
229
+ with gr.Row():
230
+ exemple = gr.Dropdown(choices=list(EXEMPLES), label="Partir d'un CV fictif",
231
+ value=next(iter(EXEMPLES), None))
232
+ inclure = gr.Checkbox(label="Inclure les AVP clos", value=config.INCLURE_AVP_FERMES)
233
+ cv_texte = gr.Code(language="json", label="CV (JSON Resume) — modifiable",
234
+ value=charger_exemple(next(iter(EXEMPLES), "")), lines=14)
235
+ bouton_c = gr.Button("Trouver mes AVP", variant="primary")
236
+ sortie_c = gr.Markdown(label="Résultats")
237
+ exemple.change(charger_exemple, exemple, cv_texte, api_visibility="private")
238
+ bouton_c.click(fn_matcher, [cv_texte, inclure], sortie_c, api_name="matcher_cv")
239
+
240
+ with gr.Tab("Je recrute"):
241
+ avp = gr.Dropdown(label="AVP à pourvoir", choices=[])
242
+ with gr.Accordion("Vivier de CV (JSON, liste) — 23 CV fictifs par défaut", open=False):
243
+ vivier = gr.Code(language="json", value=_vivier_exemple(), lines=14,
244
+ label="Vivier")
245
+ bouton_r = gr.Button("Classer les candidats", variant="primary")
246
+ sortie_r = gr.Markdown(label="Classement")
247
+ bouton_r.click(fn_classer, [avp, vivier], sortie_r, api_name="classer_candidats")
248
+
249
+ demo.load(choix_avps, None, avp, api_visibility="private")
250
+
251
+ return demo
app/main.py ADDED
@@ -0,0 +1,117 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """API FastAPI du microservice de matching CV <-> AVP, avec interface web Gradio.
2
+
3
+ Une seule application :
4
+ / interface web (Gradio)
5
+ /docs documentation de l'API (Swagger)
6
+ /match un CV -> les AVP qui lui correspondent (côté candidat)
7
+ /avps/{id_avp}/candidats un AVP -> un vivier de CV classé (côté recruteur)
8
+ /gradio_api/mcp/sse serveur MCP (outils matcher_cv et classer_candidats)
9
+
10
+ Lancer : uvicorn app.main:app --port 7860
11
+ """
12
+ from contextlib import asynccontextmanager
13
+
14
+ import gradio as gr
15
+ from fastapi import FastAPI, HTTPException, Query
16
+
17
+ from app import config, scoring
18
+ from app.avp_store import AVPStore
19
+ from app.encodeur import Encodeur
20
+ from app.interface import construire
21
+ from app.matching import matcher
22
+ from app.route_classement import creer_router
23
+ from app.schemas import CV, ReponseMatching
24
+
25
+ etat: dict = {}
26
+
27
+
28
+ def obtenir_etat():
29
+ if "store" not in etat:
30
+ raise RuntimeError("Le service démarre encore (chargement du modèle et des AVP).")
31
+ return etat["store"], etat["encodeur"]
32
+
33
+
34
+ @asynccontextmanager
35
+ async def lifespan(app: FastAPI):
36
+ # Au démarrage : on charge les modèles et les AVP UNE seule fois
37
+ if config.RERANKER_MODEL:
38
+ from app.reranker import Reranker # import tardif : les tests s'en passent
39
+ scoring.RERANKER = Reranker(config.RERANKER_MODEL)
40
+ encodeur = Encodeur(config.MODEL_NAME)
41
+ store = AVPStore(encodeur)
42
+ store.charger()
43
+ etat["encodeur"], etat["store"] = encodeur, store
44
+ yield
45
+
46
+
47
+ app = FastAPI(title="HackAVP - Matching CV / AVP", version="0.2.0", lifespan=lifespan)
48
+
49
+
50
+ @app.get("/health")
51
+ def health():
52
+ store, encodeur = obtenir_etat()
53
+ return {
54
+ "statut": "ok",
55
+ "modele": config.MODEL_NAME,
56
+ "device": encodeur.device,
57
+ "reranker": scoring.RERANKER.nom if scoring.RERANKER else None,
58
+ "nb_avps": len(store.prepares),
59
+ "nb_avps_ouverts": sum(p.ouvert for p in store.prepares.values()),
60
+ "inclure_avp_fermes": config.INCLURE_AVP_FERMES,
61
+ }
62
+
63
+
64
+ @app.get("/avps")
65
+ def lister_avps():
66
+ store, _ = obtenir_etat()
67
+ return [
68
+ {
69
+ "id_avp": id_avp,
70
+ "titre": p.titre,
71
+ "ouvert": p.ouvert,
72
+ "date_limite": str(p.avp.get("validThrough") or "")[:10] or None,
73
+ "nb_attendus": len(p.attendus),
74
+ "prerequis": [t for t, _ in p.prerequis],
75
+ }
76
+ for id_avp, p in store.prepares.items()
77
+ ]
78
+
79
+
80
+ @app.post("/match", response_model=ReponseMatching, tags=["candidat"])
81
+ def match(
82
+ cv: CV,
83
+ top: int = Query(10, ge=1, le=100),
84
+ tri: str = Query(
85
+ "qualite",
86
+ description=(
87
+ "Critère de tri des résultats. "
88
+ "'qualite' (défaut) : score pondéré, perspective candidat. "
89
+ "'couverture' : part des attendus couverts, perspective recruteur."
90
+ ),
91
+ pattern="^(qualite|couverture)$",
92
+ ),
93
+ inclure_fermes: bool = Query(config.INCLURE_AVP_FERMES,
94
+ description="Inclure les AVP dont la date limite est dépassée"),
95
+ ):
96
+ store, encodeur = obtenir_etat()
97
+ try:
98
+ return matcher(cv.model_dump(), store, encodeur, config.SEUIL_COUVERTURE,
99
+ top, tri, inclure_fermes=inclure_fermes)
100
+ except ValueError as e:
101
+ raise HTTPException(status_code=422, detail=str(e))
102
+
103
+
104
+ @app.post("/avps/refresh")
105
+ def rafraichir():
106
+ """Relit le dataset Hugging Face (nouveaux AVP, AVP modifiés ou retirés)."""
107
+ store, _ = obtenir_etat()
108
+ store.charger()
109
+ return {"statut": "ok", "nb_avps": len(store.prepares)}
110
+
111
+
112
+ # Côté recruteur : POST /avps/{id_avp}/candidats
113
+ app.include_router(creer_router(obtenir_etat))
114
+
115
+ # Interface web à la racine, montée APRÈS les routes de l'API pour ne pas les masquer
116
+ app = gr.mount_gradio_app(app, construire(obtenir_etat), path="/", mcp_server=True,
117
+ footer_links=["api"])
app/matching.py ADDED
@@ -0,0 +1,84 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Côté candidat : compare un CV à tous les AVP ouverts et retourne un résultat explicable.
2
+
3
+ Utilise le même moteur de score que le classement côté recruteur (app/scoring.py),
4
+ pour que les deux sens donnent des chiffres cohérents.
5
+ Les schémas de sortie (schemas.py) sont inchangés.
6
+ """
7
+ import numpy as np
8
+
9
+ from app import config
10
+ from app.cv_texte import phrases_du_cv
11
+ from app.schemas import CompetenceCouverte, Ecart, ReponseMatching, ResultatAVP, SavoirEtre
12
+ from app.scoring import libelle, probas_reranker_avps, savoir_etre, scorer
13
+
14
+ INCLURE_AVP_FERMES = getattr(config, "INCLURE_AVP_FERMES", False)
15
+
16
+
17
+ def matcher(cv: dict, store, encodeur, seuil: float, top: int, tri: str = "qualite",
18
+ inclure_fermes: bool = INCLURE_AVP_FERMES) -> ReponseMatching:
19
+ phrases = phrases_du_cv(cv)
20
+ if not phrases:
21
+ raise ValueError("Le CV ne contient aucun texte exploitable.")
22
+
23
+ textes_cv = [texte for texte, _ in phrases]
24
+ vecs_cv = encodeur.encoder(textes_cv)
25
+ vec_cv_global = encodeur.encoder(["\n".join(textes_cv)])[0] # même modèle que l'AVP
26
+
27
+ avps = {i: p for i, p in store.prepares.items() if inclure_fermes or p.ouvert}
28
+ rr = probas_reranker_avps(avps, textes_cv, vecs_cv) # un seul appel pour tous les AVP
29
+
30
+ candidats = [] # (adequation exacte, couverture exacte, ResultatAVP)
31
+ for id_avp, p in avps.items():
32
+ s = scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs_cv, seuil,
33
+ savoir_etre=p.savoir_etre, rr=rr.get(id_avp))
34
+
35
+ # Savoir-faire : couverts / écarts. Les savoir-être sont listés à part.
36
+ couvertes = [CompetenceCouverte(attendu=d.attendu, trouve_dans_cv=d.phrase_cv,
37
+ source_cv=d.source_cv, similarite=round(d.similarite, 3))
38
+ for d in s.details if d.couverte and not d.savoir_etre]
39
+ ecarts = [Ecart(attendu=d.attendu, plus_proche_dans_cv=d.phrase_cv,
40
+ similarite=round(d.similarite, 3))
41
+ for d in s.details if not d.couverte and not d.savoir_etre]
42
+
43
+ # Tri des explications par importance réelle (poids), pas seulement par similarité
44
+ ordre = {d.attendu: d.poids for d in s.details}
45
+ couvertes.sort(key=lambda c: (ordre[c.attendu], c.similarite), reverse=True)
46
+ ecarts.sort(key=lambda e: (ordre[e.attendu], -e.similarite), reverse=True)
47
+
48
+ metier = p.avp.get("relevantOccupation") or {}
49
+ fin = p.avp.get("validThrough")
50
+ candidats.append((s.adequation, s.couverture, ResultatAVP(
51
+ id_avp=id_avp,
52
+ titre=p.titre,
53
+ url=p.avp.get("url"),
54
+ nb_competences=len(p.attendus),
55
+ libelle=libelle(s.adequation),
56
+ nb_savoir_faire=s.nb_savoir_faire,
57
+ nb_savoir_faire_couverts=s.nb_savoir_faire_couverts,
58
+ score_qualite=round(s.adequation, 3),
59
+ score_couverture=round(s.couverture, 3),
60
+ # CV entier vs AVP entier, tous deux encodés par bge-m3 (recette OPT-NC)
61
+ score_global=round(float(p.vec_global @ vec_cv_global), 3),
62
+ fiable=s.fiable,
63
+ avertissement=s.avertissement,
64
+ ouvert=p.ouvert,
65
+ date_limite=str(fin)[:10] if fin else None,
66
+ code_metier=metier.get("code_metier"),
67
+ fiche_metier_url=metier.get("fiche_metier_url"),
68
+ competences_couvertes=couvertes,
69
+ ecarts=ecarts,
70
+ savoir_etre=[SavoirEtre(**x) for x in savoir_etre(s.details)],
71
+ )))
72
+
73
+ # Tri sur les valeurs EXACTES (pas sur les valeurs arrondies à 3 décimales)
74
+ if tri == "couverture":
75
+ candidats.sort(key=lambda t: (t[1], t[0]), reverse=True)
76
+ else:
77
+ candidats.sort(key=lambda t: t[0], reverse=True)
78
+
79
+ return ReponseMatching(
80
+ modele=encodeur.nom,
81
+ seuil=seuil,
82
+ nb_avps_analyses=len(candidats),
83
+ resultats=[r for _, _, r in candidats[:top]],
84
+ )
app/reranker.py ADDED
@@ -0,0 +1,36 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Relit une paire (attendu de l'AVP, phrase du CV) et dit si la phrase prouve l'attendu.
2
+
3
+ bge-m3 encode chaque phrase séparément : deux phrases sans rapport ont déjà ~0.45 de
4
+ similarité. Le reranker (cross-encoder) lit les deux phrases ENSEMBLE et donne une
5
+ probabilité tranchée : ~0 sans rapport, ~1 quand la phrase du CV prouve l'attendu.
6
+ Aucune paire n'est conservée après l'appel (pas de cache des phrases du CV).
7
+ """
8
+ from __future__ import annotations
9
+
10
+ import numpy as np
11
+ import torch
12
+ from sentence_transformers import CrossEncoder
13
+
14
+
15
+ class Reranker:
16
+ def __init__(self, nom_modele: str, device: str | None = None):
17
+ self.nom = nom_modele
18
+ self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
19
+ # float16 sur GPU : deux fois moins de mémoire (la RTX 3050 n'a que 4 Go)
20
+ options = {"torch_dtype": torch.float16} if self.device == "cuda" else {}
21
+ self.modele = CrossEncoder(nom_modele, device=self.device, max_length=256,
22
+ model_kwargs=options)
23
+
24
+ def probas(self, paires: list[tuple[str, str]]) -> np.ndarray:
25
+ """Probabilité 0..1 que la phrase (2e) prouve l'attendu (1er), pour chaque paire."""
26
+ if not paires:
27
+ return np.zeros(0, dtype=np.float32)
28
+ uniques = list(dict.fromkeys(paires)) # une paire relue une seule fois
29
+ # Tri par longueur : chaque lot du GPU contient des paires de taille proche,
30
+ # donc moins de remplissage inutile
31
+ uniques.sort(key=lambda x: len(x[0]) + len(x[1]))
32
+ logits = self.modele.predict(uniques, batch_size=64, convert_to_numpy=True,
33
+ activation_fn=torch.nn.Identity(),
34
+ show_progress_bar=False)
35
+ p = dict(zip(uniques, 1 / (1 + np.exp(-np.asarray(logits, dtype=np.float32)))))
36
+ return np.array([p[x] for x in paires], dtype=np.float32)
app/route_classement.py ADDED
@@ -0,0 +1,27 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Route FastAPI du classement côté recruteur : un AVP face à un vivier de CV."""
2
+ from fastapi import APIRouter, HTTPException, Query
3
+
4
+ from app import config
5
+ from app.classement import classer_candidats
6
+ from app.schemas_classement import ReponseClassement, VivierEntree
7
+
8
+
9
+ def creer_router(obtenir_etat) -> APIRouter:
10
+ """obtenir_etat() -> (store, encodeur) : le modèle n'est chargé qu'au démarrage du service."""
11
+ router = APIRouter(tags=["recruteur"])
12
+
13
+ # ":path" car les identifiants contiennent un "/" (ex. 3134-26-1264/SR).
14
+ # "def" et non "async def" : l'encodage bloque le processeur, FastAPI exécute
15
+ # alors la route dans un pool de threads sans figer le reste du service.
16
+ @router.post("/avps/{id_avp:path}/candidats", response_model=ReponseClassement)
17
+ def classer(id_avp: str, vivier: VivierEntree,
18
+ top: int = Query(20, ge=1, le=200)) -> ReponseClassement:
19
+ """Classe un vivier de CV (JSON Resume) pour un AVP donné, du plus au moins adapté."""
20
+ store, encodeur = obtenir_etat()
21
+ try:
22
+ return classer_candidats(id_avp, vivier.cvs, store, encodeur,
23
+ seuil=config.SEUIL_COUVERTURE, top=top)
24
+ except KeyError:
25
+ raise HTTPException(404, f"AVP inconnu : {id_avp}")
26
+
27
+ return router
app/schemas.py ADDED
@@ -0,0 +1,78 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from pydantic import BaseModel, ConfigDict, Field
2
+
3
+
4
+ class CV(BaseModel):
5
+ """CV au format JSON Resume. Les champs inconnus sont acceptés (extra="allow")."""
6
+ model_config = ConfigDict(extra="allow")
7
+ basics: dict | None = None
8
+ work: list[dict] = []
9
+ volunteer: list[dict] = []
10
+ education: list[dict] = []
11
+ skills: list[dict] = []
12
+ projects: list[dict] = []
13
+ certificates: list[dict] = []
14
+ languages: list[dict] = []
15
+
16
+
17
+ class CompetenceCouverte(BaseModel):
18
+ attendu: str
19
+ trouve_dans_cv: str
20
+ source_cv: str
21
+ similarite: float
22
+
23
+
24
+ class Ecart(BaseModel):
25
+ attendu: str
26
+ plus_proche_dans_cv: str | None
27
+ similarite: float
28
+
29
+
30
+ class SavoirEtre(BaseModel):
31
+ attendu: str
32
+ statut: str = Field(..., description="mention_probable | a_verifier (en entretien)")
33
+ indice_cv: str | None = None
34
+
35
+
36
+ class ResultatAVP(BaseModel):
37
+ id_avp: str
38
+ titre: str | None
39
+ url: str | None = None
40
+ nb_competences: int = Field(..., description="Nombre d'attendus notés (hors titre, "
41
+ "description et prérequis)")
42
+
43
+ libelle: str = Field(..., description=(
44
+ "Lecture du score pour un recruteur : Très bonne / Bonne / Partielle / Faible "
45
+ "adéquation (seuils SEUILS_LIBELLE, réglés sur les CV d'exemple)."))
46
+ nb_savoir_faire: int = Field(..., description="Attendus hors savoir-être (le N de « x / N »)")
47
+ nb_savoir_faire_couverts: int = Field(..., description="Savoir-faire couverts par le CV (le x)")
48
+
49
+ score_qualite: float = Field(..., description=(
50
+ "Score principal, 0..1. Moyenne pondérée des degrés de couverture (meilleure note "
51
+ "entre la rampe bge-m3 et le reranker) : chaque attendu pèse selon son champ et sa "
52
+ "rareté parmi les AVP. Tri côté candidat."))
53
+ score_couverture: float = Field(..., description=(
54
+ "Part pondérée des attendus au-dessus du seuil d'affichage, 0..1. "
55
+ "Tri côté recruteur (tri=couverture)."))
56
+ score_global: float = Field(..., description=(
57
+ "Similarité CV entier / AVP entier, tous deux encodés par bge-m3 selon la recette "
58
+ "de champs OPT-NC. Information d'ensemble, non utilisée pour le tri."))
59
+
60
+ fiable: bool = True
61
+ avertissement: str | None = None
62
+
63
+ ouvert: bool = True
64
+ date_limite: str | None = Field(None, description="validThrough de l'AVP")
65
+ code_metier: str | None = Field(None, description="Code du référentiel métiers OPT-NC")
66
+ fiche_metier_url: str | None = None
67
+
68
+ competences_couvertes: list[CompetenceCouverte] = Field(..., description="Savoir-faire couverts")
69
+ ecarts: list[Ecart] = Field(..., description="Savoir-faire non couverts")
70
+ savoir_etre: list[SavoirEtre] = Field([], description=(
71
+ "Savoir-être de l'AVP, à vérifier en entretien. Ils comptent dans le score."))
72
+
73
+
74
+ class ReponseMatching(BaseModel):
75
+ modele: str
76
+ seuil: float
77
+ nb_avps_analyses: int
78
+ resultats: list[ResultatAVP]
app/schemas_classement.py ADDED
@@ -0,0 +1,70 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Schémas Pydantic du classement côté recruteur : un AVP face à un vivier de CV."""
2
+ from pydantic import BaseModel, ConfigDict, Field
3
+
4
+ from app.schemas import SavoirEtre
5
+
6
+
7
+ class VivierEntree(BaseModel):
8
+ """Corps de POST /avps/{id_avp}/candidats.
9
+ Chaque CV est au format JSON Resume. Un champ 'ref' optionnel (hors JSON Resume)
10
+ permet au recruteur de retrouver le candidat : le matching ne lit jamais l'identité."""
11
+ model_config = ConfigDict(extra="allow")
12
+ cvs: list[dict] = Field(..., min_length=1)
13
+
14
+
15
+ class LigneExplication(BaseModel):
16
+ attendu: str
17
+ champ_avp: str
18
+ poids: float = Field(..., description="Importance de l'attendu (champ x spécificité), 0..1")
19
+ similarite: float
20
+ degre: float = Field(..., description="Degré de couverture 0..1 (rampe bge-m3 ou reranker)")
21
+ phrase_cv: str
22
+ source_cv: str
23
+
24
+
25
+ class Prerequis(BaseModel):
26
+ prerequis: str
27
+ statut: str = Field(..., description="mention_probable | a_verifier (jamais noté)")
28
+ indice_cv: str | None = None
29
+
30
+
31
+ class Candidat(BaseModel):
32
+ rang: int
33
+ index: int = Field(..., description="Position du CV dans le vivier envoyé")
34
+ ref: str | None = None
35
+ score: float = Field(..., description="Adéquation pondérée, 0..100")
36
+ libelle: str = Field(..., description="Très bonne / Bonne / Partielle / Faible adéquation")
37
+ couverture: float = Field(..., description="Part pondérée des attendus couverts, 0..100")
38
+ nb_savoir_faire: int = Field(..., description="Attendus hors savoir-être (le N de « x / N »)")
39
+ nb_savoir_faire_couverts: int = Field(..., description="Savoir-faire couverts (le x)")
40
+ ex_aequo_avec_precedent: bool
41
+ rang_de_cet_avp_pour_le_candidat: int = Field(
42
+ ..., description="1 = cet AVP est celui qui correspond le mieux au candidat")
43
+ specificite: float = Field(
44
+ ..., description="Score sur cet AVP moins son score médian sur les autres AVP. "
45
+ "Proche de 0 : profil qui obtient le même score partout.")
46
+ fiable: bool
47
+ avertissement: str | None = None
48
+ forces: list[LigneExplication]
49
+ ecarts: list[LigneExplication]
50
+ savoir_etre: list[SavoirEtre] = Field([], description="À vérifier en entretien (comptent "
51
+ "dans le score)")
52
+ prerequis: list[Prerequis]
53
+
54
+
55
+ class CandidatEcarte(BaseModel):
56
+ index: int
57
+ ref: str | None = None
58
+ raison: str
59
+
60
+
61
+ class ReponseClassement(BaseModel):
62
+ id_avp: str
63
+ titre: str | None
64
+ avp_ouvert: bool
65
+ modele: str
66
+ seuil: float
67
+ nb_attendus: int
68
+ attendus_les_plus_discriminants: list[str]
69
+ candidats: list[Candidat]
70
+ ecartes: list[CandidatEcarte]
app/scoring.py ADDED
@@ -0,0 +1,246 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Moteur de score commun aux deux sens du matching :
2
+ - un CV face à tous les AVP (matching.py, côté candidat)
3
+ - un AVP face à un vivier de CV (classement.py, côté recruteur)
4
+
5
+ Le score d'adéquation, en trois étapes :
6
+
7
+ 1. Pour chaque attendu de l'AVP, on cherche les phrases du CV les plus proches
8
+ (similarité cosinus bge-m3).
9
+
10
+ 2. On en tire un "degré de couverture" entre 0 et 1, en gardant la meilleure de deux notes :
11
+ - la rampe bge-m3 :
12
+ sim <= BAS -> 0 (rien à voir)
13
+ sim >= HAUT -> 1 (compétence clairement présente)
14
+ entre les deux -> progression linéaire
15
+ bge-m3 donne ~0.45 pour deux phrases sans rapport et ~0.90 pour deux synonymes :
16
+ la rampe étale cette plage étroite sur 0..1. Elle repère bien les reformulations.
17
+ - le reranker (si chargé) : il relit l'attendu avec les K phrases les plus proches et
18
+ donne une probabilité tranchée (~0 sans rapport, ~1 prouvé). Il écarte le bruit.
19
+ Garder la meilleure des deux = un attendu est couvert si l'un OU l'autre le voit.
20
+
21
+ 3. Moyenne pondérée des degrés. Le poids de chaque attendu = poids du champ x spécificité
22
+ (une compétence présente dans tous les AVP, comme "Maîtrise de soi", pèse presque 0).
23
+
24
+ adequation = somme(poids x degré) / somme(poids) -> entre 0 et 1
25
+
26
+ Mesuré sur 24 AVP et 23 CV fictifs (scripts/evaluer_classement.py) : la combinaison classe
27
+ mieux que chacune des deux notes seule, sans faux positif.
28
+ """
29
+ from __future__ import annotations
30
+
31
+ from dataclasses import dataclass
32
+
33
+ import numpy as np
34
+
35
+ from app import config
36
+
37
+ SIM_BAS = getattr(config, "SIM_BAS", 0.575) # [à calibrer] scripts/evaluer_classement.py
38
+ SIM_HAUT = getattr(config, "SIM_HAUT", 0.775)
39
+ SIM_PREREQUIS = getattr(config, "SIM_PREREQUIS", 0.70)
40
+ MIN_PHRASES_CV = getattr(config, "MIN_PHRASES_CV", 5)
41
+ MIN_ATTENDUS_AVP = getattr(config, "MIN_ATTENDUS_AVP", 3)
42
+ RERANKER_TOP_K = getattr(config, "RERANKER_TOP_K", 3)
43
+ SEUILS_LIBELLE = getattr(config, "SEUILS_LIBELLE", [33, 25, 15])
44
+
45
+ # Reranker chargé au démarrage du service (app/main.py). None = bge-m3 seul (tests, CPU lent).
46
+ RERANKER = None
47
+
48
+
49
+ def degre(sims: np.ndarray, bas: float | None = None, haut: float | None = None) -> np.ndarray:
50
+ """Rampe linéaire : similarité -> degré de couverture entre 0 et 1.
51
+ Les bornes sont lues à l'appel (et non figées à l'import) pour que le script
52
+ de calibration puisse les faire varier."""
53
+ bas = SIM_BAS if bas is None else bas
54
+ haut = SIM_HAUT if haut is None else haut
55
+ return np.clip((sims - bas) / (haut - bas), 0.0, 1.0)
56
+
57
+
58
+ def probas_reranker_avps(prepares: dict, textes_cv: list[str],
59
+ vecs_cv: np.ndarray) -> dict[str, tuple[np.ndarray, np.ndarray]]:
60
+ """Notes du reranker d'un CV pour plusieurs AVP, en UN seul appel : le GPU travaille
61
+ par gros lots au lieu d'un petit lot par AVP (bien plus rapide).
62
+
63
+ Pour chaque attendu, le reranker relit les RERANKER_TOP_K phrases du CV les plus proches
64
+ selon bge-m3. Retourne {id_avp: (meilleure probabilité, indice de la phrase)}, vide sans
65
+ reranker. Ne dépend pas de la rampe : calculé une fois, réutilisable."""
66
+ if RERANKER is None or len(vecs_cv) == 0:
67
+ return {}
68
+ tops, paires = {}, []
69
+ for id_avp, p in prepares.items():
70
+ if not len(p.attendus):
71
+ continue
72
+ top = np.argsort(-(p.vecs_attendus @ vecs_cv.T), axis=1)[:, :RERANKER_TOP_K]
73
+ tops[id_avp] = top
74
+ paires += [(p.attendus[i][0], textes_cv[j]) for i, ligne in enumerate(top) for j in ligne]
75
+ probas = RERANKER.probas(paires)
76
+
77
+ res, debut = {}, 0
78
+ for id_avp, top in tops.items():
79
+ p = probas[debut:debut + top.size].reshape(top.shape)
80
+ debut += top.size
81
+ meilleure = p.argmax(axis=1)
82
+ lignes = np.arange(len(top))
83
+ res[id_avp] = (p[lignes, meilleure], top[lignes, meilleure])
84
+ return res
85
+
86
+
87
+ def couvertures(sims: np.ndarray, rr: tuple[np.ndarray, np.ndarray] | None,
88
+ bas: float | None = None, haut: float | None = None
89
+ ) -> tuple[np.ndarray, np.ndarray]:
90
+ """Degré de couverture de chaque attendu = max(rampe bge-m3, probabilité reranker),
91
+ et l'indice de la phrase du CV qui l'a obtenu (pour l'explication)."""
92
+ idx = sims.argmax(axis=1)
93
+ d = degre(sims[np.arange(len(sims)), idx], bas, haut)
94
+ if rr is not None:
95
+ p, idx_rr = rr
96
+ mieux = p > d
97
+ d = np.where(mieux, p, d)
98
+ idx = np.where(mieux, idx_rr, idx)
99
+ return d, idx
100
+
101
+
102
+ def libelle(adequation: float) -> str:
103
+ """Score 0..1 -> libellé pour les recruteurs, seuils réglés sur les CV d'exemple."""
104
+ tres_bonne, bonne, partielle = SEUILS_LIBELLE
105
+ score = 100 * adequation
106
+ if score >= tres_bonne:
107
+ return "Très bonne adéquation"
108
+ if score >= bonne:
109
+ return "Bonne adéquation"
110
+ if score >= partielle:
111
+ return "Adéquation partielle"
112
+ return "Adéquation faible"
113
+
114
+
115
+ @dataclass
116
+ class Detail:
117
+ """Une ligne d'explication : un attendu de l'AVP et ce que le CV y répond."""
118
+ attendu: str
119
+ champ: str
120
+ poids: float
121
+ similarite: float # cosinus bge-m3 entre l'attendu et la phrase retenue
122
+ degre: float # couverture 0..1 retenue (rampe ou reranker)
123
+ phrase_cv: str
124
+ source_cv: str
125
+ couverte: bool
126
+ savoir_etre: bool = False # affiché "à vérifier en entretien", compte quand même
127
+
128
+
129
+ @dataclass
130
+ class Score:
131
+ adequation: float # 0..1, score principal (soft, pondéré)
132
+ couverture: float # 0..1, part pondérée des attendus au-dessus du seuil
133
+ details: list[Detail]
134
+ fiable: bool
135
+ avertissement: str | None
136
+
137
+ @property
138
+ def nb_savoir_faire(self) -> int:
139
+ return sum(not d.savoir_etre for d in self.details)
140
+
141
+ @property
142
+ def nb_savoir_faire_couverts(self) -> int:
143
+ return sum(d.couverte and not d.savoir_etre for d in self.details)
144
+
145
+
146
+ def scorer(
147
+ attendus: list[tuple[str, str]],
148
+ vecs_attendus: np.ndarray,
149
+ poids: np.ndarray,
150
+ phrases_cv: list[tuple[str, str]],
151
+ vecs_cv: np.ndarray,
152
+ seuil: float,
153
+ savoir_etre: np.ndarray | None = None,
154
+ rr: tuple[np.ndarray, np.ndarray] | None = None,
155
+ ) -> Score:
156
+ """Score d'un CV face à un AVP. Aucun arrondi ici : on arrondit à l'affichage.
157
+ rr : notes du reranker pour cet AVP, calculées d'avance avec probas_reranker_avps
158
+ (None = bge-m3 seul)."""
159
+ raisons = []
160
+ if len(phrases_cv) < MIN_PHRASES_CV:
161
+ raisons.append(f"CV court ({len(phrases_cv)} éléments exploitables) : "
162
+ "le score repose sur peu d'informations.")
163
+ if len(attendus) < MIN_ATTENDUS_AVP:
164
+ raisons.append(f"AVP peu détaillé ({len(attendus)} attendus extraits).")
165
+
166
+ if not attendus or len(phrases_cv) == 0 or float(np.sum(poids)) <= 0:
167
+ return Score(0.0, 0.0, [], False,
168
+ " ".join(raisons) or "Aucun attendu exploitable dans l'AVP.")
169
+
170
+ sims = vecs_attendus @ vecs_cv.T # (n_attendus, n_phrases_cv)
171
+ d, idx = couvertures(sims, rr)
172
+ couvertes = d >= seuil
173
+ if savoir_etre is None:
174
+ savoir_etre = np.zeros(len(attendus), dtype=bool)
175
+
176
+ w = poids
177
+ adequation = float(np.sum(w * d) / np.sum(w))
178
+ couverture = float(np.sum(w * couvertes) / np.sum(w))
179
+
180
+ details = [
181
+ Detail(
182
+ attendu=attendus[i][0], champ=attendus[i][1], poids=float(w[i]),
183
+ similarite=float(sims[i, idx[i]]), degre=float(d[i]),
184
+ phrase_cv=phrases_cv[idx[i]][0], source_cv=phrases_cv[idx[i]][1],
185
+ couverte=bool(couvertes[i]), savoir_etre=bool(savoir_etre[i]),
186
+ )
187
+ for i in range(len(attendus))
188
+ ]
189
+ return Score(adequation, couverture, details, not raisons, " ".join(raisons) or None)
190
+
191
+
192
+ def adequations_tous_avps(prepares, vecs_cv: np.ndarray,
193
+ rr: dict | None = None) -> dict[str, float]:
194
+ """Adéquation d'un CV avec chaque AVP (sans détails), pour situer un score.
195
+ rr : notes du reranker par AVP (probas_reranker_avps) ; sans, bge-m3 seul."""
196
+ rr = rr or {}
197
+ res = {}
198
+ for id_avp, p in prepares.items():
199
+ if len(p.attendus) == 0 or float(np.sum(p.poids)) <= 0 or len(vecs_cv) == 0:
200
+ res[id_avp] = 0.0
201
+ continue
202
+ d, _ = couvertures(p.vecs_attendus @ vecs_cv.T, rr.get(id_avp))
203
+ res[id_avp] = float(np.sum(p.poids * d) / np.sum(p.poids))
204
+ return res
205
+
206
+
207
+ def forces_et_ecarts(details: list[Detail], top: int = 3) -> tuple[list[Detail], list[Detail]]:
208
+ """Forces : savoir-faire couverts qui pèsent le plus. Écarts : savoir-faire non couverts
209
+ qui pèsent le plus (= ceux qui font le plus baisser le score). Les savoir-être sont
210
+ présentés à part (à vérifier en entretien)."""
211
+ savoir_faire = [x for x in details if not x.savoir_etre]
212
+ forces = sorted((x for x in savoir_faire if x.couverte),
213
+ key=lambda x: -x.poids * x.degre)[:top]
214
+ ecarts = sorted((x for x in savoir_faire if not x.couverte),
215
+ key=lambda x: -x.poids * (1 - x.degre))[:top]
216
+ return forces, ecarts
217
+
218
+
219
+ def savoir_etre(details: list[Detail]) -> list[dict]:
220
+ """Savoir-être de l'AVP : un CV les écrit rarement, le recruteur les vérifie en entretien.
221
+ 'mention_probable' si une phrase du CV semble y répondre."""
222
+ return [{"attendu": d.attendu,
223
+ "statut": "mention_probable" if d.couverte else "a_verifier",
224
+ "indice_cv": d.phrase_cv if d.couverte else None}
225
+ for d in details if d.savoir_etre]
226
+
227
+
228
+ def verifier_prerequis(prerequis, vecs_prerequis, phrases_cv, vecs_cv) -> list[dict]:
229
+ """Les prérequis (permis, habilitations, diplôme) ne sont pas notés :
230
+ on signale seulement si le CV semble les mentionner. Le recruteur vérifie."""
231
+ if not prerequis:
232
+ return []
233
+ if len(phrases_cv) == 0:
234
+ return [{"prerequis": t, "statut": "a_verifier", "indice_cv": None}
235
+ for t, _ in prerequis]
236
+ sims = vecs_prerequis @ vecs_cv.T
237
+ sortie = []
238
+ for i, (texte, _) in enumerate(prerequis):
239
+ j = int(sims[i].argmax())
240
+ mentionne = float(sims[i, j]) >= SIM_PREREQUIS
241
+ sortie.append({
242
+ "prerequis": texte,
243
+ "statut": "mention_probable" if mentionne else "a_verifier",
244
+ "indice_cv": phrases_cv[j][0] if mentionne else None,
245
+ })
246
+ return sortie
app_zerogpu.py ADDED
@@ -0,0 +1,50 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Point d'entrée pour Hugging Face Spaces, SDK Gradio + matériel ZeroGPU.
2
+
3
+ ZeroGPU prête une carte graphique seulement pendant les fonctions décorées @spaces.GPU,
4
+ et n'accepte que le SDK Gradio. Ce fichier réutilise tout le code de app/ :
5
+ - les modèles sont placés sur "cuda" dès le chargement du module (règle ZeroGPU) ;
6
+ - l'encodage des AVP se fait une fois au démarrage, dans une fonction @spaces.GPU ;
7
+ - les deux fonctions de l'interface (aussi outils MCP) sont décorées @spaces.GPU.
8
+
9
+ En local ou avec Docker, on garde : uvicorn app.main:app --port 7860 (API REST complète).
10
+ Ce fichier tourne aussi en local (python app_zerogpu.py) : sans ZeroGPU, @spaces.GPU ne fait rien.
11
+ """
12
+ try:
13
+ import spaces # AVANT torch : active l'émulation CUDA de ZeroGPU
14
+ GPU = spaces.GPU
15
+ except ImportError: # en local sans le paquet "spaces"
16
+ spaces, GPU = None, None
17
+
18
+ import os
19
+
20
+ import torch
21
+
22
+ from app import config, scoring
23
+ from app.avp_store import AVPStore
24
+ from app.encodeur import Encodeur
25
+ from app.interface import construire
26
+ from app.reranker import Reranker
27
+
28
+ # DEVICE=cuda dans les variables du Space si torch ne voit pas la carte hors @spaces.GPU
29
+ DEVICE = os.getenv("DEVICE") or ("cuda" if torch.cuda.is_available() else "cpu")
30
+
31
+ encodeur = Encodeur(config.MODEL_NAME, device=DEVICE)
32
+ if config.RERANKER_MODEL:
33
+ scoring.RERANKER = Reranker(config.RERANKER_MODEL, device=DEVICE)
34
+ store = AVPStore(encodeur)
35
+
36
+
37
+ def _charger_avps() -> None:
38
+ """Télécharge le dataset et encode les AVP (vecteurs gardés en mémoire, en numpy)."""
39
+ store.charger()
40
+
41
+
42
+ # Au démarrage, une seule fois : l'encodage a besoin du GPU, donc d'une fonction décorée
43
+ (GPU(duration=300)(_charger_avps) if GPU else _charger_avps)()
44
+ print(f"{len(store.prepares)} AVP prêts · modèle {config.MODEL_NAME} · "
45
+ f"reranker {config.RERANKER_MODEL or 'aucun'} · device {DEVICE}")
46
+
47
+ demo = construire(lambda: (store, encodeur), gpu=GPU)
48
+
49
+ if __name__ == "__main__":
50
+ demo.launch(mcp_server=True, footer_links=["api"])
exemples/attendus.json ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "0": ["3134-26-1419"],
3
+ "1": ["3134-26-1377"],
4
+ "2": ["3134-26-1378"],
5
+ "3": ["3134-26-1386", "3134-26-1388"],
6
+ "4": ["3134-26-1395", "3134-26-1396"],
7
+ "5": ["3134-26-1381", "3134-26-1384", "3134-26-1387"],
8
+ "6": ["3134-26-1383"],
9
+ "7": ["3134-26-1379"],
10
+ "8": ["3134-26-1382"],
11
+ "9": null,
12
+ "10": null,
13
+ "12": ["3134-26-1388"],
14
+ "13": ["3134-26-1402"],
15
+ "16": ["3134-26-1390"],
16
+ "17": ["3134-26-1391", "3134-26-1392"],
17
+ "18": ["3134-26-1385"],
18
+ "19": null,
19
+ "20": null,
20
+ "21": null,
21
+ "22": null
22
+ }
exemples/cv_juriste_fictif.json ADDED
@@ -0,0 +1,27 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "basics": {
3
+ "name": "Candidate Fictive",
4
+ "label": "Juriste en droit social",
5
+ "summary": "Juriste spécialisée en droit du travail, 4 ans d'expérience en service RH d'un établissement public."
6
+ },
7
+ "work": [
8
+ {
9
+ "name": "Établissement public fictif",
10
+ "position": "Juriste RH",
11
+ "summary": "Conseil juridique auprès de la DRH et des managers.",
12
+ "highlights": [
13
+ "Rédaction de notes juridiques et d'avis argumentés",
14
+ "Suivi des procédures disciplinaires et du précontentieux",
15
+ "Veille sur la réglementation de la fonction publique"
16
+ ]
17
+ }
18
+ ],
19
+ "education": [
20
+ { "studyType": "Master", "area": "Droit social", "institution": "Université de la Nouvelle-Calédonie" }
21
+ ],
22
+ "skills": [
23
+ { "name": "Droit", "keywords": ["droit du travail", "fonction publique", "contentieux"] },
24
+ { "name": "Bureautique", "keywords": ["Word", "Excel"] }
25
+ ],
26
+ "languages": [ { "language": "Anglais", "fluency": "Professionnel" } ]
27
+ }
exemples/cv_list.json ADDED
@@ -0,0 +1,877 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "_profil": "Auditeur interne (bon match 3134-26-1419)",
4
+ "basics": {
5
+ "label": "Auditeur interne",
6
+ "summary": "5 ans d'expérience en audit interne et contrôle interne dans un établissement public."
7
+ },
8
+ "work": [
9
+ {
10
+ "name": "Établissement public fictif",
11
+ "position": "Auditeur interne",
12
+ "summary": "Réalisation de missions d'audit et suivi des recommandations.",
13
+ "highlights": [
14
+ "Élaboration du référentiel de contrôle interne",
15
+ "Réalisation de missions d'audit selon les normes professionnelles",
16
+ "Suivi des recommandations et reporting à la direction",
17
+ "Animation du processus de management des risques",
18
+ "Analyse des risques et diagnostic des processus"
19
+ ]
20
+ }
21
+ ],
22
+ "education": [
23
+ {
24
+ "studyType": "Master",
25
+ "area": "Audit et contrôle de gestion",
26
+ "institution": "Université fictive"
27
+ }
28
+ ],
29
+ "skills": [
30
+ {
31
+ "name": "Audit",
32
+ "keywords": [
33
+ "contrôle interne",
34
+ "gestion des risques",
35
+ "audit interne",
36
+ "amélioration continue"
37
+ ]
38
+ }
39
+ ]
40
+ },
41
+ {
42
+ "_profil": "Comptable (bon match 3134-26-1377)",
43
+ "basics": {
44
+ "label": "Cadre comptable",
45
+ "summary": "7 ans en comptabilité générale et analytique dans le secteur bancaire."
46
+ },
47
+ "work": [
48
+ {
49
+ "name": "Banque fictive",
50
+ "position": "Responsable comptabilité",
51
+ "summary": "Supervision de la comptabilité générale et production des états financiers.",
52
+ "highlights": [
53
+ "Tenue et contrôle de la comptabilité générale",
54
+ "Production des états financiers et bilans",
55
+ "Rapprochements bancaires et clôtures mensuelles",
56
+ "Suivi des engagements et gestion de la trésorerie",
57
+ "Respect des normes comptables et réglementaires"
58
+ ]
59
+ }
60
+ ],
61
+ "education": [
62
+ {
63
+ "studyType": "Master",
64
+ "area": "Comptabilité Finance",
65
+ "institution": "Université fictive"
66
+ }
67
+ ],
68
+ "skills": [
69
+ {
70
+ "name": "Comptabilité",
71
+ "keywords": [
72
+ "comptabilité générale",
73
+ "bilan",
74
+ "normes comptables",
75
+ "trésorerie"
76
+ ]
77
+ }
78
+ ]
79
+ },
80
+ {
81
+ "_profil": "Conformité et KYC (bon match 3134-26-1378)",
82
+ "basics": {
83
+ "label": "Contrôleur conformité et KYC",
84
+ "summary": "4 ans en conformité bancaire, lutte anti-blanchiment et connaissance client."
85
+ },
86
+ "work": [
87
+ {
88
+ "name": "Banque fictive",
89
+ "position": "Chargé de conformité",
90
+ "summary": "Contrôle de la conformité réglementaire et gestion du KYC.",
91
+ "highlights": [
92
+ "Vérification de la conformité des dossiers clients KYC",
93
+ "Application des procédures de lutte anti-blanchiment",
94
+ "Analyse des risques de non-conformité",
95
+ "Rédaction de rapports de conformité",
96
+ "Veille réglementaire sur la réglementation bancaire"
97
+ ]
98
+ }
99
+ ],
100
+ "education": [
101
+ {
102
+ "studyType": "Master",
103
+ "area": "Droit bancaire et finance",
104
+ "institution": "Université fictive"
105
+ }
106
+ ],
107
+ "skills": [
108
+ {
109
+ "name": "Conformité",
110
+ "keywords": [
111
+ "KYC",
112
+ "conformité",
113
+ "anti-blanchiment",
114
+ "réglementation bancaire"
115
+ ]
116
+ }
117
+ ]
118
+ },
119
+ {
120
+ "_profil": "Informaticien SI (bon match 3134-26-1386 et 3134-26-1388)",
121
+ "basics": {
122
+ "label": "Responsable qualité des systèmes d'information",
123
+ "summary": "6 ans en administration d'applications SI et qualité des systèmes d'information."
124
+ },
125
+ "work": [
126
+ {
127
+ "name": "DSI fictive",
128
+ "position": "Administrateur applications SI",
129
+ "summary": "Administration et maintenance des applications métiers.",
130
+ "highlights": [
131
+ "Administration et maintenance des applications SI",
132
+ "Gestion de la qualité et de la disponibilité des systèmes",
133
+ "Rédaction de procédures et documentation technique",
134
+ "Suivi des incidents et des demandes de maintenance",
135
+ "Participation aux projets de transformation numérique"
136
+ ]
137
+ }
138
+ ],
139
+ "education": [
140
+ {
141
+ "studyType": "Master",
142
+ "area": "Informatique et systèmes d'information",
143
+ "institution": "Université fictive"
144
+ }
145
+ ],
146
+ "skills": [
147
+ {
148
+ "name": "SI",
149
+ "keywords": [
150
+ "systèmes d'information",
151
+ "administration applicative",
152
+ "qualité SI",
153
+ "ITIL"
154
+ ]
155
+ }
156
+ ]
157
+ },
158
+ {
159
+ "_profil": "Commercial télécom (bon match 3134-26-1395 et 3134-26-1396)",
160
+ "basics": {
161
+ "label": "Commercial Grands Comptes Télécom",
162
+ "summary": "5 ans en développement commercial B2B dans le secteur des télécommunications."
163
+ },
164
+ "work": [
165
+ {
166
+ "name": "Opérateur télécom fictif",
167
+ "position": "Chargé d'affaires Grands Comptes",
168
+ "summary": "Développement et fidélisation d'un portefeuille clients entreprises.",
169
+ "highlights": [
170
+ "Gestion et développement d'un portefeuille de clients entreprises",
171
+ "Vente de solutions télécom et services associés",
172
+ "Élaboration de propositions commerciales et négociation",
173
+ "Suivi de la satisfaction client et gestion des contrats",
174
+ "Atteinte des objectifs commerciaux"
175
+ ]
176
+ }
177
+ ],
178
+ "education": [
179
+ {
180
+ "studyType": "Bachelor",
181
+ "area": "Commerce et Marketing",
182
+ "institution": "École de commerce fictive"
183
+ }
184
+ ],
185
+ "skills": [
186
+ {
187
+ "name": "Commercial",
188
+ "keywords": [
189
+ "développement commercial",
190
+ "grands comptes",
191
+ "télécom",
192
+ "négociation"
193
+ ]
194
+ }
195
+ ]
196
+ },
197
+ {
198
+ "_profil": "Chargé de clientèle (bon match 3134-26-1381, 1384, 1387)",
199
+ "basics": {
200
+ "label": "Chargé de contact clientèle",
201
+ "summary": "3 ans en relation client et accueil dans un réseau d'agences."
202
+ },
203
+ "work": [
204
+ {
205
+ "name": "Agence fictive",
206
+ "position": "Conseiller clientèle",
207
+ "summary": "Accueil et conseil des clients en agence.",
208
+ "highlights": [
209
+ "Accueil et renseignement des clients en agence",
210
+ "Vente de produits et services au guichet",
211
+ "Gestion des réclamations et suivi de la satisfaction client",
212
+ "Application des procédures et règlements en vigueur",
213
+ "Encaissement et gestion de la caisse"
214
+ ]
215
+ }
216
+ ],
217
+ "education": [
218
+ {
219
+ "studyType": "BTS",
220
+ "area": "Commerce",
221
+ "institution": "Lycée fictif"
222
+ }
223
+ ],
224
+ "skills": [
225
+ {
226
+ "name": "Relation client",
227
+ "keywords": ["accueil", "vente", "service client", "caisse"]
228
+ }
229
+ ]
230
+ },
231
+ {
232
+ "_profil": "Chef d'agence (bon match 3134-26-1383)",
233
+ "basics": {
234
+ "label": "Chef d'agence",
235
+ "summary": "8 ans en management d'équipe et gestion d'agence commerciale."
236
+ },
237
+ "work": [
238
+ {
239
+ "name": "Réseau d'agences fictif",
240
+ "position": "Responsable d'agence",
241
+ "summary": "Management d'une équipe de 10 personnes et pilotage de l'activité commerciale.",
242
+ "highlights": [
243
+ "Management et animation d'une équipe pluridisciplinaire",
244
+ "Pilotage des objectifs commerciaux et opérationnels",
245
+ "Gestion administrative et reporting à la direction",
246
+ "Développement de la relation client et fidélisation",
247
+ "Organisation et planification de l'activité"
248
+ ]
249
+ }
250
+ ],
251
+ "education": [
252
+ {
253
+ "studyType": "Master",
254
+ "area": "Management",
255
+ "institution": "École de management fictive"
256
+ }
257
+ ],
258
+ "skills": [
259
+ {
260
+ "name": "Management",
261
+ "keywords": [
262
+ "management d'équipe",
263
+ "gestion d'agence",
264
+ "pilotage commercial",
265
+ "leadership"
266
+ ]
267
+ }
268
+ ]
269
+ },
270
+ {
271
+ "_profil": "Logisticien / magasinier (bon match 3134-26-1379)",
272
+ "basics": {
273
+ "label": "Magasinier logisticien",
274
+ "summary": "4 ans en gestion de stocks et logistique dans un entrepôt."
275
+ },
276
+ "work": [
277
+ {
278
+ "name": "Entrepôt fictif",
279
+ "position": "Magasinier",
280
+ "summary": "Réception, stockage et expédition des marchandises.",
281
+ "highlights": [
282
+ "Réception et contrôle des livraisons",
283
+ "Gestion des stocks et inventaires",
284
+ "Préparation des commandes et expéditions",
285
+ "Utilisation des engins de manutention",
286
+ "Application des règles de sécurité et d'hygiène"
287
+ ]
288
+ }
289
+ ],
290
+ "education": [
291
+ {
292
+ "studyType": "CAP",
293
+ "area": "Logistique",
294
+ "institution": "Lycée professionnel fictif"
295
+ }
296
+ ],
297
+ "skills": [
298
+ {
299
+ "name": "Logistique",
300
+ "keywords": [
301
+ "gestion des stocks",
302
+ "manutention",
303
+ "logistique",
304
+ "inventaire"
305
+ ]
306
+ }
307
+ ]
308
+ },
309
+ {
310
+ "_profil": "Administrateur pratiques métiers (bon match 3134-26-1382)",
311
+ "basics": {
312
+ "label": "Administrateur des pratiques métiers",
313
+ "summary": "5 ans en gestion des processus et pratiques métiers dans un grand groupe."
314
+ },
315
+ "work": [
316
+ {
317
+ "name": "Grande entreprise fictive",
318
+ "position": "Chargé des pratiques métiers",
319
+ "summary": "Formalisation et amélioration des processus métiers.",
320
+ "highlights": [
321
+ "Modélisation et formalisation des processus métiers",
322
+ "Rédaction de procédures et guides de bonnes pratiques",
323
+ "Animation des équipes opérationnelles et fonctionnelles",
324
+ "Conduite d'audits internes des pratiques",
325
+ "Pilotage des démarches d'amélioration continue"
326
+ ]
327
+ }
328
+ ],
329
+ "education": [
330
+ {
331
+ "studyType": "Master",
332
+ "area": "Management des organisations",
333
+ "institution": "Université fictive"
334
+ }
335
+ ],
336
+ "skills": [
337
+ {
338
+ "name": "Processus",
339
+ "keywords": [
340
+ "processus métiers",
341
+ "amélioration continue",
342
+ "modélisation",
343
+ "BPMN"
344
+ ]
345
+ }
346
+ ]
347
+ },
348
+ {
349
+ "_profil": "Hors domaine - Médecin (faux positif attendu)",
350
+ "basics": {
351
+ "label": "Médecin généraliste",
352
+ "summary": "10 ans de pratique médicale en cabinet libéral."
353
+ },
354
+ "work": [
355
+ {
356
+ "name": "Cabinet médical fictif",
357
+ "position": "Médecin généraliste",
358
+ "summary": "Consultation et suivi de patients.",
359
+ "highlights": [
360
+ "Diagnostic et traitement des pathologies courantes",
361
+ "Suivi des patients chroniques",
362
+ "Prescription médicale et orientation vers les spécialistes",
363
+ "Tenue du dossier médical"
364
+ ]
365
+ }
366
+ ],
367
+ "education": [
368
+ {
369
+ "studyType": "Doctorat",
370
+ "area": "Médecine",
371
+ "institution": "Faculté de médecine fictive"
372
+ }
373
+ ],
374
+ "skills": [
375
+ {
376
+ "name": "Médecine",
377
+ "keywords": ["diagnostic", "prescription", "pathologie", "soins"]
378
+ }
379
+ ]
380
+ },
381
+ {
382
+ "_profil": "Hors domaine - Cuisinier (faux positif attendu)",
383
+ "basics": {
384
+ "label": "Chef cuisinier",
385
+ "summary": "8 ans en restauration gastronomique."
386
+ },
387
+ "work": [
388
+ {
389
+ "name": "Restaurant fictif",
390
+ "position": "Chef de cuisine",
391
+ "summary": "Direction de la cuisine et élaboration des menus.",
392
+ "highlights": [
393
+ "Élaboration des menus et fiches techniques",
394
+ "Gestion des approvisionnements et des stocks alimentaires",
395
+ "Management de l'équipe de cuisine",
396
+ "Respect des normes HACCP",
397
+ "Contrôle de la qualité des plats"
398
+ ]
399
+ }
400
+ ],
401
+ "education": [
402
+ {
403
+ "studyType": "CAP",
404
+ "area": "Cuisine",
405
+ "institution": "Lycée hôtelier fictif"
406
+ }
407
+ ],
408
+ "skills": [
409
+ {
410
+ "name": "Cuisine",
411
+ "keywords": [
412
+ "gastronomie",
413
+ "HACCP",
414
+ "gestion des stocks alimentaires",
415
+ "management cuisine"
416
+ ]
417
+ }
418
+ ]
419
+ },
420
+ {
421
+ "_profil": "Profil généraliste administratif (match moyen attendu)",
422
+ "basics": {
423
+ "label": "Assistant administratif",
424
+ "summary": "4 ans en assistanat administratif et opérationnel dans le secteur public."
425
+ },
426
+ "work": [
427
+ {
428
+ "name": "Collectivité fictive",
429
+ "position": "Assistant administratif",
430
+ "summary": "Support administratif et opérationnel à la direction.",
431
+ "highlights": [
432
+ "Gestion du courrier et des communications internes",
433
+ "Rédaction de comptes-rendus et rapports administratifs",
434
+ "Organisation des réunions et gestion des agendas",
435
+ "Suivi des dossiers administratifs",
436
+ "Accueil téléphonique et orientation des interlocuteurs"
437
+ ]
438
+ }
439
+ ],
440
+ "education": [
441
+ {
442
+ "studyType": "BTS",
443
+ "area": "Assistant de gestion",
444
+ "institution": "Lycée fictif"
445
+ }
446
+ ],
447
+ "skills": [
448
+ {
449
+ "name": "Administratif",
450
+ "keywords": [
451
+ "secrétariat",
452
+ "rédaction administrative",
453
+ "organisation",
454
+ "bureautique"
455
+ ]
456
+ }
457
+ ]
458
+ },
459
+ {
460
+ "_profil": "Technicien réseau télécom (bon match 3134-26-1388)",
461
+ "basics": {
462
+ "label": "Technicien réseaux télécom",
463
+ "summary": "5 ans en exploitation et maintenance des réseaux télécom mobiles et fixes."
464
+ },
465
+ "work": [
466
+ {
467
+ "name": "Opérateur télécom fictif",
468
+ "position": "Technicien réseaux",
469
+ "summary": "Exploitation et maintenance des infrastructures télécom.",
470
+ "highlights": [
471
+ "Maintenance et exploitation des équipements réseau télécom",
472
+ "Diagnostic et résolution des pannes sur le réseau mobile et fixe",
473
+ "Configuration des équipements de transmission et de commutation",
474
+ "Suivi des interventions et rédaction des rapports techniques",
475
+ "Participation aux projets de déploiement réseau"
476
+ ]
477
+ }
478
+ ],
479
+ "education": [
480
+ {
481
+ "studyType": "BTS",
482
+ "area": "Systèmes numériques option réseaux",
483
+ "institution": "IUT fictif"
484
+ }
485
+ ],
486
+ "skills": [
487
+ {
488
+ "name": "Réseaux télécom",
489
+ "keywords": [
490
+ "réseaux mobiles",
491
+ "transmission",
492
+ "maintenance télécom",
493
+ "IP"
494
+ ]
495
+ }
496
+ ]
497
+ },
498
+ {
499
+ "_profil": "Superviseur réseau (bon match 3134-26-1402)",
500
+ "basics": {
501
+ "label": "Superviseur centre opérationnel réseau",
502
+ "summary": "6 ans en supervision 24/7 des infrastructures télécom et gestion des incidents."
503
+ },
504
+ "work": [
505
+ {
506
+ "name": "Opérateur fictif",
507
+ "position": "Superviseur NOC",
508
+ "summary": "Supervision temps réel des réseaux et coordination des interventions.",
509
+ "highlights": [
510
+ "Surveillance en temps réel des équipements et liens télécom",
511
+ "Détection, qualification et escalade des incidents réseau",
512
+ "Coordination des équipes terrain lors des incidents majeurs",
513
+ "Rédaction de rapports d'incidents et de tableaux de bord",
514
+ "Application des procédures de gestion de crise"
515
+ ]
516
+ }
517
+ ],
518
+ "education": [
519
+ {
520
+ "studyType": "Licence",
521
+ "area": "Réseaux et télécommunications",
522
+ "institution": "IUT fictif"
523
+ }
524
+ ],
525
+ "skills": [
526
+ {
527
+ "name": "Supervision",
528
+ "keywords": [
529
+ "NOC",
530
+ "supervision réseau",
531
+ "gestion incidents",
532
+ "monitoring télécom"
533
+ ]
534
+ }
535
+ ]
536
+ },
537
+ {
538
+ "_profil": "Chargé RH (match partiel attendu sur plusieurs AVP)",
539
+ "basics": {
540
+ "label": "Chargé de ressources humaines",
541
+ "summary": "4 ans en gestion RH généraliste dans une collectivité publique."
542
+ },
543
+ "work": [
544
+ {
545
+ "name": "Collectivité publique fictive",
546
+ "position": "Chargé RH",
547
+ "summary": "Gestion des recrutements, formations et administration du personnel.",
548
+ "highlights": [
549
+ "Pilotage des recrutements et intégration des agents",
550
+ "Gestion des formations et du plan de développement des compétences",
551
+ "Administration du personnel et suivi des carrières",
552
+ "Conseil aux managers sur les questions RH",
553
+ "Participation aux réunions paritaires"
554
+ ]
555
+ }
556
+ ],
557
+ "education": [
558
+ {
559
+ "studyType": "Master",
560
+ "area": "Gestion des ressources humaines",
561
+ "institution": "Université fictive"
562
+ }
563
+ ],
564
+ "skills": [
565
+ {
566
+ "name": "RH",
567
+ "keywords": [
568
+ "recrutement",
569
+ "formation",
570
+ "gestion des carrières",
571
+ "droit social"
572
+ ]
573
+ }
574
+ ]
575
+ },
576
+ {
577
+ "_profil": "Juriste droit public (match partiel sur conformité et audit)",
578
+ "basics": {
579
+ "label": "Juriste en droit public",
580
+ "summary": "5 ans en conseil juridique et veille réglementaire dans un établissement public."
581
+ },
582
+ "work": [
583
+ {
584
+ "name": "Établissement public fictif",
585
+ "position": "Juriste",
586
+ "summary": "Conseil juridique et gestion des contentieux.",
587
+ "highlights": [
588
+ "Rédaction d'avis juridiques et de notes de droit public",
589
+ "Veille réglementaire et analyse des textes législatifs",
590
+ "Gestion des contentieux et des procédures administratives",
591
+ "Conseil aux directions sur les risques juridiques",
592
+ "Rédaction de contrats et conventions"
593
+ ]
594
+ }
595
+ ],
596
+ "education": [
597
+ {
598
+ "studyType": "Master",
599
+ "area": "Droit public",
600
+ "institution": "Université fictive"
601
+ }
602
+ ],
603
+ "skills": [
604
+ {
605
+ "name": "Droit",
606
+ "keywords": [
607
+ "droit public",
608
+ "contentieux administratif",
609
+ "veille réglementaire",
610
+ "contrats publics"
611
+ ]
612
+ }
613
+ ]
614
+ },
615
+ {
616
+ "_profil": "Préposé distribution courrier (bon match 3134-26-1390)",
617
+ "basics": {
618
+ "label": "Facteur préposé à la distribution",
619
+ "summary": "3 ans en distribution quotidienne du courrier et des colis à domicile."
620
+ },
621
+ "work": [
622
+ {
623
+ "name": "Service postal fictif",
624
+ "position": "Facteur",
625
+ "summary": "Distribution du courrier et des colis sur une tournée définie.",
626
+ "highlights": [
627
+ "Distribution quotidienne du courrier et des colis sur la tournée",
628
+ "Collecte du courrier départ et dépôt en bureau de poste",
629
+ "Gestion des avis de passage et des recommandés",
630
+ "Relation de proximité avec les clients de la tournée",
631
+ "Utilisation d'un véhicule de service et respect des délais"
632
+ ]
633
+ }
634
+ ],
635
+ "education": [
636
+ {
637
+ "studyType": "CAP",
638
+ "area": "Agent logistique",
639
+ "institution": "Lycée professionnel fictif"
640
+ }
641
+ ],
642
+ "skills": [
643
+ {
644
+ "name": "Distribution postale",
645
+ "keywords": [
646
+ "distribution courrier",
647
+ "colis",
648
+ "tournée postale",
649
+ "service client"
650
+ ]
651
+ }
652
+ ]
653
+ },
654
+ {
655
+ "_profil": "Agent exploitation postal (bon match 3134-26-1391 et 3134-26-1392)",
656
+ "basics": {
657
+ "label": "Agent d'exploitation postal",
658
+ "summary": "4 ans en traitement et acheminement du courrier en centre de tri."
659
+ },
660
+ "work": [
661
+ {
662
+ "name": "Centre de tri fictif",
663
+ "position": "Agent d'exploitation",
664
+ "summary": "Traitement du courrier entrant et sortant.",
665
+ "highlights": [
666
+ "Tri manuel et mécanisé du courrier et des colis",
667
+ "Chargement et déchargement des véhicules de collecte",
668
+ "Contrôle de la conformité des envois postaux",
669
+ "Utilisation des équipements de manutention et de tri",
670
+ "Respect des délais et procédures d'exploitation postale"
671
+ ]
672
+ }
673
+ ],
674
+ "education": [
675
+ {
676
+ "studyType": "CAP",
677
+ "area": "Logistique",
678
+ "institution": "Lycée professionnel fictif"
679
+ }
680
+ ],
681
+ "skills": [
682
+ {
683
+ "name": "Exploitation postale",
684
+ "keywords": [
685
+ "tri postal",
686
+ "manutention",
687
+ "centre de tri",
688
+ "acheminement courrier"
689
+ ]
690
+ }
691
+ ]
692
+ },
693
+ {
694
+ "_profil": "Contrôleur bancaire client (bon match 3134-26-1385)",
695
+ "basics": {
696
+ "label": "Contrôleur client bancaire",
697
+ "summary": "4 ans en contrôle qualité des dossiers clients dans un back-office bancaire."
698
+ },
699
+ "work": [
700
+ {
701
+ "name": "Banque fictive",
702
+ "position": "Contrôleur back-office",
703
+ "summary": "Contrôle et validation des dossiers clients bancaires.",
704
+ "highlights": [
705
+ "Vérification et validation des dossiers clients bancaires",
706
+ "Détection et traitement des anomalies et écarts",
707
+ "Gestion des réclamations clients complexes en back-office",
708
+ "Rédaction de rapports de contrôle qualité",
709
+ "Participation aux audits et contrôles internes"
710
+ ]
711
+ }
712
+ ],
713
+ "education": [
714
+ {
715
+ "studyType": "Licence",
716
+ "area": "Banque et finance",
717
+ "institution": "Université fictive"
718
+ }
719
+ ],
720
+ "skills": [
721
+ {
722
+ "name": "Contrôle bancaire",
723
+ "keywords": [
724
+ "back-office bancaire",
725
+ "contrôle qualité",
726
+ "dossiers clients",
727
+ "réclamations"
728
+ ]
729
+ }
730
+ ]
731
+ },
732
+ {
733
+ "_profil": "Hors domaine - Enseignant (faux positif attendu)",
734
+ "basics": {
735
+ "label": "Professeur de mathématiques",
736
+ "summary": "12 ans d'enseignement des mathématiques au lycée."
737
+ },
738
+ "work": [
739
+ {
740
+ "name": "Lycée fictif",
741
+ "position": "Professeur de mathématiques",
742
+ "summary": "Enseignement des mathématiques en classes de lycée.",
743
+ "highlights": [
744
+ "Enseignement des mathématiques en terminale S",
745
+ "Préparation et correction des épreuves du baccalauréat",
746
+ "Suivi individualisé des élèves en difficulté",
747
+ "Participation aux conseils de classe et réunions pédagogiques"
748
+ ]
749
+ }
750
+ ],
751
+ "education": [
752
+ {
753
+ "studyType": "Master",
754
+ "area": "Mathématiques",
755
+ "institution": "Université fictive"
756
+ }
757
+ ],
758
+ "skills": [
759
+ {
760
+ "name": "Enseignement",
761
+ "keywords": [
762
+ "mathématiques",
763
+ "pédagogie",
764
+ "lycée",
765
+ "éducation nationale"
766
+ ]
767
+ }
768
+ ]
769
+ },
770
+ {
771
+ "_profil": "Hors domaine - Agriculteur (faux positif attendu)",
772
+ "basics": {
773
+ "label": "Agriculteur éleveur",
774
+ "summary": "15 ans en exploitation agricole polyculture-élevage bovin en Nouvelle-Calédonie."
775
+ },
776
+ "work": [
777
+ {
778
+ "name": "Exploitation agricole fictive",
779
+ "position": "Agriculteur exploitant",
780
+ "summary": "Gestion d'une exploitation agricole et d'un élevage bovin.",
781
+ "highlights": [
782
+ "Conduite des cultures et gestion des récoltes",
783
+ "Élevage bovin et gestion du troupeau",
784
+ "Entretien et réparation des équipements agricoles",
785
+ "Gestion administrative et comptable de l'exploitation"
786
+ ]
787
+ }
788
+ ],
789
+ "education": [
790
+ {
791
+ "studyType": "BPREA",
792
+ "area": "Agriculture",
793
+ "institution": "Lycée agricole fictif"
794
+ }
795
+ ],
796
+ "skills": [
797
+ {
798
+ "name": "Agriculture",
799
+ "keywords": [
800
+ "élevage bovin",
801
+ "cultures",
802
+ "machinisme agricole",
803
+ "gestion exploitation"
804
+ ]
805
+ }
806
+ ]
807
+ },
808
+ {
809
+ "_profil": "Hors domaine - Sportif professionnel (faux positif attendu)",
810
+ "basics": {
811
+ "label": "Joueur de rugby professionnel",
812
+ "summary": "8 ans de carrière dans le rugby professionnel en Nouvelle-Calédonie et en métropole."
813
+ },
814
+ "work": [
815
+ {
816
+ "name": "Club de rugby fictif",
817
+ "position": "Joueur professionnel",
818
+ "summary": "Pratique du rugby professionnel et participation aux compétitions.",
819
+ "highlights": [
820
+ "Participation aux entraînements quotidiens et aux matchs officiels",
821
+ "Préparation physique et récupération sportive",
822
+ "Travail en équipe et respect des consignes de l'entraîneur",
823
+ "Représentation du club lors des événements officiels"
824
+ ]
825
+ }
826
+ ],
827
+ "education": [
828
+ {
829
+ "studyType": "Baccalauréat",
830
+ "area": "Sciences et techniques des activités physiques et sportives",
831
+ "institution": "Lycée fictif"
832
+ }
833
+ ],
834
+ "skills": [
835
+ {
836
+ "name": "Sport",
837
+ "keywords": [
838
+ "rugby",
839
+ "performance sportive",
840
+ "travail en équipe",
841
+ "préparation physique"
842
+ ]
843
+ }
844
+ ]
845
+ },
846
+ {
847
+ "_profil": "Étudiant junior sans expérience (scores bas attendus partout)",
848
+ "basics": {
849
+ "label": "Étudiant en master informatique",
850
+ "summary": "Étudiant en fin de master informatique, sans expérience professionnelle significative."
851
+ },
852
+ "work": [
853
+ {
854
+ "name": "Stage fictif",
855
+ "position": "Stagiaire développeur",
856
+ "summary": "Stage de 3 mois en développement web.",
857
+ "highlights": [
858
+ "Développement d'une application web en Python Django",
859
+ "Rédaction de tests unitaires et documentation"
860
+ ]
861
+ }
862
+ ],
863
+ "education": [
864
+ {
865
+ "studyType": "Master",
866
+ "area": "Informatique",
867
+ "institution": "Université de la Nouvelle-Calédonie"
868
+ }
869
+ ],
870
+ "skills": [
871
+ {
872
+ "name": "Informatique",
873
+ "keywords": ["Python", "développement web", "SQL", "Git"]
874
+ }
875
+ ]
876
+ }
877
+ ]
requirements-dev.txt ADDED
@@ -0,0 +1,4 @@
 
 
 
 
 
1
+ # Outils de mesure et de documentation (pas nécessaires au service)
2
+ -r requirements.txt
3
+ matplotlib>=3.8 # scripts/graphiques.py
4
+ playwright>=1.40 # scripts/captures.py (puis : python -m playwright install chromium)
requirements.txt ADDED
@@ -0,0 +1,18 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Service
2
+ fastapi>=0.115.2,<1.0
3
+ uvicorn[standard]>=0.30
4
+ pydantic>=2.11,<=2.12.5
5
+ gradio[mcp]==6.30.0
6
+
7
+ # Modèle et données
8
+ sentence-transformers>=3.0,<7
9
+ # >=2.6 : transformers 5 a besoin de torch.accelerator ; <2.14 : versions acceptées par ZeroGPU
10
+ torch>=2.6,<2.14
11
+ spaces>=0.40 # ZeroGPU sur Hugging Face (@spaces.GPU) ; sans effet ailleurs
12
+ huggingface_hub>=1.16,<2.0
13
+ numpy>=1.26
14
+ pandas>=2.0
15
+ pyarrow>=15
16
+
17
+ # Scripts d'analyse (scripts/)
18
+ scipy>=1.11
scripts/__init__.py ADDED
File without changes
scripts/avp.py ADDED
@@ -0,0 +1,19 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import json
2
+ import urllib.request
3
+
4
+ cvs = json.load(open("exemples/cv_list.json", encoding="utf-8"))
5
+ cv = cvs[0]
6
+ cv.pop("_profil", None)
7
+
8
+ data = json.dumps(cv).encode()
9
+ req = urllib.request.Request(
10
+ "http://localhost:8000/match?top=3",
11
+ data=data,
12
+ headers={"Content-Type": "application/json"},
13
+ method="POST"
14
+ )
15
+ try:
16
+ with urllib.request.urlopen(req) as r:
17
+ print(r.read().decode())
18
+ except urllib.error.HTTPError as e:
19
+ print(e.read().decode())
scripts/captures.py ADDED
@@ -0,0 +1,50 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Captures d'écran de l'interface web (service lancé) + texte exact des résultats affichés.
2
+
3
+ Lancer, service démarré sur le port 7860 :
4
+ python -m scripts.captures resultats/<date> [http://127.0.0.1:7860]
5
+ Produit : 5_interface_candidat.png, 6_interface_recruteur.png et les textes .md associés.
6
+ """
7
+ import sys
8
+ from pathlib import Path
9
+
10
+ from playwright.sync_api import sync_playwright
11
+
12
+ DOSSIER = Path(sys.argv[1])
13
+ URL = sys.argv[2] if len(sys.argv) > 2 else "http://127.0.0.1:7860"
14
+ AVP_RECRUTEUR = "3134-26-1419/SR" # Auditeur : le vivier des 23 CV fictifs est classé pour lui
15
+ DELAI_MS = 10 * 60 * 1000 # le classement de 23 CV peut prendre ~1-2 min sur GPU
16
+
17
+
18
+ def sauver_texte(page, nom):
19
+ texte = page.locator(".prose").last.inner_text()
20
+ (DOSSIER / nom).write_text(texte, encoding="utf-8")
21
+ print(f" -> {DOSSIER / nom}")
22
+
23
+
24
+ with sync_playwright() as p:
25
+ nav = p.chromium.launch()
26
+ page = nav.new_page(viewport={"width": 1280, "height": 900}, device_scale_factor=1.5)
27
+ page.goto(URL, wait_until="networkidle")
28
+
29
+ # Onglet candidat : CV fictif par défaut (auditeur), AVP clos inclus
30
+ case = page.get_by_label("Inclure les AVP clos")
31
+ if not case.is_checked():
32
+ case.check()
33
+ page.get_by_role("button", name="Trouver mes AVP").click()
34
+ page.get_by_text("AVP analysés").wait_for(timeout=DELAI_MS)
35
+ page.screenshot(path=DOSSIER / "5_interface_candidat.png", full_page=True)
36
+ print(f" -> {DOSSIER / '5_interface_candidat.png'}")
37
+ sauver_texte(page, "5_interface_candidat.md")
38
+
39
+ # Onglet recruteur : AVP Auditeur, vivier des 23 CV fictifs
40
+ page.get_by_role("tab", name="Je recrute").click()
41
+ liste = page.get_by_label("AVP à pourvoir")
42
+ liste.click()
43
+ liste.fill(AVP_RECRUTEUR.split("/")[0])
44
+ page.get_by_role("option").filter(has_text=AVP_RECRUTEUR).first.click()
45
+ page.get_by_role("button", name="Classer les candidats").click()
46
+ page.get_by_text("Attendus les plus discriminants").wait_for(timeout=DELAI_MS)
47
+ page.screenshot(path=DOSSIER / "6_interface_recruteur.png", full_page=True)
48
+ print(f" -> {DOSSIER / '6_interface_recruteur.png'}")
49
+ sauver_texte(page, "6_interface_recruteur.md")
50
+ nav.close()
scripts/evaluer_classement.py ADDED
@@ -0,0 +1,158 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Évalue le score dans les deux sens et calibre la rampe SIM_BAS / SIM_HAUT.
2
+
3
+ Utilise les 23 CV fictifs de exemples/cv_list.json et les réponses attendues de
4
+ exemples/attendus.json :
5
+ {"0": ["3134-26-1419"], "3": ["3134-26-1386", "3134-26-1388"], "9": null, ...}
6
+ - une liste : le ou les AVP sur lesquels ce CV devrait sortir (préfixe d'id accepté)
7
+ - null : profil hors domaine, ne devrait être en tête nulle part
8
+ - CV absent : cas ambigu (match partiel), ignoré dans les mesures
9
+
10
+ Mesures :
11
+ sens recruteur : pour un AVP, le bon CV est-il en tête du vivier ? (top1, MRR)
12
+ sens candidat : pour un CV, son bon AVP est-il en tête ? (top1, top3, MRR)
13
+ marge : score du bon CV moins le meilleur score d'un hors-domaine sur le même
14
+ AVP. Négatif = faux positif (un hors-domaine passe devant).
15
+
16
+ Le score est calculé comme dans le service : meilleure note entre la rampe bge-m3 et le
17
+ reranker (si RERANKER_MODEL est défini). Les notes du reranker ne dépendent pas de la rampe :
18
+ elles sont calculées une fois, puis la rampe est calibrée par-dessus.
19
+
20
+ Lancer depuis la racine du projet : python -m scripts.evaluer_classement
21
+ Sans reranker (pour comparer) : $env:RERANKER_MODEL=""; python -m scripts.evaluer_classement
22
+ """
23
+ import json
24
+ from pathlib import Path
25
+
26
+ import numpy as np
27
+
28
+ from app import config, scoring
29
+ from app.avp_store import AVPStore
30
+ from app.cv_texte import phrases_du_cv
31
+ from app.encodeur import Encodeur
32
+
33
+ RACINE = Path(__file__).resolve().parent.parent
34
+
35
+
36
+ def charger_attendus(ids_avp: list[str]) -> dict[int, list[str] | None]:
37
+ brut = json.loads((RACINE / "exemples/attendus.json").read_text(encoding="utf-8"))
38
+ sortie = {}
39
+ for k, v in brut.items():
40
+ if v is None:
41
+ sortie[int(k)] = None
42
+ continue
43
+ trouves = [i for x in v for i in ids_avp if i == x or i.startswith(x + "/")]
44
+ if not trouves:
45
+ print(f" ⚠ CV {k} : AVP attendu(s) {v} absent(s) du dataset, CV ignoré")
46
+ continue
47
+ sortie[int(k)] = trouves
48
+ return sortie
49
+
50
+
51
+ def matrice(sims_cv, poids, bas, haut) -> np.ndarray:
52
+ """scores[c, a] = adéquation du CV c pour l'AVP a, pour une rampe donnée.
53
+ sims_cv[c][a] = (similarités attendus x phrases, notes du reranker ou None)."""
54
+ m = np.zeros((len(sims_cv), len(poids)))
55
+ for c, ligne in enumerate(sims_cv):
56
+ for a, (x, w) in enumerate(zip(ligne, poids)):
57
+ if x is not None and w.sum() > 0:
58
+ d, _ = scoring.couvertures(x[0], x[1], bas, haut)
59
+ m[c, a] = float(np.sum(w * d) / w.sum())
60
+ return m
61
+
62
+
63
+ def mesurer(m: np.ndarray, ids: list[str], attendus: dict) -> dict:
64
+ hors = [c for c, a in attendus.items() if a is None]
65
+ rangs_rec, rangs_cand, marges = [], [], []
66
+ for c, cibles in attendus.items():
67
+ if cibles is None:
68
+ continue
69
+ cols = [ids.index(a) for a in cibles]
70
+ for a in cols: # sens recruteur
71
+ rangs_rec.append(1 + int(np.sum(m[:, a] > m[c, a])))
72
+ if hors:
73
+ marges.append(float(m[c, a] - max(m[h, a] for h in hors)))
74
+ rangs_cand.append(min(1 + int(np.sum(m[c] > m[c, a])) for a in cols)) # sens candidat
75
+ rr, rc = np.array(rangs_rec), np.array(rangs_cand)
76
+ return {
77
+ "rec_top1": round(float(np.mean(rr == 1)), 3),
78
+ "rec_mrr": round(float(np.mean(1 / rr)), 3),
79
+ "cand_top1": round(float(np.mean(rc == 1)), 3),
80
+ "cand_top3": round(float(np.mean(rc <= 3)), 3),
81
+ "cand_mrr": round(float(np.mean(1 / rc)), 3),
82
+ "marge_min": round(min(marges), 3) if marges else None,
83
+ "faux_positifs": int(sum(x < 0 for x in marges)),
84
+ }
85
+
86
+
87
+ def main():
88
+ cvs = json.loads((RACINE / "exemples/cv_list.json").read_text(encoding="utf-8"))
89
+ print("Chargement des modèles et des AVP (tous, y compris clos)...")
90
+ if config.RERANKER_MODEL:
91
+ from app.reranker import Reranker
92
+ scoring.RERANKER = Reranker(config.RERANKER_MODEL)
93
+ encodeur = Encodeur(config.MODEL_NAME)
94
+ store = AVPStore(encodeur)
95
+ store.charger()
96
+ ids = list(store.prepares)
97
+ attendus = charger_attendus(ids)
98
+
99
+ # Similarités et notes du reranker ne dépendent pas de la rampe : calculées une seule fois
100
+ poids = [store.prepares[i].poids for i in ids]
101
+ sims_cv = []
102
+ for cv in cvs:
103
+ phrases = phrases_du_cv(cv)
104
+ textes = [t for t, _ in phrases]
105
+ vecs = encodeur.encoder(textes) if phrases else None
106
+ rr = scoring.probas_reranker_avps(store.prepares, textes, vecs) if vecs is not None else {}
107
+ sims_cv.append([
108
+ (store.prepares[i].vecs_attendus @ vecs.T, rr.get(i))
109
+ if vecs is not None and len(store.prepares[i].attendus) else None
110
+ for i in ids])
111
+
112
+ n_hors = sum(v is None for v in attendus.values())
113
+ print(f"\n{len(ids)} AVP, {len(cvs)} CV, {len(attendus) - n_hors} avec réponse attendue, "
114
+ f"{n_hors} hors domaine")
115
+ print(f"Reranker : {scoring.RERANKER.nom if scoring.RERANKER else 'aucun (bge-m3 seul)'}\n")
116
+
117
+ bas0, haut0 = scoring.SIM_BAS, scoring.SIM_HAUT
118
+ m0 = matrice(sims_cv, poids, bas0, haut0)
119
+ print(f"Réglage actuel SIM_BAS={bas0} SIM_HAUT={haut0}")
120
+ print(" ", mesurer(m0, ids, attendus))
121
+
122
+ print("\nDétail par CV (réglage actuel) :")
123
+ for c, cv in enumerate(cvs):
124
+ nom = (cv.get("_profil") or f"CV {c}")[:45]
125
+ a = int(np.argmax(m0[c]))
126
+ cibles = attendus.get(c, "ignoré") if c in attendus else "ignoré"
127
+ ok = " " if cibles in ("ignoré", None) else ("✓ " if ids[a] in cibles else "✗ ")
128
+ print(f" {ok}{c:2d} {nom:45s} en tête : {ids[a]:18s} {100 * m0[c, a]:5.1f}/100")
129
+
130
+ # Seuils des libellés : où tombent les bons CV sur leur AVP, et le meilleur hors domaine ?
131
+ bons = sorted(100 * m0[c, ids.index(a)] for c, cib in attendus.items() if cib for a in cib)
132
+ hors = sorted(100 * m0[c].max() for c, cib in attendus.items() if cib is None)
133
+ print("\nRépartition des scores (pour SEUILS_LIBELLE) :")
134
+ print(f" bons CV sur leur AVP : {' '.join(f'{x:.0f}' for x in bons)}")
135
+ print(f" hors domaine, meilleur AVP : {' '.join(f'{x:.0f}' for x in hors)}")
136
+ print(f" avec SEUILS_LIBELLE={config.SEUILS_LIBELLE} :")
137
+ for nom in ("Très bonne adéquation", "Bonne adéquation", "Adéquation partielle",
138
+ "Adéquation faible"):
139
+ nb_bons = sum(scoring.libelle(x / 100) == nom for x in bons)
140
+ nb_hors = sum(scoring.libelle(x / 100) == nom for x in hors)
141
+ print(f" {nom:22s} {nb_bons:2d} bons CV {nb_hors} hors domaine")
142
+
143
+ print("\nRecherche de la meilleure rampe...")
144
+ essais = []
145
+ for bas in np.arange(0.35, 0.61, 0.025):
146
+ for haut in np.arange(bas + 0.10, 0.86, 0.025):
147
+ res = mesurer(matrice(sims_cv, poids, bas, haut), ids, attendus)
148
+ cle = (res["rec_mrr"] + res["cand_mrr"], res["marge_min"] or 0)
149
+ essais.append((cle, round(float(bas), 3), round(float(haut), 3), res))
150
+ essais.sort(key=lambda e: e[0], reverse=True)
151
+ for _, bas, haut, res in essais[:5]:
152
+ print(f" SIM_BAS={bas} SIM_HAUT={haut} -> {res}")
153
+ print("\nReporte le meilleur couple dans app/config.py (ou en variables d'environnement).")
154
+ print("Attention : avec ~20 CV, un écart de MRR inférieur à ~0.05 n'est pas significatif.")
155
+
156
+
157
+ if __name__ == "__main__":
158
+ main()
scripts/graphiques.py ADDED
@@ -0,0 +1,213 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Graphiques PNG à partir des mesures de scripts/mesurer_performances.py.
2
+
3
+ Lancer : python -m scripts.graphiques resultats/<date>
4
+ Produit dans ce dossier :
5
+ 1_temps.png durées GPU vs CPU (échelle logarithmique)
6
+ 2_qualite.png qualité du classement de chaque méthode testée
7
+ 3_repartition.png scores des bons CV et des hors-domaine, seuils des libellés
8
+ 4_carte_scores.png score de chaque CV sur chaque AVP (méthode retenue)
9
+
10
+ Couleurs : palette catégorielle validée (daltonisme compris) - bleu = GPU / bons CV / méthode
11
+ retenue, orange = CPU / hors domaine, gris = méthodes de comparaison.
12
+ """
13
+ import csv
14
+ import json
15
+ import sys
16
+ from pathlib import Path
17
+
18
+ import matplotlib
19
+ import matplotlib.ticker
20
+
21
+ matplotlib.use("Agg")
22
+ import matplotlib.pyplot as plt
23
+ import numpy as np
24
+ from matplotlib.colors import LinearSegmentedColormap
25
+
26
+ DOSSIER = Path(sys.argv[1]) if len(sys.argv) > 1 else sorted(Path("resultats").iterdir())[-1]
27
+
28
+ # Palette de référence (mode clair)
29
+ SURFACE, ENCRE, ENCRE_2, MUET = "#fcfcfb", "#0b0b0b", "#52514e", "#898781"
30
+ GRILLE, AXE = "#e1e0d9", "#c3c2b7"
31
+ BLEU, ORANGE, GRIS = "#2a78d6", "#eb6834", "#c3c2b7"
32
+ RAMPE_BLEUE = ["#fcfcfb", "#cde2fb", "#9ec5f4", "#6da7ec", "#3987e5", "#256abf", "#184f95", "#0d366b"]
33
+
34
+ plt.rcParams.update({
35
+ "font.family": ["Segoe UI", "DejaVu Sans"], "font.size": 10,
36
+ "figure.facecolor": SURFACE, "axes.facecolor": SURFACE, "savefig.facecolor": SURFACE,
37
+ "text.color": ENCRE, "axes.labelcolor": ENCRE_2, "xtick.color": MUET, "ytick.color": ENCRE_2,
38
+ "axes.edgecolor": AXE, "axes.linewidth": 0.8, "grid.color": GRILLE, "grid.linewidth": 0.8,
39
+ "axes.spines.top": False, "axes.spines.right": False, "axes.titleweight": "bold",
40
+ "axes.titlesize": 12, "axes.titlelocation": "left", "axes.titlepad": 12,
41
+ })
42
+
43
+
44
+ def lire(nom):
45
+ f = DOSSIER / nom
46
+ return json.loads(f.read_text(encoding="utf-8")) if f.exists() else None
47
+
48
+
49
+ def sauver(fig, nom):
50
+ fig.savefig(DOSSIER / nom, dpi=160, bbox_inches="tight")
51
+ plt.close(fig)
52
+ print(f" -> {DOSSIER / nom}")
53
+
54
+
55
+ def duree(x: float) -> str:
56
+ texte = f"{x:.2f} s" if x < 1 else (f"{x:.1f} s" if x < 60 else f"{x / 60:.1f} min")
57
+ return texte.replace(".", ",")
58
+
59
+
60
+ # ---------- 1. Durées GPU vs CPU ----------
61
+ def graphique_temps():
62
+ gpu, cpu = lire("temps_gpu.json"), lire("temps_cpu.json")
63
+ if not gpu:
64
+ return
65
+ mediane = lambda t, cle, mode: (np.median([v["mediane_s"] for v in t[cle][mode].values()])
66
+ if t and t[cle].get(mode) else None)
67
+ classe = lambda t, mode: (t["classement_23_cv"][mode]["mediane_s"]
68
+ if t and t["classement_23_cv"].get(mode) else None)
69
+ lignes = [
70
+ ("Démarrage : encodage des 24 AVP", lambda t: t and t["encodage_avps_s"]),
71
+ ("/match sans reranker", lambda t: mediane(t, "match", "sans_reranker")),
72
+ ("/match avec reranker", lambda t: mediane(t, "match", "avec_reranker")),
73
+ ("Classer 23 CV sans reranker", lambda t: classe(t, "sans_reranker")),
74
+ ("Classer 23 CV avec reranker", lambda t: classe(t, "avec_reranker")),
75
+ ]
76
+ fig, ax = plt.subplots(figsize=(9, 4.6))
77
+ y = np.arange(len(lignes))
78
+ h = 0.34
79
+ for decal, (t, nom, coul) in zip((-h / 2 - 0.02, h / 2 + 0.02),
80
+ ((gpu, "GPU (RTX 3050)", BLEU), (cpu, "CPU seul", ORANGE))):
81
+ for k, (_, f) in enumerate(lignes):
82
+ v = f(t)
83
+ if v is None:
84
+ if t is cpu and cpu:
85
+ ax.text(0.012, y[k] + decal, "non mesuré (~1 h 30 estimée)", va="center",
86
+ fontsize=8.5, color=MUET)
87
+ continue
88
+ ax.barh(y[k] + decal, v, height=h, color=coul, label=nom if k == 0 else None)
89
+ ax.text(v * 1.15, y[k] + decal, duree(v), va="center", fontsize=8.5, color=ENCRE_2)
90
+ ax.set_xscale("log")
91
+ ax.set_xlim(0.01, 20000)
92
+ graduations = [0.01, 0.1, 1, 10, 60, 600, 3600]
93
+ ax.set_xticks(graduations, ["0,01 s", "0,1 s", "1 s", "10 s", "1 min", "10 min", "1 h"])
94
+ ax.xaxis.set_minor_locator(matplotlib.ticker.NullLocator())
95
+ ax.set_yticks(y, [n for n, _ in lignes])
96
+ ax.set_ylim(len(lignes) - 0.3, -0.6) # inversé, avec de la marge en bas
97
+ ax.tick_params(axis="y", length=0)
98
+ ax.grid(axis="x")
99
+ ax.set_axisbelow(True)
100
+ ax.set_xlabel("Durée (échelle logarithmique)")
101
+ ax.set_title("Vitesse du service : la carte graphique rend le reranker utilisable")
102
+ ax.legend(frameon=False, loc="lower right")
103
+ sauver(fig, "1_temps.png")
104
+
105
+
106
+ # ---------- 2. Qualité du classement par méthode ----------
107
+ def graphique_qualite():
108
+ q = lire("qualite.json")
109
+ if not q:
110
+ return
111
+ methodes = q["methodes"]
112
+ mesures = [("cand_top1", "Candidat : bon AVP classé 1er"),
113
+ ("cand_top3", "Candidat : bon AVP dans le top 3"),
114
+ ("rec_top1", "Recruteur : bon CV classé 1er")]
115
+ fig, axes = plt.subplots(1, 3, figsize=(12, 3.9), sharey=True)
116
+ y = np.arange(len(methodes))
117
+ for ax, (cle, titre) in zip(axes, mesures):
118
+ for k, m in enumerate(methodes):
119
+ retenu = "retenu" in m["methode"]
120
+ v = 100 * m[cle]
121
+ ax.barh(y[k], v, height=0.62, color=BLEU if retenu else GRIS)
122
+ ax.text(v + 1.5, y[k], f"{v:.0f} %", va="center", fontsize=8.5,
123
+ color=ENCRE if retenu else ENCRE_2, fontweight="bold" if retenu else None)
124
+ ax.set_xlim(0, 112)
125
+ ax.set_xticks([0, 50, 100], ["0 %", "50 %", "100 %"])
126
+ ax.set_title(titre, fontsize=10, fontweight="normal", color=ENCRE)
127
+ ax.grid(axis="x")
128
+ ax.set_axisbelow(True)
129
+ ax.tick_params(axis="y", length=0)
130
+ etiquettes = [m["methode"] + (f" ⚠ {m['faux_positifs']} faux positif" if m["faux_positifs"] else "")
131
+ for m in methodes]
132
+ axes[0].set_yticks(y, etiquettes)
133
+ axes[0].invert_yaxis()
134
+ fig.suptitle(f"Qualité du classement ({q['nb_cv_etiquetes']} CV étiquetés, "
135
+ f"{q['nb_hors_domaine']} hors domaine, 24 AVP)", x=0.01, ha="left",
136
+ fontweight="bold", fontsize=12)
137
+ fig.text(0.01, -0.03, "Bleu : méthode retenue. Avec 14 CV, un écart d'un CV (~7 points) "
138
+ "n'est pas significatif.", fontsize=8.5, color=MUET)
139
+ fig.tight_layout()
140
+ sauver(fig, "2_qualite.png")
141
+
142
+
143
+ # ---------- 3. Répartition des scores et libellés ----------
144
+ def graphique_repartition():
145
+ r = lire("repartition.json")
146
+ if not r:
147
+ return
148
+ s_tb, s_b, s_p = r["seuils_libelle"]
149
+ bons = [x["score"] for x in r["bons_cv_sur_leur_avp"]]
150
+ hors = [x["score"] for x in r["hors_domaine_meilleur_avp"]]
151
+ xmax = max(bons + hors) * 1.15
152
+ fig, ax = plt.subplots(figsize=(9, 3.4))
153
+ bandes = [(0, s_p, "Faible"), (s_p, s_b, "Partielle"), (s_b, s_tb, "Bonne"),
154
+ (s_tb, xmax, "Très bonne")]
155
+ for k, (a, b, nom) in enumerate(bandes):
156
+ if k:
157
+ ax.axvline(a, color=AXE, linewidth=0.8)
158
+ ax.text((a + b) / 2, 2.05, nom, ha="center", fontsize=9, color=ENCRE_2)
159
+ rng = np.random.default_rng(0)
160
+ for valeurs, yb, coul, nom in ((bons, 1.2, BLEU, "Bons CV, sur leur AVP"),
161
+ (hors, 0.4, ORANGE, "Hors domaine, sur leur meilleur AVP")):
162
+ ax.scatter(valeurs, yb + rng.uniform(-0.18, 0.18, len(valeurs)), s=60, color=coul,
163
+ edgecolors=SURFACE, linewidths=2, zorder=3, label=nom)
164
+ ax.set_xlim(0, xmax)
165
+ ax.set_ylim(0, 2.3)
166
+ ax.set_yticks([1.2, 0.4], ["Bons CV", "Hors domaine"])
167
+ ax.tick_params(axis="y", length=0)
168
+ ax.spines["left"].set_visible(False)
169
+ ax.set_xlabel("Score /100 (méthode retenue)")
170
+ ax.set_title(f"Libellés : seuils {s_p} / {s_b} / {s_tb} - aucun hors-domaine au-dessus de « Faible »")
171
+ sauver(fig, "3_repartition.png")
172
+
173
+
174
+ # ---------- 4. Carte des scores CV x AVP ----------
175
+ def graphique_carte():
176
+ f = DOSSIER / "scores_cv_avp.csv"
177
+ if not f.exists():
178
+ return
179
+ with open(f, encoding="utf-8-sig") as fh:
180
+ lignes = list(csv.reader(fh, delimiter=";"))
181
+ ids = lignes[0][3:]
182
+ data = lignes[1:]
183
+ m = np.array([[float(x) for x in l[3:]] for l in data])
184
+ fig, ax = plt.subplots(figsize=(12, 8.2))
185
+ cmap = LinearSegmentedColormap.from_list("bleu", RAMPE_BLEUE)
186
+ im = ax.imshow(m, cmap=cmap, vmin=0, vmax=max(50, m.max()), aspect="auto")
187
+ for c, l in enumerate(data):
188
+ for cible in l[2].split("|"):
189
+ if cible in ids:
190
+ a = ids.index(cible)
191
+ ax.add_patch(plt.Rectangle((a - 0.5, c - 0.5), 1, 1, fill=False,
192
+ edgecolor=ORANGE, linewidth=2))
193
+ ax.set_xticks(range(len(ids)), [i.replace("3134-26-", "").replace("/SR", "") for i in ids],
194
+ rotation=90, fontsize=8)
195
+ ax.set_yticks(range(len(data)), [f"{l[0]} {l[1].split('(')[0].strip()[:42]}" for l in data],
196
+ fontsize=8)
197
+ ax.tick_params(length=0)
198
+ for s in ax.spines.values():
199
+ s.set_visible(False)
200
+ ax.set_xlabel("AVP (numéro 3134-26-…)")
201
+ ax.set_title("Score de chaque CV sur chaque AVP - encadré orange : le bon AVP attendu")
202
+ cb = fig.colorbar(im, ax=ax, fraction=0.025, pad=0.01)
203
+ cb.set_label("Score /100")
204
+ cb.outline.set_visible(False)
205
+ sauver(fig, "4_carte_scores.png")
206
+
207
+
208
+ if __name__ == "__main__":
209
+ print(f"Graphiques dans {DOSSIER}")
210
+ graphique_temps()
211
+ graphique_qualite()
212
+ graphique_repartition()
213
+ graphique_carte()
scripts/inspecter_avp.py ADDED
@@ -0,0 +1,15 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from huggingface_hub import hf_hub_download
2
+ import json
3
+ from app.avp_store import competences_avp
4
+
5
+ chemin = hf_hub_download("opt-nc/odata-avps", "data/all_avps.jsonl", repo_type="dataset")
6
+
7
+ with open(chemin, encoding="utf-8") as f:
8
+ for ligne in f:
9
+ avp = json.loads(ligne)
10
+ if avp.get("id_avp") == "3134-26-1382/SR":
11
+ comps = competences_avp(avp)
12
+ print(f"Nb compétences : {len(comps)}")
13
+ for c in comps:
14
+ print(f" - {c}")
15
+ break
scripts/inspecter_dataset.py ADDED
@@ -0,0 +1,35 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Affiche la structure réelle du dataset opt-nc/odata-avps, sans rien modifier.
2
+
3
+ Lancer depuis la racine du projet : python -m scripts.inspecter_dataset
4
+ """
5
+ from collections import Counter
6
+ from datetime import date
7
+
8
+ from huggingface_hub import list_repo_files
9
+
10
+ from app import config
11
+ from app.avp_store import CHAMPS_ATTENDUS, CHAMPS_PREREQUIS, est_ouvert, extraire, lire_avps
12
+
13
+ print("=== Fichiers du dataset ===")
14
+ print("\n".join(f for f in list_repo_files(config.DATASET_REPO, repo_type="dataset")
15
+ if not f.startswith("data/20"))) # l'archive data/AAAA/MM/ est masquée
16
+
17
+ avps = lire_avps()
18
+ ouverts = [a for a in avps if est_ouvert(a)]
19
+ print(f"\n=== {len(avps)} AVP, dont {len(ouverts)} ouverts au {date.today()} ===")
20
+ for a in sorted(avps, key=lambda a: str(a.get("validThrough"))):
21
+ print(f" {str(a.get('id_avp')):18s} {str(a.get('validThrough'))[:10]:10s} "
22
+ f"{'ouvert' if est_ouvert(a) else 'clos '} {a.get('title') or a.get('name')}")
23
+
24
+ print("\n=== Nombre d'attendus notés par AVP ===")
25
+ nb = [len(extraire(a, CHAMPS_ATTENDUS)) for a in avps]
26
+ print(f" min {min(nb, default=0)} · moyenne {sum(nb) / max(len(nb), 1):.0f} · max {max(nb, default=0)}")
27
+
28
+ print("\n=== Compétences les plus fréquentes (texte identique) ===")
29
+ compte = Counter(t for a in avps for t, _ in extraire(a, CHAMPS_ATTENDUS))
30
+ for texte, n in compte.most_common(10):
31
+ print(f" {n:3d} AVP {texte}")
32
+
33
+ print("\n=== Prérequis rencontrés (jamais notés) ===")
34
+ for texte, n in Counter(t for a in avps for t, _ in extraire(a, CHAMPS_PREREQUIS)).most_common(10):
35
+ print(f" {n:3d} AVP {texte}")
scripts/mesurer_performances.py ADDED
@@ -0,0 +1,238 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Mesure la qualité du classement et la vitesse du service, et garde des traces.
2
+
3
+ Écrit dans resultats/<date>/ :
4
+ machine_<device>.json la machine et les versions (GPU, pilote, torch...) + pip_freeze.txt
5
+ qualite.json mesures de classement de chaque méthode testée (GPU seulement)
6
+ scores_cv_avp.csv score de chaque CV sur chaque AVP, méthode retenue (GPU seulement)
7
+ repartition.json scores des bons CV et des hors-domaine, seuils des libellés
8
+ temps_<device>.json durées : démarrage, /match, classement d'un vivier
9
+
10
+ Lancer depuis la racine du projet (le dataset complet : $env:DATASET_REVISION=...) :
11
+ python -m scripts.mesurer_performances --device gpu
12
+ python -m scripts.mesurer_performances --device cpu # carte graphique masquée, ~20 min
13
+ Puis : python -m scripts.graphiques resultats/<date>
14
+ """
15
+ import argparse
16
+ import json
17
+ import os
18
+ import platform
19
+ import statistics
20
+ import subprocess
21
+ import sys
22
+ import time
23
+ from datetime import datetime
24
+ from pathlib import Path
25
+
26
+ parser = argparse.ArgumentParser()
27
+ parser.add_argument("--device", choices=["gpu", "cpu"], default="gpu")
28
+ parser.add_argument("--sortie", default=None, help="dossier (défaut : resultats/<date du jour>)")
29
+ args = parser.parse_args()
30
+ if args.device == "cpu":
31
+ os.environ["CUDA_VISIBLE_DEVICES"] = "-1" # avant l'import de torch
32
+
33
+ import numpy as np
34
+ import torch
35
+
36
+ from app import config, scoring
37
+ from app.avp_store import AVPStore
38
+ from app.classement import classer_candidats
39
+ from app.cv_texte import phrases_du_cv
40
+ from app.encodeur import Encodeur
41
+ from app.matching import matcher
42
+ from scripts.evaluer_classement import charger_attendus, mesurer
43
+
44
+ RACINE = Path(__file__).resolve().parent.parent
45
+ SORTIE = Path(args.sortie) if args.sortie else RACINE / "resultats" / datetime.now().strftime("%Y-%m-%d")
46
+ SORTIE.mkdir(parents=True, exist_ok=True)
47
+ CV_TEST = [0, 6, 16] # auditeur, chef d'agence, facteur
48
+ AVP_VIVIER = "3134-26-1419/SR" # classement des 23 CV pour l'AVP Auditeur
49
+
50
+ # (nom affiché, mode, SIM_BAS, SIM_HAUT) - mode : bge (rampe seule), rr (reranker seul), hyb
51
+ VARIANTES = [
52
+ ("Avant : bge-m3, rampe 0,45/0,70", "bge", 0.45, 0.70),
53
+ ("bge-m3, rampe 0,55/0,75", "bge", 0.55, 0.75),
54
+ ("bge-m3, rampe 0,575/0,775", "bge", 0.575, 0.775),
55
+ ("Reranker seul", "rr", None, None),
56
+ ("Hybride, rampe 0,55/0,75", "hyb", 0.55, 0.75),
57
+ ("Hybride, rampe 0,575/0,775 (retenu)", "hyb", 0.575, 0.775),
58
+ ]
59
+
60
+
61
+ def ecrire(nom: str, donnees) -> None:
62
+ (SORTIE / nom).write_text(json.dumps(donnees, ensure_ascii=False, indent=2), encoding="utf-8")
63
+ print(f" -> {SORTIE / nom}")
64
+
65
+
66
+ def commande(cmd: list[str]) -> str:
67
+ try:
68
+ return subprocess.run(cmd, capture_output=True, text=True, timeout=60).stdout.strip()
69
+ except Exception:
70
+ return ""
71
+
72
+
73
+ def fiche_machine() -> dict:
74
+ import gradio
75
+ import sentence_transformers
76
+ import transformers
77
+ fiche = {
78
+ "date": datetime.now().isoformat(timespec="seconds"),
79
+ "device_demande": args.device,
80
+ "os": platform.platform(),
81
+ "python": platform.python_version(),
82
+ "coeurs_logiques": os.cpu_count(),
83
+ "threads_torch": torch.get_num_threads(),
84
+ "torch": torch.__version__,
85
+ "cuda_disponible": torch.cuda.is_available(),
86
+ "transformers": transformers.__version__,
87
+ "sentence_transformers": sentence_transformers.__version__,
88
+ "gradio": gradio.__version__,
89
+ "modele": config.MODEL_NAME,
90
+ "reranker": config.RERANKER_MODEL or None,
91
+ "dataset": config.DATASET_REPO,
92
+ "dataset_revision": config.DATASET_REVISION,
93
+ "rampe": [scoring.SIM_BAS, scoring.SIM_HAUT],
94
+ "seuils_libelle": config.SEUILS_LIBELLE,
95
+ }
96
+ if platform.system() == "Windows":
97
+ fiche["processeur"] = commande(["powershell", "-NoProfile", "-Command",
98
+ "(Get-CimInstance Win32_Processor).Name"])
99
+ ram = commande(["powershell", "-NoProfile", "-Command",
100
+ "(Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory"])
101
+ fiche["ram_go"] = round(int(ram) / 2**30, 1) if ram.isdigit() else None
102
+ else:
103
+ fiche["processeur"] = platform.processor()
104
+ if torch.cuda.is_available():
105
+ fiche["gpu"] = torch.cuda.get_device_name(0)
106
+ fiche["gpu_vram_go"] = round(torch.cuda.get_device_properties(0).total_memory / 2**30, 1)
107
+ fiche["cuda_torch"] = torch.version.cuda
108
+ fiche["pilote_nvidia"] = commande(["nvidia-smi", "--query-gpu=driver_version",
109
+ "--format=csv,noheader"])
110
+ (SORTIE / "pip_freeze.txt").write_text(
111
+ commande([sys.executable, "-m", "pip", "freeze"]), encoding="utf-8")
112
+ return fiche
113
+
114
+
115
+ def chrono(f, n: int = 3) -> dict:
116
+ """Durée médiane de n appels (après un appel de chauffe fait par l'appelant)."""
117
+ durees = []
118
+ for _ in range(n):
119
+ t = time.perf_counter()
120
+ f()
121
+ if torch.cuda.is_available():
122
+ torch.cuda.synchronize()
123
+ durees.append(time.perf_counter() - t)
124
+ return {"mediane_s": round(statistics.median(durees), 3), "essais_s": [round(d, 3) for d in durees]}
125
+
126
+
127
+ def matrice_variante(sims_cv, poids, mode, bas, haut) -> np.ndarray:
128
+ m = np.zeros((len(sims_cv), len(poids)))
129
+ for c, ligne in enumerate(sims_cv):
130
+ for a, (x, w) in enumerate(zip(ligne, poids)):
131
+ if x is None or w.sum() <= 0:
132
+ continue
133
+ sims, rr = x
134
+ if mode == "rr":
135
+ d = rr[0]
136
+ else:
137
+ d, _ = scoring.couvertures(sims, rr if mode == "hyb" else None, bas, haut)
138
+ m[c, a] = float(np.sum(w * d) / w.sum())
139
+ return m
140
+
141
+
142
+ def main():
143
+ print(f"Sortie : {SORTIE}")
144
+ fiche = fiche_machine()
145
+ ecrire(f"machine_{args.device}.json", fiche)
146
+ print(f"Machine : {fiche.get('processeur')} | GPU : {fiche.get('gpu', 'aucun')} | torch {fiche['torch']}")
147
+
148
+ temps = {"device": args.device}
149
+ cvs = json.loads((RACINE / "exemples/cv_list.json").read_text(encoding="utf-8"))
150
+
151
+ # 1. Démarrage du service : chargement des modèles, puis encodage des AVP
152
+ t = time.perf_counter()
153
+ from app.reranker import Reranker
154
+ reranker = Reranker(config.RERANKER_MODEL)
155
+ encodeur = Encodeur(config.MODEL_NAME)
156
+ temps["chargement_modeles_s"] = round(time.perf_counter() - t, 1)
157
+ t = time.perf_counter()
158
+ store = AVPStore(encodeur)
159
+ store.charger()
160
+ temps["encodage_avps_s"] = round(time.perf_counter() - t, 1)
161
+ temps["nb_avps"] = len(store.prepares)
162
+ print(f"Démarrage : modèles {temps['chargement_modeles_s']} s, "
163
+ f"{temps['nb_avps']} AVP {temps['encodage_avps_s']} s")
164
+
165
+ # 2. /match (côté candidat), sans puis avec reranker
166
+ temps["match"] = {}
167
+ for nom, rr in (("sans_reranker", None), ("avec_reranker", reranker)):
168
+ scoring.RERANKER = rr
169
+ appel = lambda i: matcher(cvs[i], store, encodeur, config.SEUIL_COUVERTURE,
170
+ top=5, inclure_fermes=True)
171
+ appel(CV_TEST[0]) # chauffe
172
+ n = 3 if (rr is None or args.device == "gpu") else 1 # CPU + reranker : ~4 min/appel
173
+ temps["match"][nom] = {str(i): chrono(lambda: appel(i), n) for i in CV_TEST}
174
+ meds = [v["mediane_s"] for v in temps["match"][nom].values()]
175
+ print(f" /match {nom:14s} : {', '.join(f'{x:.2f} s' for x in meds)}")
176
+
177
+ # 3. Classement d'un vivier de 23 CV pour un AVP (côté recruteur)
178
+ temps["classement_23_cv"] = {}
179
+ for nom, rr in (("sans_reranker", None), ("avec_reranker", reranker)):
180
+ if rr is not None and args.device == "cpu":
181
+ temps["classement_23_cv"][nom] = None # ~23 x 4 min : non mesuré
182
+ continue
183
+ scoring.RERANKER = rr
184
+ temps["classement_23_cv"][nom] = chrono(
185
+ lambda: classer_candidats(AVP_VIVIER, cvs, store, encodeur,
186
+ seuil=config.SEUIL_COUVERTURE, top=23), n=1)
187
+ print(f" classement 23 CV {nom:14s} : {temps['classement_23_cv'][nom]['mediane_s']:.1f} s")
188
+ ecrire(f"temps_{args.device}.json", temps)
189
+
190
+ if args.device == "cpu":
191
+ return
192
+
193
+ # 4. Qualité du classement de chaque méthode (mêmes mesures que evaluer_classement)
194
+ scoring.RERANKER = reranker
195
+ ids = list(store.prepares)
196
+ attendus = charger_attendus(ids)
197
+ poids = [store.prepares[i].poids for i in ids]
198
+ sims_cv = []
199
+ for cv in cvs:
200
+ textes = [t for t, _ in phrases_du_cv(cv)]
201
+ vecs = encodeur.encoder(textes) if textes else None
202
+ rr = scoring.probas_reranker_avps(store.prepares, textes, vecs) if vecs is not None else {}
203
+ sims_cv.append([(store.prepares[i].vecs_attendus @ vecs.T, rr.get(i))
204
+ if vecs is not None and len(store.prepares[i].attendus) else None
205
+ for i in ids])
206
+ qualite = []
207
+ for nom, mode, bas, haut in VARIANTES:
208
+ m = matrice_variante(sims_cv, poids, mode, bas, haut)
209
+ qualite.append({"methode": nom, "mode": mode, "sim_bas": bas, "sim_haut": haut,
210
+ **mesurer(m, ids, attendus)})
211
+ print(f" {nom:38s} {qualite[-1]}")
212
+ ecrire("qualite.json", {"nb_cv_etiquetes": sum(v is not None for v in attendus.values()),
213
+ "nb_hors_domaine": sum(v is None for v in attendus.values()),
214
+ "methodes": qualite})
215
+
216
+ # 5. Méthode retenue : matrice complète CV x AVP et répartition des scores
217
+ m = matrice_variante(sims_cv, poids, "hyb", scoring.SIM_BAS, scoring.SIM_HAUT)
218
+ lignes = ["cv;profil;attendu;" + ";".join(ids)]
219
+ for c, cv in enumerate(cvs):
220
+ cible = attendus.get(c, "ignore") if c in attendus else "ignore"
221
+ cible = "hors_domaine" if cible is None else ("ignore" if cible == "ignore" else "|".join(cible))
222
+ lignes.append(f"{c};{cv.get('_profil', '')};{cible};" +
223
+ ";".join(f"{100 * x:.1f}" for x in m[c]))
224
+ (SORTIE / "scores_cv_avp.csv").write_text("\n".join(lignes), encoding="utf-8-sig")
225
+ print(f" -> {SORTIE / 'scores_cv_avp.csv'}")
226
+
227
+ bons = [{"cv": c, "profil": cvs[c].get("_profil"), "avp": a, "score": round(100 * m[c, ids.index(a)], 1),
228
+ "libelle": scoring.libelle(m[c, ids.index(a)])}
229
+ for c, cib in attendus.items() if cib for a in cib]
230
+ hors = [{"cv": c, "profil": cvs[c].get("_profil"), "avp": ids[int(m[c].argmax())],
231
+ "score": round(100 * m[c].max(), 1), "libelle": scoring.libelle(m[c].max())}
232
+ for c, cib in attendus.items() if cib is None]
233
+ ecrire("repartition.json", {"seuils_libelle": config.SEUILS_LIBELLE,
234
+ "bons_cv_sur_leur_avp": bons, "hors_domaine_meilleur_avp": hors})
235
+
236
+
237
+ if __name__ == "__main__":
238
+ main()
scripts/test.py ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from huggingface_hub import hf_hub_download
2
+ import json
3
+
4
+ chemin = hf_hub_download(
5
+ "opt-nc/odata-avps",
6
+ "data/all_avps.jsonl",
7
+ repo_type="dataset"
8
+ )
9
+
10
+ with open(chemin, encoding="utf-8") as f:
11
+ avp = json.loads(f.readline())
12
+
13
+ champs = [
14
+ "id_avp", "title", "description",
15
+ "skills", "responsibilities",
16
+ "educationRequirements", "experienceRequirements",
17
+ "qualifications", "occupationalCategory",
18
+ "relevantOccupation", "additionalType", "md5_hash"
19
+ ]
20
+
21
+ for champ in champs:
22
+ valeur = avp.get(champ)
23
+ print(f"\n=== {champ} ===")
24
+ print(json.dumps(valeur, ensure_ascii=False, indent=2))
scripts/test_correlation.py ADDED
@@ -0,0 +1,184 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Test de corrélation entre score_qualite et score_couverture, sur 3 CV types.
3
+ Produit aussi scores_bruts.json avec les détails par compétence.
4
+
5
+ Lance depuis la racine du projet (venv actif) :
6
+ python -m scripts.test_correlation
7
+
8
+ Depuis la version 0.2, score_qualite est la moyenne PONDÉRÉE des degrés de couverture
9
+ (poids = champ x rareté de la compétence parmi les AVP) et score_couverture la part
10
+ pondérée des attendus au-dessus de SEUIL_COUVERTURE. Voir app/scoring.py.
11
+
12
+ Interprétation de la corrélation de Spearman :
13
+ > 0.95 → les deux scores mesurent la même chose, supprimer l'un
14
+ 0.70 – 0.95 → ils divergent sur les cas limites, les deux sont utiles
15
+ < 0.70 → ils mesurent vraiment des choses différentes, garder les deux
16
+
17
+ Lis TOUJOURS p_value avec la corrélation :
18
+ p < 0.05 → corrélation statistiquement significative
19
+ p > 0.05 → pas assez de points pour conclure
20
+ """
21
+ import json
22
+ from pathlib import Path
23
+ from scipy.stats import spearmanr
24
+
25
+ from app import config
26
+ from app.avp_store import AVPStore
27
+ from app.encodeur import Encodeur
28
+ from app.matching import matcher
29
+
30
+ CVS = {
31
+ "Très spécialisé (juriste RH)": {
32
+ "basics": {
33
+ "label": "Juriste spécialisé en droit social",
34
+ "summary": "8 ans en cabinet RH, contentieux social et procédures disciplinaires.",
35
+ },
36
+ "work": [{
37
+ "position": "Juriste RH senior",
38
+ "name": "Cabinet juridique fictif",
39
+ "summary": "Conseil juridique et contentieux en droit du travail.",
40
+ "highlights": [
41
+ "Rédaction de 200+ actes juridiques et notes de droit social",
42
+ "Pilotage des procédures disciplinaires et licenciements",
43
+ "Veille réglementaire sur le statut de la fonction publique",
44
+ "Formation des managers aux obligations légales RH",
45
+ ],
46
+ }],
47
+ "skills": [{"name": "Droit", "keywords": [
48
+ "droit du travail", "contentieux social", "procédures disciplinaires",
49
+ "statut fonction publique", "rédaction juridique",
50
+ ]}],
51
+ },
52
+
53
+ "Généraliste RH": {
54
+ "basics": {
55
+ "label": "Responsable RH généraliste",
56
+ "summary": "5 ans en entreprise, multi-domaines RH.",
57
+ },
58
+ "work": [{
59
+ "position": "RRH",
60
+ "name": "Entreprise fictive",
61
+ "summary": "Gestion complète des ressources humaines.",
62
+ "highlights": [
63
+ "Recrutement et intégration des collaborateurs",
64
+ "Gestion de la paie et des avantages sociaux",
65
+ "Mise en place des plans de formation",
66
+ "Administration du personnel et suivi des contrats",
67
+ ],
68
+ }],
69
+ "skills": [{"name": "RH", "keywords": [
70
+ "recrutement", "paie", "formation", "gestion administrative",
71
+ ]}],
72
+ },
73
+
74
+ "Hors domaine (comptable)": {
75
+ "basics": {
76
+ "label": "Comptable",
77
+ "summary": "3 ans en cabinet d'expertise comptable.",
78
+ },
79
+ "work": [{
80
+ "position": "Comptable",
81
+ "name": "Cabinet comptable fictif",
82
+ "summary": "Tenue de la comptabilité et préparation des bilans.",
83
+ "highlights": [
84
+ "Saisie et contrôle des écritures comptables",
85
+ "Élaboration des budgets prévisionnels",
86
+ "Rapprochements bancaires et clôtures mensuelles",
87
+ ],
88
+ }],
89
+ "skills": [{"name": "Comptabilité", "keywords": [
90
+ "comptabilité générale", "Excel", "gestion budgétaire", "bilan",
91
+ ]}],
92
+ },
93
+ }
94
+
95
+ # ── Chargement ─────────────────────────────────────────────────────────────────
96
+ print("Chargement du modèle et des AVP...")
97
+ encodeur = Encodeur(config.MODEL_NAME)
98
+ store = AVPStore(encodeur)
99
+ store.charger()
100
+ print(f"{len(store.avps)} AVP chargés.\n")
101
+
102
+ # ── Un seul appel matcher() par CV ────────────────────────────────────────────
103
+ tous_les_scores = {}
104
+
105
+ for nom_cv, cv in CVS.items():
106
+ print(f"{'='*60}")
107
+ print(f"CV : {nom_cv}")
108
+ print(f"{'='*60}")
109
+
110
+ # Un seul appel : on réutilise reponse partout dans cette itération
111
+ reponse = matcher(cv, store, encodeur, config.SEUIL_COUVERTURE, top=100,
112
+ inclure_fermes=True)
113
+
114
+ qualite = [r.score_qualite for r in reponse.resultats]
115
+ couverture = [r.score_couverture for r in reponse.resultats]
116
+
117
+ corr, pval = spearmanr(qualite, couverture)
118
+ print(f"Corrélation de Spearman : {corr:.3f} (p={pval:.3f})")
119
+ if pval > 0.05:
120
+ print(f" ⚠ p > 0.05 : {len(qualite)} AVP ne suffisent pas à conclure statistiquement.")
121
+ if corr > 0.95:
122
+ print(" → Les deux scores mesurent la même chose. Envisager d'en supprimer un.")
123
+ elif corr > 0.70:
124
+ print(" → Ils divergent sur les cas limites. Les deux sont utiles.")
125
+ else:
126
+ print(" → Ils mesurent des choses vraiment différentes. Garder les deux.")
127
+
128
+ print(f"\nTop 5 par score_qualite :")
129
+ triés_q = sorted(reponse.resultats, key=lambda r: r.score_qualite, reverse=True)
130
+ for r in triés_q[:5]:
131
+ print(f" {r.id_avp} qualite={r.score_qualite:.3f} couverture={r.score_couverture:.2f} {r.titre}")
132
+
133
+ print(f"\nTop 5 par score_couverture :")
134
+ triés_c = sorted(reponse.resultats, key=lambda r: (r.score_couverture, r.score_qualite), reverse=True)
135
+ for r in triés_c[:5]:
136
+ print(f" {r.id_avp} qualite={r.score_qualite:.3f} couverture={r.score_couverture:.2f} {r.titre}")
137
+
138
+ if nom_cv == "Hors domaine (comptable)":
139
+ print(f"\nScore du comptable sur les AVP RH (révélateur) :")
140
+ for r in reponse.resultats:
141
+ if r.titre and ("RH" in r.titre or "ressources humaines" in r.titre.lower()):
142
+ print(f" {r.id_avp} qualite={r.score_qualite:.3f} couverture={r.score_couverture:.2f} {r.titre}")
143
+
144
+ # Sauvegarde complète depuis la même reponse, avec détails par compétence
145
+ tous_les_scores[nom_cv] = [
146
+ {
147
+ "avp_id": r.id_avp,
148
+ "titre": r.titre,
149
+ "score_qualite": r.score_qualite,
150
+ "score_couverture": r.score_couverture,
151
+ "score_global": r.score_global,
152
+ "nb_competences": r.nb_competences,
153
+ # Détails par compétence : indispensables pour calibrer le seuil.
154
+ # On sait quelle compétence est juste en dessous du seuil et si
155
+ # elle mériterait d'être couverte.
156
+ "details_competences": [
157
+ {
158
+ "competence": c.attendu,
159
+ "meilleur_score": c.similarite,
160
+ "phrase_cv": c.trouve_dans_cv,
161
+ "source_cv": c.source_cv,
162
+ "couverte": True,
163
+ }
164
+ for c in r.competences_couvertes
165
+ ] + [
166
+ {
167
+ "competence": e.attendu,
168
+ "meilleur_score": e.similarite,
169
+ "phrase_cv": e.plus_proche_dans_cv,
170
+ "source_cv": None,
171
+ "couverte": False,
172
+ }
173
+ for e in r.ecarts
174
+ ],
175
+ }
176
+ for r in reponse.resultats
177
+ ]
178
+ print()
179
+
180
+ # ── Écriture JSON après la boucle ─────────────────────────────────────────────
181
+ out = Path("scores_bruts.json")
182
+ out.write_text(json.dumps(tous_les_scores, ensure_ascii=False, indent=2))
183
+ print(f"Scores détaillés écrits dans {out.resolve()}")
184
+ print("Analyse scores_bruts.json pour calibrer SEUIL_COUVERTURE dans app/config.py")
scripts/test_cvs.py ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import json
2
+ import urllib.request
3
+
4
+ cvs = json.load(open("exemples/cv_list.json", encoding="utf-8"))
5
+
6
+ for cv in cvs:
7
+ profil = cv.pop("_profil")
8
+ data = json.dumps(cv).encode()
9
+ req = urllib.request.Request(
10
+ "http://localhost:8000/match?top=3",
11
+ data=data,
12
+ headers={"Content-Type": "application/json"},
13
+ method="POST"
14
+ )
15
+ try:
16
+ with urllib.request.urlopen(req) as r:
17
+ res = json.loads(r.read())
18
+ print(f"\n{'='*55}")
19
+ print(f"Profil : {profil}")
20
+ for r in res["resultats"][:3]:
21
+ print(f" {r['id_avp']} q={r['score_qualite']:.3f} c={r['score_couverture']:.2f} {r['titre']}")
22
+ except Exception as e:
23
+ print(f"\nErreur sur {profil} : {e}")
24
+ cv["_profil"] = profil
scripts/verifier_embeddings.py ADDED
@@ -0,0 +1,47 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Vérifie que nos vecteurs bge-m3 se comportent comme les vecteurs officiels de l'OPT-NC.
2
+
3
+ On ne peut pas comparer directement un vecteur bge-m3 (1024 dimensions) avec un vecteur
4
+ Google text-embedding-004 (768 dimensions) : ce sont deux espaces différents.
5
+ On compare donc à l'intérieur de chaque espace : pour chaque paire d'AVP, similarité
6
+ selon Google et similarité selon bge-m3 (même recette de champs, cf. issue OPT-NC).
7
+ Corrélation de Spearman élevée = les deux modèles rangent les paires dans le même ordre,
8
+ notre remplacement ne dénature pas la recherche sémantique de l'OPT-NC.
9
+
10
+ Lancer depuis la racine du projet : python -m scripts.verifier_embeddings
11
+ """
12
+ import numpy as np
13
+ import pandas as pd
14
+ from huggingface_hub import hf_hub_download
15
+ from scipy.stats import spearmanr
16
+
17
+ from app import config
18
+ from app.avp_store import AVPStore
19
+ from app.encodeur import Encodeur
20
+
21
+ officiels = pd.read_parquet(
22
+ hf_hub_download(config.DATASET_REPO, "data/all_embeddings.parquet", repo_type="dataset")
23
+ ).set_index("reference")
24
+
25
+ encodeur = Encodeur(config.MODEL_NAME)
26
+ store = AVPStore(encodeur)
27
+ store.charger()
28
+
29
+ ids = sorted(set(officiels.index) & set(store.prepares))
30
+ if len(ids) < 3:
31
+ raise SystemExit(f"Seulement {len(ids)} AVP communs aux deux sources : comparaison impossible.")
32
+
33
+ A = np.array(officiels.loc[ids, "embeddings"].tolist()) # Google, 768 dim.
34
+ B = np.array([store.prepares[i].vec_global for i in ids]) # bge-m3, 1024 dim.
35
+ print(f"{len(ids)} AVP communs · Google {A.shape[1]} dim. · bge-m3 {B.shape[1]} dim.")
36
+
37
+ paires = np.triu_indices(len(ids), k=1) # chaque paire une fois
38
+ rho, p = spearmanr((A @ A.T)[paires], (B @ B.T)[paires])
39
+ print(f"{len(paires[0])} paires d'AVP · Spearman Google vs bge-m3 : {rho:.2f} (p={p:.1e})")
40
+
41
+ # Les 3 voisins les plus proches de quelques AVP, selon chaque modèle
42
+ for k in range(min(3, len(ids))):
43
+ g = [ids[j] for j in np.argsort(-(A @ A[k]))[1:4]]
44
+ b = [ids[j] for j in np.argsort(-(B @ B[k]))[1:4]]
45
+ print(f"\n{store.prepares[ids[k]].titre}")
46
+ print(f" voisins Google : {g}")
47
+ print(f" voisins bge-m3 : {b} ({len(set(g) & set(b))}/3 en commun)")
tests/__init__.py ADDED
File without changes
tests/factices.py ADDED
@@ -0,0 +1,73 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Données et encodeur factices pour tester sans bge-m3 ni réseau.
2
+
3
+ L'encodeur factice (trigrammes de caractères) donne des similarités plus basses que bge-m3 :
4
+ les tests règlent donc leur propre rampe (SIM_BAS, SIM_HAUT). Les AVP reprennent la forme
5
+ et le vocabulaire de vraies lignes du dataset opt-nc/odata-avps ; les CV sont fictifs.
6
+ """
7
+ import hashlib
8
+ import unicodedata
9
+
10
+ import numpy as np
11
+
12
+
13
+ class Encodeur:
14
+ """Encodeur factice : trigrammes de caractères hachés, vecteurs normalisés."""
15
+ nom = "factice-trigrammes"; dimension = 1024; device = "cpu"
16
+ def encoder(self, textes):
17
+ m = np.zeros((len(textes), self.dimension), dtype=np.float32)
18
+ for i, t in enumerate(textes):
19
+ t = unicodedata.normalize("NFKD", t.lower()).encode("ascii", "ignore").decode()
20
+ for mot in t.split():
21
+ mot = f" {mot} "
22
+ for k in range(len(mot) - 2):
23
+ m[i, int(hashlib.md5(mot[k:k+3].encode()).hexdigest(), 16) % self.dimension] += 1
24
+ n = np.linalg.norm(m[i]); m[i] /= n if n else 1
25
+ return m
26
+
27
+
28
+
29
+ SOFT = ["Maîtrise de soi", "Avoir l'esprit d'équipe", "Curiosité intellectuelle",
30
+ "Faire preuve de discrétion", "Aisance relationnelle"]
31
+ def avp(id_, titre, resp, skills, comp, exp=None, qualif="Permis B", fin="2026-12-31T00:00:00", cred=None):
32
+ return {"id_avp": id_, "md5_hash": id_, "title": titre, "description": f"Poste de {titre}.",
33
+ "occupationalCategory": ["Administration"], "responsibilities": resp,
34
+ "skills": skills + SOFT, "educationRequirements": {"competencyRequired": comp, "credentialCategory": cred},
35
+ "experienceRequirements": exp, "qualifications": qualif, "validThrough": fin}
36
+ AVPS = [
37
+ avp("3134-26-1269/SR", "Juriste RH",
38
+ ["Instruire les procédures disciplinaires", "Rédiger les mémoires en défense", "Instruire les contentieux individuels et collectifs"],
39
+ ["Rédiger des actes et notes juridiques", "Analyser des situations complexes et évaluer les risques juridiques"],
40
+ ["Droit du travail et fonction publique", "Gestion des procédures disciplinaires et contentieuses"],
41
+ exp="Expérience dans un service RH d'une administration", cred="Bac+3"),
42
+ avp("3134-26-1268/SR", "Architecte réseaux IP et transport",
43
+ ["Définir l'architecture cible des réseaux IP/MPLS", "Dimensionner un réseau selon les prévisions de trafic"],
44
+ ["Produire des dossiers d'architecture réseau", "Comparer des solutions et challenger les fournisseurs"],
45
+ ["Routage BGP et OSPF, MPLS, VPN", "Transport fibre optique DWDM"],
46
+ exp="Expérience confirmée dans l'ingénierie de réseaux d'opérateurs IP.",
47
+ qualif="Permis B souhaité"),
48
+ avp("3134-26-1270/SR", "Préposé à la distribution à domicile",
49
+ ["Trier le courrier et les colis", "Distribuer le courrier et les colis aux destinataires", "Conduire un scooter en sécurité"],
50
+ ["Maîtriser les délais", "Appliquer une procédure"],
51
+ ["Réglementation postale de la distribution", "Quartiers et secteurs géographiques"],
52
+ qualif="Permis B, A2 + aptitude à la conduite d'un deux roues"),
53
+ avp("3134-26-1267/SR", "Assistant administratif",
54
+ ["Traiter et contrôler les factures fournisseurs", "Saisir les lettres de commande"],
55
+ ["Appliquer les techniques comptables", "Technique des marchés publics"],
56
+ ["Règles et techniques budgétaires"], qualif=None, fin="2026-09-11T00:00:00"),
57
+ ]
58
+ def cv(position, highlights, skills, certs=()):
59
+ return {"basics": {"name": "NE DOIT PAS COMPTER", "email": "x@y.nc"},
60
+ "work": [{"position": position, "highlights": highlights}],
61
+ "skills": [{"name": s} for s in skills], "certificates": [{"name": c} for c in certs]}
62
+ CVS = [
63
+ cv("Juriste en droit social", ["Rédaction de mémoires en défense devant le tribunal administratif",
64
+ "Instruction de procédures disciplinaires", "Analyse des risques juridiques en droit du travail"],
65
+ ["Droit du travail", "Contentieux", "Rédaction juridique", "Esprit d'équipe"], ["Permis B"]),
66
+ cv("Ingénieur réseaux", ["Conception d'architectures IP/MPLS opérateur", "Configuration BGP et OSPF",
67
+ "Dimensionnement réseau et prévisions de trafic"], ["Fibre optique DWDM", "VPN", "Esprit d'équipe"]),
68
+ cv("Facteur", ["Tri et distribution du courrier et des colis", "Tournée en scooter dans le respect des délais"],
69
+ ["Connaissance des quartiers de Dumbéa", "Ponctualité", "Esprit d'équipe"], ["Permis B", "Permis A2"]),
70
+ cv("Cuisinier", ["Préparation des plats chauds", "Gestion des stocks de cuisine"],
71
+ ["Maîtrise de soi", "Avoir l'esprit d'équipe", "Curiosité intellectuelle", "Faire preuve de discrétion", "Aisance relationnelle"]),
72
+ {"basics": {"name": "vide"}},
73
+ ]
tests/test_api.py ADDED
@@ -0,0 +1,77 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Test de l'application complète (API + interface Gradio + MCP), sans bge-m3 ni réseau.
2
+
3
+ On remplace le module app.encodeur (qui charge torch et bge-m3) par l'encodeur factice,
4
+ et la lecture du dataset Hugging Face par des AVP de test. Le démarrage (lifespan),
5
+ toutes les routes et les fonctions de l'interface sont exercés.
6
+
7
+ Lancer depuis la racine du projet : python -m tests.test_api
8
+ """
9
+ import json
10
+ import sys
11
+ import types
12
+
13
+ from tests import factices
14
+
15
+ # 1. Encodeur factice à la place de bge-m3 (avant d'importer app.main)
16
+ faux_module = types.ModuleType("app.encodeur")
17
+ faux_module.Encodeur = lambda nom: factices.Encodeur()
18
+ sys.modules["app.encodeur"] = faux_module
19
+
20
+ from app import avp_store, config, interface, scoring # noqa: E402
21
+
22
+ scoring.SIM_BAS, scoring.SIM_HAUT = 0.15, 0.55
23
+ config.RERANKER_MODEL = "" # pas de reranker (ni téléchargement)
24
+ avp_store.lire_avps = lambda: factices.AVPS # pas de téléchargement
25
+
26
+ from fastapi.testclient import TestClient # noqa: E402
27
+
28
+ from app.main import app # noqa: E402
29
+
30
+ with TestClient(app) as client: # "with" déclenche le démarrage (lifespan)
31
+ h = client.get("/health").json()
32
+ print("health:", h)
33
+ assert h["nb_avps"] == 4 and h["nb_avps_ouverts"] == 3
34
+
35
+ avps = client.get("/avps").json()
36
+ assert {a["id_avp"] for a in avps} >= {"3134-26-1269/SR"}
37
+ assert next(a for a in avps if a["id_avp"] == "3134-26-1267/SR")["ouvert"] is False
38
+
39
+ juriste = factices.CVS[0]
40
+ r = client.post("/match?top=3", json=juriste)
41
+ assert r.status_code == 200, r.text
42
+ res = r.json()["resultats"]
43
+ print("match:", [(x["titre"], x["score_qualite"], x["ouvert"]) for x in res])
44
+ assert res[0]["id_avp"] == "3134-26-1269/SR" and res[0]["date_limite"] == "2026-12-31"
45
+ assert res[0]["libelle"] and res[0]["nb_savoir_faire"] == res[0]["nb_competences"] - 5
46
+ assert len(res[0]["savoir_etre"]) == 5 and h["reranker"] is None
47
+ assert len(client.post("/match?inclure_fermes=true", json=juriste).json()["resultats"]) == 4
48
+ assert client.post("/match", json={"basics": {"name": "x"}}).status_code == 422
49
+
50
+ r = client.post("/avps/3134-26-1268/SR/candidats", json={"cvs": factices.CVS})
51
+ assert r.status_code == 200, r.text
52
+ assert r.json()["candidats"][0]["index"] == 1
53
+
54
+ assert client.get("/docs").status_code == 200
55
+ page = client.get("/")
56
+ assert page.status_code == 200 and "html" in page.headers["content-type"], page.status_code
57
+ print("page / :", page.status_code, page.headers["content-type"])
58
+
59
+ # Fonctions de l'interface (celles exposées aussi en MCP)
60
+ md = interface.matcher_cv(json.dumps(juriste), False)
61
+ assert "Juriste RH" in md and "Point fort" in md, md
62
+ assert "illisible" in interface.matcher_cv("{pas du json", False)
63
+ md = interface.classer_vivier("3134-26-1270/SR", json.dumps(factices.CVS))
64
+ assert "| 1 |" in md and "Prérequis" in md, md
65
+ assert "inconnu" in interface.classer_vivier("nope", json.dumps(factices.CVS))
66
+ print(md[:900])
67
+
68
+ # Exemples du projet : 23 CV fictifs chargés, sans le champ _profil (réponse attendue)
69
+ if interface.EXEMPLES:
70
+ assert all("_profil" not in cv for cv in interface.EXEMPLES.values())
71
+ print(f"{len(interface.EXEMPLES)} CV d'exemple chargés dans l'interface")
72
+
73
+ # Serveur MCP monté par Gradio
74
+ routes = [getattr(x, "path", "") for x in app.routes]
75
+ print("routes MCP:", [x for x in routes if "mcp" in x] or "montées sous /", )
76
+
77
+ print("\nTEST API OK")
tests/test_scoring.py ADDED
@@ -0,0 +1,129 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Tests du moteur de score, sans télécharger bge-m3 ni le dataset.
2
+
3
+ On remplace bge-m3 par un encodeur factice (trigrammes de caractères) : les scores
4
+ absolus ne ressemblent pas à ceux de bge-m3, mais la logique (extraction, poids,
5
+ tri, explications, routes) est vérifiée. Lancer : python -m tests.test_scoring
6
+ """
7
+ import numpy as np
8
+
9
+ from app import scoring
10
+ from tests.factices import AVPS, CVS, SOFT, Encodeur
11
+
12
+ # Rampe adaptée à l'encodeur factice (ses similarités sont plus basses que celles de bge-m3)
13
+ scoring.SIM_BAS, scoring.SIM_HAUT = 0.15, 0.55
14
+
15
+ import copy
16
+ from datetime import date
17
+
18
+ from fastapi import FastAPI
19
+ from fastapi.testclient import TestClient
20
+
21
+ from app.avp_store import (AVPStore, CHAMPS_ATTENDUS, est_ouvert, est_savoir_etre, extraire,
22
+ texte_embedding)
23
+ from app.classement import classer_candidats
24
+ from app.matching import matcher
25
+ from app.route_classement import creer_router
26
+
27
+ enc = Encodeur(); store = AVPStore(enc); store.installer(AVPS)
28
+
29
+ # 1. Extraction : contexte exclu des attendus, prérequis séparés, doublon normalisé
30
+ a = extraire({"experienceRequirements": "Expérience X.", "educationRequirements": {"competencyRequired": ["Expérience X"]}}, CHAMPS_ATTENDUS)
31
+ assert len(a) == 1, a
32
+ p = store.prepares["3134-26-1269/SR"]
33
+ assert all(c not in ("title", "description", "qualifications") for _, c in p.attendus)
34
+ assert [t for t, _ in p.prerequis] == ["Permis B", "Bac+3"], p.prerequis
35
+ assert [t for t, _ in store.prepares["3134-26-1270/SR"].prerequis][:2] == ["Permis B", "A2"]
36
+ assert "Permis B" in texte_embedding(AVPS[0])
37
+
38
+ # 2. Spécificité : les soft skills communs aux 4 AVP pèsent moins que les compétences métier
39
+ idx = {t: k for k, (t, _) in enumerate(p.attendus)}
40
+ w_soft = p.poids[idx["Maîtrise de soi"]]; w_metier = p.poids[idx["Droit du travail et fonction publique"]]
41
+ print(f"poids 'Maîtrise de soi' = {w_soft:.3f} vs 'Droit du travail...' = {w_metier:.3f}")
42
+ assert w_soft < 0.2 and w_metier > 0.9 # n=4 AVP : log(5/4)/log(5)=0.14
43
+
44
+ # 3. validThrough
45
+ assert not store.prepares["3134-26-1267/SR"].ouvert
46
+ assert est_ouvert({"validThrough": "2026-10-07T00:00:00"}, date(2026, 10, 7))
47
+
48
+ # 4. Classement côté recruteur
49
+ for id_avp, bon in [("3134-26-1269/SR", 0), ("3134-26-1268/SR", 1), ("3134-26-1270/SR", 2)]:
50
+ r = classer_candidats(id_avp, CVS, store, enc, seuil=0.35)
51
+ ordre = [(c.index, c.score, c.specificite, c.rang_de_cet_avp_pour_le_candidat) for c in r.candidats]
52
+ print(r.titre, "->", ordre, "| écartés:", [e.index for e in r.ecartes])
53
+ assert r.candidats[0].index == bon
54
+ cuisinier = next(c for c in r.candidats if c.index == 3)
55
+ assert cuisinier.score < r.candidats[0].score - 15, "le hors-domaine doit être loin derrière"
56
+ assert r.ecartes[0].index == 4
57
+
58
+ r = classer_candidats("3134-26-1270/SR", CVS, store, enc, seuil=0.35)
59
+ top = r.candidats[0]
60
+ print("forces facteur:", [(f.attendu, f.phrase_cv, f.source_cv) for f in top.forces])
61
+ print("prérequis facteur:", [(x.prerequis, x.statut) for x in top.prerequis])
62
+ print("plus discriminants:", r.attendus_les_plus_discriminants)
63
+
64
+ # 5. Identité jamais utilisée : changer le nom ne change rien
65
+ cv2 = copy.deepcopy(CVS[0]); cv2["basics"]["name"] = "Quelqu'un d'autre"
66
+ s1 = classer_candidats("3134-26-1269/SR", [CVS[0]], store, enc, 0.35).candidats[0].score
67
+ s2 = classer_candidats("3134-26-1269/SR", [cv2], store, enc, 0.35).candidats[0].score
68
+ assert s1 == s2
69
+
70
+ # 6. Côté candidat : schémas existants, AVP fermé exclu par défaut
71
+ rm = matcher(CVS[0], store, enc, seuil=0.35, top=10)
72
+ print("matching juriste:", [(x.titre, x.score_qualite, x.score_global) for x in rm.resultats])
73
+ assert rm.resultats[0].id_avp == "3134-26-1269/SR"
74
+ assert all(x.id_avp != "3134-26-1267/SR" for x in rm.resultats) and rm.nb_avps_analyses == 3
75
+ assert len(matcher(CVS[0], store, enc, 0.35, 10, inclure_fermes=True).resultats) == 4
76
+
77
+ # 7. Route HTTP (id avec "/")
78
+ app = FastAPI(); app.include_router(creer_router(lambda: (store, enc)))
79
+ c = TestClient(app)
80
+ resp = c.post("/avps/3134-26-1268/SR/candidats?top=3", json={"cvs": CVS})
81
+ assert resp.status_code == 200, resp.text
82
+ print("HTTP:", [(x["index"], x["score"], x["ex_aequo_avec_precedent"]) for x in resp.json()["candidats"]])
83
+ assert c.post("/avps/inconnu/candidats", json={"cvs": CVS}).status_code == 404
84
+ assert c.post("/avps/3134-26-1268/SR/candidats", json={"cvs": []}).status_code == 422
85
+
86
+ # 8. Refresh atomique : un AVP qui disparaît sort du cache
87
+ store.installer(AVPS[:3]); assert "3134-26-1267/SR" not in store.prepares and len(store._cache) == 3
88
+
89
+ # 9. Savoir-être : repérés pour l'affichage, mais toujours comptés dans le score
90
+ assert est_savoir_etre("Être rigoureux", "skills") and est_savoir_etre("Autonomie", "skills")
91
+ assert est_savoir_etre("Faire preuve de discrétion", "skills")
92
+ assert not est_savoir_etre("Savoir rédiger", "skills")
93
+ assert not est_savoir_etre("Construire un diagnostic", "skills")
94
+ assert not est_savoir_etre("Autonomie", "responsibilities") # seul le champ skills
95
+ p = store.prepares["3134-26-1270/SR"]
96
+ assert int(p.savoir_etre.sum()) == len(SOFT), [t for (t, _), se in zip(p.attendus, p.savoir_etre) if se]
97
+ rm = matcher(CVS[2], store, enc, seuil=0.35, top=1)
98
+ r0 = rm.resultats[0]
99
+ assert r0.nb_savoir_faire == r0.nb_competences - len(SOFT) and len(r0.savoir_etre) == len(SOFT)
100
+ assert all(c.attendu not in SOFT for c in r0.competences_couvertes + r0.ecarts)
101
+ print("facteur :", r0.libelle, f"{r0.nb_savoir_faire_couverts}/{r0.nb_savoir_faire}",
102
+ [(s.attendu, s.statut) for s in r0.savoir_etre])
103
+
104
+ # 10. Reranker : la couverture d'un attendu est la meilleure des deux notes (rampe, reranker)
105
+ class RerankerFactice:
106
+ nom = "factice"
107
+ def probas(self, paires):
108
+ return np.array([1.0 if "scooter" in a.lower() and "scooter" in b.lower() else 0.0
109
+ for a, b in paires], dtype=np.float32)
110
+
111
+ phrases = [("Facteur", "work[0]"), ("Tournée en deux-roues (scooter)", "work[0].highlights[0]"),
112
+ ("Ponctualité", "skills[0]")] * 2
113
+ vecs = enc.encoder([t for t, _ in phrases])
114
+ sans = scoring.scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs, 0.5)
115
+ assert scoring.probas_reranker_avps({"x": p}, [t for t, _ in phrases], vecs) == {} # pas de reranker
116
+ scoring.RERANKER = RerankerFactice()
117
+ try:
118
+ rr = scoring.probas_reranker_avps(store.prepares, [t for t, _ in phrases], vecs)
119
+ assert set(rr) == set(store.prepares) # un seul appel, tous les AVP
120
+ avec = scoring.scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs, 0.5,
121
+ rr=rr["3134-26-1270/SR"])
122
+ finally:
123
+ scoring.RERANKER = None
124
+ d = next(x for x in avec.details if x.attendu == "Conduire un scooter en sécurité")
125
+ assert d.degre == 1.0 and "scooter" in d.phrase_cv, d
126
+ assert avec.adequation > sans.adequation
127
+ assert all(a.degre >= s.degre for a, s in zip(avec.details, sans.details)) # jamais pire
128
+ print(f"reranker factice : {100 * sans.adequation:.1f} -> {100 * avec.adequation:.1f}")
129
+ print("\nTOUS LES TESTS PASSENT")