Spaces:
Running on Zero
Running on Zero
Matching CV-AVP : score hybride bge-m3 + reranker, ZeroGPU
Browse files- .dockerignore +7 -0
- .gitignore +7 -0
- Dockerfile +26 -0
- README.md +187 -7
- app/__init__.py +0 -0
- app/avp_store.py +305 -0
- app/classement.py +105 -0
- app/config.py +70 -0
- app/cv_texte.py +54 -0
- app/encodeur.py +26 -0
- app/interface.py +251 -0
- app/main.py +117 -0
- app/matching.py +84 -0
- app/reranker.py +36 -0
- app/route_classement.py +27 -0
- app/schemas.py +78 -0
- app/schemas_classement.py +70 -0
- app/scoring.py +246 -0
- app_zerogpu.py +50 -0
- exemples/attendus.json +22 -0
- exemples/cv_juriste_fictif.json +27 -0
- exemples/cv_list.json +877 -0
- requirements-dev.txt +4 -0
- requirements.txt +18 -0
- scripts/__init__.py +0 -0
- scripts/avp.py +19 -0
- scripts/captures.py +50 -0
- scripts/evaluer_classement.py +158 -0
- scripts/graphiques.py +213 -0
- scripts/inspecter_avp.py +15 -0
- scripts/inspecter_dataset.py +35 -0
- scripts/mesurer_performances.py +238 -0
- scripts/test.py +24 -0
- scripts/test_correlation.py +184 -0
- scripts/test_cvs.py +24 -0
- scripts/verifier_embeddings.py +47 -0
- tests/__init__.py +0 -0
- tests/factices.py +73 -0
- tests/test_api.py +77 -0
- tests/test_scoring.py +129 -0
.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:
|
| 3 |
-
emoji:
|
| 4 |
-
colorFrom:
|
| 5 |
-
colorTo:
|
| 6 |
sdk: gradio
|
| 7 |
sdk_version: 6.30.0
|
| 8 |
-
python_version:
|
| 9 |
-
app_file:
|
| 10 |
pinned: false
|
|
|
|
| 11 |
---
|
| 12 |
|
| 13 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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")
|