anonymisation/.kiro/specs/anonymization-quality-optimization/SUMMARY.md

# Résumé Exécutif - Optimisation de la Qualité d'Anonymisation

## Contexte

Vous disposez d'un système d'anonymisation de documents PDF médicaux qui combine **4 couches de détection** :

**1. Extraction multi-passes** : pdfplumber → pdfminer → PyMuPDF → docTR OCR → tesseract

**2. Détection par regex** : EMAIL, TEL, NIR, IBAN, IPP, FINESS, RPPS, OGC, dates, adresses

**3. VLM (Vision Language Model)** : Ollama avec qwen2.5vl:7b pour analyse visuelle des PDF scannés
- Détecte 20+ catégories de PII visuellement (manuscrit, mal orienté)
- Matching flou pour identifiants numériques manuscrits
- Masquage total des pages manuscrites (< 100 mots OCR)

**4. NER** : EDS-Pseudo (AP-HP, F1=0.97) via edsnlp OU CamemBERT-NER ONNX

**5. Consolidation** : Propagation globale + extraction Trackare + rescan sélectif

**Corpus de travail** : 59 dossiers OGC (130 fichiers PDF) dans `/home/dom/Téléchargements/II-1 Ctrl_T2A_2025_CHCB_DocJustificatifs (1)/`

## Problématique

- ❌ Faux négatifs (PII non détectés) → Risque RGPD
- ❌ Faux positifs (termes médicaux masqués) → Documents illisibles
- ❌ VLM peut halluciner sur pages manuscrites complexes
- ❌ Pas de métriques de qualité mesurables
- ❌ Pas de validation post-anonymisation
- ❌ Pas d'optimisation GPU pour VLM (Ollama local)

## Objectifs

**Métriques cibles** :
- Rappel ≥ 99.5% (max 0.5% de PII manqués)
- Précision ≥ 97% (max 3% de faux positifs)
- F1-Score ≥ 0.98
- Temps < 10s par PDF (avec GPU)

**Matériel disponible** :
- CPU : AMD Ryzen 9 9950X (16 cœurs / 32 threads)
- RAM : 128 GB
- GPU : NVIDIA RTX 5070 (12 GB VRAM)
- CUDA : PyTorch 2.10.0 avec support CUDA

## Solution Proposée

### 1. Mesure (2 semaines)

**Créer un dataset de test annoté** :
- Sélectionner 30 documents représentatifs
- Annoter manuellement tous les PII
- Format JSON standardisé

**Implémenter l'évaluation** :
- Évaluateur de qualité (Précision, Rappel, F1)
- Scanner de fuite (détection PII résiduels)
- Benchmark de performance

**Mesurer la baseline** :
- Évaluer le système actuel
- Identifier les faux négatifs/positifs
- Benchmarker les performances

### 2. Amélioration (3 semaines)

**Regex améliorées** :
- Téléphones fragmentés : `06 12 34\n56 78`
- Emails médicaux : `nom@chu-bordeaux.fr`
- Adresses avec compléments : `12 rue X, Bât. B, Appt. 12`
- NIR avec espaces variables
- Noms avec caractères spéciaux : `O'Brien, Müller`

**Détection contextuelle** :
- Noms après "Dr.", "Patient:", etc.
- Noms en MAJUSCULES (hors stopwords médicaux)
- Filtrage des faux positifs

**Approche hybride** :
- Pipeline en 5 étapes : Regex → VLM (si scanné) → EDS-Pseudo → CamemBERT → Contextuel
- Masquage progressif (éviter doublons)
- Fusion intelligente des résultats
- Validation croisée VLM ↔ NER (anti-hallucination)
- Accélération GPU pour NER et optimisation VLM
- Traitement parallèle de plusieurs PDFs (8-12 workers)

### 3. Validation (1 semaine)

**Validation post-anonymisation** :
- Scanner automatique de fuite
- Vérification métadonnées PDF
- Certificat de conformité

**Tests de régression** :
- Suite automatique sur dataset annoté
- Alerte si dégradation des métriques

**Validation corpus complet** :
- Exécution sur les 59 dossiers OGC
- Vérification 0 fuite critique
- Validation manuelle (échantillon)

### 4. Documentation (3 jours)

- Guide d'annotation
- Guide d'évaluation
- Référence API
- Rapports de qualité

## Architecture Cible

```
PDF → Extraction texte → Détection Hybride → Consolidation → Redaction
                         (5 passes + GPU)                      ↓
                                                        Validation Post-Anonymisation
                                                               ↓
                                                        Certificat de Conformité
```

**Détection Hybride** :
1. Regex améliorées (formats structurés)
2. VLM optimisé (Ollama qwen2.5vl:7b) - si PDF scanné
3. EDS-Pseudo (noms, contexte médical) - GPU accéléré
4. CamemBERT-NER (fallback) - GPU accéléré
5. Contextuel (patterns linguistiques)

**Optimisations Performance** :
- Accélération CUDA pour modèles NER
- Batch processing optimisé (12 GB VRAM)
- VLM avec prompt amélioré et validation croisée
- Traitement parallèle multi-PDF (16 cœurs)
- Temps cible : < 10s par PDF (textuel), < 30s (scanné avec VLM)

## Livrables

1. ✅ Dataset annoté (30+ documents)
2. ✅ Système d'évaluation (évaluateur + scanner + benchmark)
3. ✅ Détecteurs améliorés (regex + contextuel + hybride)
4. ✅ Tests de régression automatiques
5. ✅ Rapports de qualité (HTML + JSON)
6. ✅ Documentation complète
7. ✅ Métriques baseline et finales

## Planning

| Phase | Durée | Tâches Principales |
|-------|-------|-------------------|
| **Phase 1 : Mesure** | 2 semaines | Dataset annoté, Évaluation, Baseline |
| **Phase 2 : Amélioration** | 3 semaines | Regex, Contextuel, Hybride, GPU optimization |
| **Phase 3 : Validation** | 1 semaine | Post-validation, Tests, Corpus complet |
| **Phase 4 : Documentation** | 3 jours | Guides, API, Rapports |
| **Total** | **7 semaines** | |

## Prochaines Étapes

### Étape 1 : Sélectionner les Documents de Test

```bash
# Analyser le corpus
cd "/home/dom/Téléchargements/II-1 Ctrl_T2A_2025_CHCB_DocJustificatifs (1)/"
find . -name "*.pdf" | wc -l  # Compter les PDFs

# Sélectionner 30 documents représentatifs
# - 10 simples (1-2 pages, peu de PII)
# - 15 moyens (3-5 pages, PII variés)
# - 5 complexes (>5 pages, nombreux PII)

# Copier dans tests/ground_truth/
mkdir -p tests/ground_truth
# Copier manuellement les 30 PDFs sélectionnés
```

### Étape 2 : Créer l'Outil d'Annotation

```bash
# Créer le fichier
touch tools/annotation_tool.py

# Implémenter l'outil CLI pour annoter les PDFs
# (voir design.md section 2.1.2 pour les spécifications)
```

### Étape 3 : Annoter les Documents

```bash
# Lancer l'outil d'annotation
python tools/annotation_tool.py tests/ground_truth/

# Pour chaque PDF :
# 1. Afficher le texte page par page
# 2. Saisir les PII (type, texte, contexte)
# 3. Lister les termes médicaux à préserver
# 4. Sauvegarder en JSON
```

### Étape 4 : Implémenter l'Évaluateur

```bash
# Créer le fichier
touch evaluation/quality_evaluator.py

# Implémenter :
# - Classe EvaluationResult
# - Classe QualityEvaluator
# - Méthode evaluate()
# - Calcul Précision/Rappel/F1
# - Génération de rapport
```

### Étape 5 : Mesurer la Baseline

```bash
# Anonymiser les 30 documents annotés
python Pseudonymisation_Gui_V5.py  # Ou CLI

# Évaluer
python evaluation/quality_evaluator.py \
  --ground-truth tests/ground_truth/ \
  --output reports/baseline_report.html

# Analyser les résultats
# - Identifier les faux négatifs
# - Identifier les faux positifs
# - Prioriser les améliorations
```

## Points d'Attention

### Annotation Manuelle

⚠️ **Temps estimé** : 30 documents × 1h = 30 heures
- Prévoir 5 jours dédiés
- Possibilité de paralléliser (2 annotateurs)
- Validation croisée recommandée

### Optimisation GPU

✅ **Accélération disponible** : RTX 5070 avec 12 GB VRAM
- EDS-Pseudo et CamemBERT-NER peuvent utiliser CUDA
- Batch processing optimisé pour réduire le temps de traitement
- Objectif : < 10s par PDF (vs 30s en CPU-only)
- Fallback CPU automatique si GPU indisponible

### Traitement Parallèle

✅ **Puissance CPU** : 16 cœurs / 32 threads
- Traitement simultané de 8-12 PDFs
- Speedup significatif sur corpus complet
- Répartition de charge intelligente

### Faux Négatifs Critiques

⚠️ **Priorité RGPD** : 0 faux négatif = objectif
- Scanner de fuite obligatoire
- Validation post-anonymisation en mode strict
- Double vérification manuelle sur échantillon

### Faux Positifs Médicaux

⚠️ **Lisibilité** : Préserver les termes médicaux
- Enrichir la liste des stopwords
- Validation par expert médical
- Ajustement des seuils de confiance

## Critères de Succès

✅ **Qualité** :
- Rappel ≥ 99.5%
- Précision ≥ 97%
- F1-Score ≥ 0.98
- Taux de documents sûrs ≥ 98%

✅ **Performance** :
- Temps < 10s par PDF (avec GPU)
- Temps < 30s par PDF (fallback CPU)
- RAM < 32 GB par processus
- VRAM < 10 GB
- Pas de dégradation > 20% vs baseline

✅ **Livrables** :
- Dataset annoté créé
- Système d'évaluation fonctionnel
- Tests de régression en place
- Documentation complète

✅ **Validation** :
- 0 fuite critique sur corpus complet
- Validation expert médical (échantillon)
- Amélioration mesurable vs baseline

## Ressources

**Documentation** :
- `requirements.md` : Exigences détaillées
- `design.md` : Architecture technique
- `tasks.md` : Plan d'implémentation
- `README.md` : Vue d'ensemble

**Code** :
- `tools/annotation_tool.py` : Outil d'annotation
- `evaluation/quality_evaluator.py` : Évaluateur
- `evaluation/leak_scanner.py` : Scanner de fuite
- `detectors/improved_regex.py` : Regex améliorées
- `detectors/contextual.py` : Détection contextuelle
- `detectors/hybrid.py` : Approche hybride

**Tests** :
- `tests/unit/` : Tests unitaires
- `tests/regression/` : Tests de régression
- `tests/ground_truth/` : Dataset annoté

**Configuration** :
- `config/quality_config.yml` : Configuration qualité

**Rapports** :
- `reports/baseline_report.html` : Rapport baseline
- `reports/final_report.html` : Rapport final
- `reports/comparison.html` : Comparaison avant/après

---

**Prêt à démarrer ?** Commencez par la Phase 1 : Sélection et annotation des 30 documents de test !