# Tasks - Optimisation de la Qualité d'Anonymisation

## Phase 1 : Mesure et Baseline (2 semaines)

### 1.1 Création du Dataset de Test Annoté

- [x] 1.1.1 Sélectionner 30 documents représentatifs des 59 dossiers OGC
  - [x] 1.1.1.1 Analyser la répartition des documents (types, complexité, taille)
  - [x] 1.1.1.2 Sélectionner 10 documents simples (1-2 pages, peu de PII)
  - [x] 1.1.1.3 Sélectionner 15 documents moyens (3-5 pages, PII variés)
  - [x] 1.1.1.4 Sélectionner 5 documents complexes (>5 pages, nombreux PII)
  - [x] 1.1.1.5 Copier les documents dans `tests/ground_truth/`

- [x] 1.1.2 Créer l'outil d'annotation CLI
  - [x] 1.1.2.1 Créer `tools/annotation_tool.py`
  - [x] 1.1.2.2 Implémenter l'extraction et affichage du texte
  - [x] 1.1.2.3 Implémenter la saisie guidée des annotations
  - [x] 1.1.2.4 Implémenter la validation du format JSON
  - [x] 1.1.2.5 Implémenter l'export au format standardisé
  - [x] 1.1.2.6 Ajouter la documentation d'utilisation

- [x] 1.1.3 Annoter les 30 documents sélectionnés
  - [x] 1.1.3.1 Annoter les 10 documents simples
  - [x] 1.1.3.2 Annoter les 15 documents moyens
  - [x] 1.1.3.3 Annoter les 5 documents complexes
  - [x] 1.1.3.4 Valider les annotations (double vérification)
  - [x] 1.1.3.5 Calculer les statistiques du dataset (PII par type, difficulté)

- [-] 1.1.4 Enrichir la liste des stopwords médicaux
  - [x] 1.1.4.1 Extraire les termes médicaux des 30 documents annotés
  - [x] 1.1.4.2 Identifier les faux positifs actuels (termes masqués à tort)
  - [ ] 1.1.4.3 Ajouter les nouveaux termes à `_MEDICAL_STOP_WORDS_SET`
  - [ ] 1.1.4.4 Documenter les sources des stopwords

### 1.2 Système d'Évaluation de la Qualité

- [x] 1.2.1 Implémenter l'évaluateur de qualité
  - [x] 1.2.1.1 Créer `evaluation/quality_evaluator.py`
  - [x] 1.2.1.2 Implémenter la classe `EvaluationResult` (dataclass)
  - [x] 1.2.1.3 Implémenter la classe `QualityEvaluator`
  - [x] 1.2.1.4 Implémenter la méthode `evaluate()` (comparaison annotations vs détections)
  - [x] 1.2.1.5 Implémenter le calcul des métriques (Précision, Rappel, F1)
  - [x] 1.2.1.6 Implémenter l'identification des faux négatifs
  - [x] 1.2.1.7 Implémenter l'identification des faux positifs
  - [x] 1.2.1.8 Implémenter la génération de rapport texte
  - [x] 1.2.1.9 Ajouter les tests unitaires

- [x] 1.2.2 Implémenter le scanner de fuite
  - [x] 1.2.2.1 Créer `evaluation/leak_scanner.py`
  - [x] 1.2.2.2 Implémenter la classe `LeakReport` (dataclass)
  - [x] 1.2.2.3 Implémenter la classe `LeakScanner`
  - [x] 1.2.2.4 Implémenter `scan_text()` (détection PII résiduels)
  - [x] 1.2.2.5 Implémenter `scan_metadata()` (scan métadonnées PDF)
  - [x] 1.2.2.6 Implémenter la classification par sévérité
  - [x] 1.2.2.7 Implémenter la génération de rapport de fuite
  - [x] 1.2.2.8 Ajouter les tests unitaires

- [x] 1.2.3 Implémenter le benchmark de performance
  - [x] 1.2.3.1 Créer `evaluation/benchmark.py`
  - [x] 1.2.3.2 Implémenter la collecte des métriques de temps
  - [x] 1.2.3.3 Implémenter la collecte des métriques CPU/RAM
  - [x] 1.2.3.4 Implémenter la collecte des métriques de qualité
  - [x] 1.2.3.5 Implémenter l'export JSON des résultats
  - [x] 1.2.3.6 Implémenter l'affichage tabulaire des résultats
  - [x] 1.2.3.7 Ajouter les tests unitaires

### 1.3 Mesure de la Baseline

- [x] 1.3.1 Exécuter l'évaluation sur le dataset annoté
  - [x] 1.3.1.1 Anonymiser les 30 documents annotés avec le système actuel
  - [x] 1.3.1.2 Exécuter l'évaluateur sur les 30 documents
  - [x] 1.3.1.3 Générer le rapport de qualité baseline
  - [x] 1.3.1.4 Identifier les faux négatifs critiques
  - [x] 1.3.1.5 Identifier les faux positifs fréquents

- [x] 1.3.2 Exécuter le benchmark de performance
  - [x] 1.3.2.1 Benchmarker le système actuel sur les 30 documents
  - [x] 1.3.2.2 Mesurer le temps de traitement moyen
  - [x] 1.3.2.3 Mesurer l'utilisation CPU/RAM
  - [x] 1.3.2.4 Exporter les résultats baseline

- [x] 1.3.3 Analyser les résultats baseline
  - [x] 1.3.3.1 Analyser les types de PII manqués (faux négatifs)
  - [x] 1.3.3.2 Analyser les types de faux positifs
  - [x] 1.3.3.3 Identifier les patterns problématiques
  - [x] 1.3.3.4 Prioriser les améliorations à implémenter
  - [x] 1.3.3.5 Documenter les findings dans un rapport

---

## Phase 2 : Correction de la Régression de Qualité (3-4 jours) - PRIORITÉ CRITIQUE

### 2.0 Analyse de la Régression (COMPLÉTÉ ✅)

- [x] 2.0.1 Analyser la régression de qualité en production
  - [x] 2.0.1.1 Comparer documents originaux vs anonymisés
  - [x] 2.0.1.2 Identifier les artefacts OCR
  - [x] 2.0.1.3 Identifier les sur-masquages
  - [x] 2.0.1.4 Comparer test dataset vs production
  - [x] 2.0.1.5 Documenter les causes racines

### 2.1 Optimisation OCR (1-2 jours) - CRITIQUE

- [ ] 2.1.1 Optimiser les paramètres docTR
  - [ ] 2.1.1.1 Augmenter la résolution d'entrée (300 → 400 DPI)
  - [ ] 2.1.1.2 Activer le post-traitement docTR
  - [ ] 2.1.1.3 Tester différentes configurations sur 10 documents scannés
  - [ ] 2.1.1.4 Mesurer le taux d'artefacts OCR (cible: <5%)

- [ ] 2.1.2 Implémenter le nettoyage des artefacts OCR
  - [ ] 2.1.2.1 Créer `detectors/ocr_cleaner.py`
  - [ ] 2.1.2.2 Implémenter la fusion des lettres espacées (`P Nr °a t` → `Praticien`)
  - [ ] 2.1.2.3 Implémenter la fusion des chiffres espacés (`1o 0s 1p` → `10100`)
  - [ ] 2.1.2.4 Utiliser un dictionnaire médical pour corriger les mots fragmentés
  - [ ] 2.1.2.5 Intégrer dans `_extract_with_doctr()`
  - [ ] 2.1.2.6 Tester sur 20 documents scannés
  - [ ] 2.1.2.7 Mesurer l'amélioration de lisibilité (cible: >80%)

### 2.2 Whitelist Médicaments (1 jour) - CRITIQUE

- [ ] 2.2.1 Créer la whitelist de médicaments
  - [ ] 2.2.1.1 Vérifier que `_load_edsnlp_drug_names()` fonctionne
  - [ ] 2.2.1.2 Ajouter les médicaments manquants (IDACIO, etc.)
  - [ ] 2.2.1.3 Créer `config/medications_whitelist.yml`
  - [ ] 2.2.1.4 Charger la whitelist au démarrage

- [ ] 2.2.2 Intégrer la whitelist dans le NER
  - [ ] 2.2.2.1 Modifier `_mask_with_eds_pseudo()` pour filtrer les médicaments
  - [ ] 2.2.2.2 Ajouter le filtre dans la boucle de masquage NER
  - [ ] 2.2.2.3 Tester sur 10 documents avec médicaments
  - [ ] 2.2.2.4 Vérifier que 0 médicament est masqué

### 2.3 Raffiner Regex Termes Médicaux (1 jour) - CRITIQUE

- [ ] 2.3.1 Modifier les regex problématiques
  - [ ] 2.3.1.1 Modifier `RE_SERVICE` pour exclure "Chef de service"
  - [ ] 2.3.1.2 Modifier `RE_ETABLISSEMENT` pour exclure "Chef de Clinique"
  - [ ] 2.3.1.3 Créer `config/medical_terms_whitelist.yml`
  - [ ] 2.3.1.4 Ajouter les termes structurels (Chef de service, Praticien hospitalier, etc.)

- [ ] 2.3.2 Intégrer la whitelist dans le pipeline
  - [ ] 2.3.2.1 Charger la whitelist au démarrage
  - [ ] 2.3.2.2 Filtrer les détections avant masquage
  - [ ] 2.3.2.3 Tester sur 10 documents
  - [ ] 2.3.2.4 Vérifier que 0 terme médical structurel est masqué

### 2.4 Validation de la Correction (1 jour)

- [ ] 2.4.1 Ré-anonymiser le corpus de test
  - [ ] 2.4.1.1 Ré-anonymiser les 27 documents du test dataset
  - [ ] 2.4.1.2 Exécuter l'évaluateur de qualité
  - [ ] 2.4.1.3 Vérifier que Recall=100%, Precision=100%, F1=100%
  - [ ] 2.4.1.4 Mesurer les nouvelles métriques (artefacts OCR, médicaments, termes médicaux)

- [ ] 2.4.2 Ré-anonymiser un échantillon de production
  - [ ] 2.4.2.1 Sélectionner 50 documents de production (scannés)
  - [ ] 2.4.2.2 Ré-anonymiser avec les corrections
  - [ ] 2.4.2.3 Comparer avec la baseline (avant corrections)
  - [ ] 2.4.2.4 Mesurer l'amélioration:
    - Artefacts OCR: <5% (était ~30%)
    - Médicaments masqués: 0 (était >0)
    - Termes médicaux masqués: 0 (était >10)
    - Lisibilité: >80% (était ~60%)
    - PII/doc: <30 (était 54.8)

- [ ] 2.4.3 Validation manuelle
  - [ ] 2.4.3.1 Sélectionner 10 documents aléatoires
  - [ ] 2.4.3.2 Vérifier manuellement la qualité
  - [ ] 2.4.3.3 Vérifier la lisibilité médicale
  - [ ] 2.4.3.4 Documenter les observations

- [ ] 2.4.4 Générer le rapport de correction
  - [ ] 2.4.4.1 Créer `REGRESSION_FIX_REPORT.md`
  - [ ] 2.4.4.2 Documenter les métriques avant/après
  - [ ] 2.4.4.3 Documenter les corrections appliquées
  - [ ] 2.4.4.4 Documenter les résultats de validation

---

## Phase 3 : Amélioration Avancée de la Détection (3 semaines) - OPTIONNEL

### 3.1 Amélioration des Regex

- [ ] 3.1.1 Améliorer la détection des téléphones
  - [ ] 2.1.1.1 Créer `detectors/improved_regex.py`
  - [ ] 2.1.1.2 Implémenter `RE_TEL_IMPROVED` (formats fragmentés)
  - [ ] 2.1.1.3 Ajouter 20+ tests unitaires pour les téléphones
  - [ ] 2.1.1.4 Valider sur le dataset annoté

- [ ] 2.1.2 Améliorer la détection des emails
  - [ ] 2.1.2.1 Implémenter `RE_EMAIL_IMPROVED` (domaines médicaux)
  - [ ] 2.1.2.2 Ajouter 20+ tests unitaires pour les emails
  - [ ] 2.1.2.3 Valider sur le dataset annoté

- [ ] 2.1.3 Améliorer la détection des adresses
  - [ ] 2.1.3.1 Implémenter `RE_ADRESSE_IMPROVED` (compléments Bât., Appt.)
  - [ ] 2.1.3.2 Ajouter 20+ tests unitaires pour les adresses
  - [ ] 2.1.3.3 Valider sur le dataset annoté

- [ ] 2.1.4 Améliorer la détection des NIR
  - [ ] 2.1.4.1 Implémenter `RE_NIR_IMPROVED` (espaces variables)
  - [ ] 2.1.4.2 Ajouter 20+ tests unitaires pour les NIR
  - [ ] 2.1.4.3 Valider sur le dataset annoté

- [ ] 2.1.5 Améliorer la détection des noms avec caractères spéciaux
  - [ ] 2.1.5.1 Adapter les regex pour O'Brien, D'Angelo, Müller, etc.
  - [ ] 2.1.5.2 Ajouter 20+ tests unitaires
  - [ ] 2.1.5.3 Valider sur le dataset annoté

- [ ] 2.1.6 Intégrer les regex améliorées
  - [ ] 2.1.6.1 Remplacer les regex dans `anonymizer_core_refactored_onnx.py`
  - [ ] 2.1.6.2 Exécuter les tests de régression
  - [ ] 2.1.6.3 Mesurer l'amélioration (Rappel, Précision)

### 2.2 Détection Contextuelle

- [ ] 2.2.1 Implémenter le détecteur contextuel
  - [ ] 2.2.1.1 Créer `detectors/contextual.py`
  - [ ] 2.2.1.2 Implémenter la classe `ContextualDetector`
  - [ ] 2.2.1.3 Implémenter la détection avec contexte fort
  - [ ] 2.2.1.4 Implémenter la détection des noms en MAJUSCULES
  - [ ] 2.2.1.5 Implémenter la détection avec contexte faible
  - [ ] 2.2.1.6 Implémenter le filtrage via stopwords médicaux
  - [ ] 2.2.1.7 Implémenter la dédoplication et tri par confiance
  - [ ] 2.2.1.8 Ajouter les tests unitaires

- [ ] 2.2.2 Valider le détecteur contextuel
  - [ ] 2.2.2.1 Tester sur le dataset annoté
  - [ ] 2.2.2.2 Mesurer le rappel (noms détectés)
  - [ ] 2.2.2.3 Mesurer la précision (faux positifs)
  - [ ] 2.2.2.4 Ajuster les seuils de confiance si nécessaire

### 2.3 Approche Hybride

- [ ] 2.3.1 Implémenter le détecteur hybride
  - [ ] 2.3.1.1 Créer `detectors/hybrid.py`
  - [ ] 2.3.1.2 Implémenter la classe `HybridDetector`
  - [ ] 2.3.1.3 Implémenter le pipeline en 4 étapes (Regex → EDS → CamemBERT → Contextuel)
  - [ ] 2.3.1.4 Implémenter le masquage progressif
  - [ ] 2.3.1.5 Implémenter la fusion des résultats
  - [ ] 2.3.1.6 Implémenter la traçabilité (méthode de détection)
  - [ ] 2.3.1.7 Ajouter les tests d'intégration

- [ ] 2.3.2 Intégrer le détecteur hybride
  - [ ] 2.3.2.1 Modifier `anonymizer_core_refactored_onnx.py` pour utiliser `HybridDetector`
  - [ ] 2.3.2.2 Ajouter la configuration activable/désactivable par détecteur
  - [ ] 2.3.2.3 Exécuter les tests de régression
  - [ ] 2.3.2.4 Mesurer l'amélioration globale

- [ ] 2.3.3 Optimiser les performances avec GPU
  - [ ] 2.3.3.1 Activer l'accélération CUDA pour EDS-Pseudo
  - [ ] 2.3.3.2 Activer l'accélération CUDA pour CamemBERT-NER
  - [ ] 2.3.3.3 Implémenter le batch processing optimisé pour GPU
  - [ ] 2.3.3.4 Tester différentes tailles de batch (4, 8, 16, 32)
  - [ ] 2.3.3.5 Mesurer l'utilisation VRAM et ajuster batch_size
  - [ ] 2.3.3.6 Implémenter le fallback CPU automatique si GPU indisponible
  - [ ] 2.3.3.7 Profiler le code (cProfile + CUDA profiler)
  - [ ] 2.3.3.8 Identifier les goulots d'étranglement
  - [ ] 2.3.3.9 Optimiser les parties critiques
  - [ ] 2.3.3.10 Vérifier que le temps de traitement est < 10s/PDF avec GPU

- [ ] 2.3.4 Implémenter le traitement parallèle multi-PDF
  - [ ] 2.3.4.1 Créer un gestionnaire de pool de workers (ProcessPoolExecutor)
  - [ ] 2.3.4.2 Tester avec 4, 8, 12 workers (optimal sur 16 cœurs)
  - [ ] 2.3.4.3 Implémenter la répartition de charge intelligente
  - [ ] 2.3.4.4 Mesurer le speedup avec parallélisation
  - [ ] 2.3.4.5 Gérer les conflits d'accès GPU entre workers

### 2.4 Configuration

- [ ] 2.4.1 Créer le fichier de configuration
  - [ ] 2.4.1.1 Créer `config/quality_config.yml`
  - [ ] 2.4.1.2 Définir les paramètres d'évaluation
  - [ ] 2.4.1.3 Définir les paramètres de validation
  - [ ] 2.4.1.4 Définir les paramètres de détection
  - [ ] 2.4.1.5 Définir les paramètres GPU (device, batch_size, max_vram)
  - [ ] 2.4.1.6 Définir les paramètres VLM (Ollama URL, model, timeout, confidence)
  - [ ] 2.4.1.7 Définir les paramètres de performance (max_workers, parallélisation)
  - [ ] 2.4.1.8 Définir les paramètres de reporting

- [ ] 2.4.2 Implémenter le chargement de configuration
  - [ ] 2.4.2.1 Utiliser `pydantic` pour valider la configuration
  - [ ] 2.4.2.2 Créer les modèles de configuration typés
  - [ ] 2.4.2.3 Implémenter le chargement depuis YAML
  - [ ] 2.4.2.4 Ajouter les tests de validation

### 2.5 Optimisation VLM

- [ ] 2.5.1 Améliorer le prompt VLM
  - [ ] 2.5.1.1 Analyser les hallucinations actuelles du VLM
  - [ ] 2.5.1.2 Créer un prompt plus précis avec exemples négatifs
  - [ ] 2.5.1.3 Ajouter des instructions anti-hallucination
  - [ ] 2.5.1.4 Tester sur échantillon de pages manuscrites
  - [ ] 2.5.1.5 Mesurer le taux d'hallucination avant/après

- [ ] 2.5.2 Implémenter la validation croisée VLM ↔ NER
  - [ ] 2.5.2.1 Créer `detectors/vlm_validator.py`
  - [ ] 2.5.2.2 Implémenter la comparaison VLM vs NER
  - [ ] 2.5.2.3 Définir les règles de résolution de conflits
  - [ ] 2.5.2.4 Rejeter les détections VLM non confirmées (seuil configurable)
  - [ ] 2.5.2.5 Logger les conflits pour analyse
  - [ ] 2.5.2.6 Ajouter les tests unitaires

- [ ] 2.5.3 Optimiser les performances VLM
  - [ ] 2.5.3.1 Vérifier si Ollama supporte GPU (CUDA)
  - [ ] 2.5.3.2 Configurer Ollama pour utiliser le GPU si disponible
  - [ ] 2.5.3.3 Mesurer le temps de traitement par page (baseline)
  - [ ] 2.5.3.4 Optimiser la résolution d'image (trade-off qualité/vitesse)
  - [ ] 2.5.3.5 Implémenter un cache des résultats VLM par hash d'image
  - [ ] 2.5.3.6 Mesurer le speedup après optimisations

---

## Phase 3 : Validation et Reporting (1 semaine)

### 3.1 Validation Post-Anonymisation

- [ ] 3.1.1 Implémenter la validation post-anonymisation
  - [ ] 3.1.1.1 Créer `core/post_validation.py`
  - [ ] 3.1.1.2 Implémenter la fonction `validate_anonymized_pdf()`
  - [ ] 3.1.1.3 Intégrer le scanner de fuite
  - [ ] 3.1.1.4 Implémenter la vérification de lisibilité
  - [ ] 3.1.1.5 Implémenter la génération de certificat
  - [ ] 3.1.1.6 Implémenter le mode strict (blocage si fuite)
  - [ ] 3.1.1.7 Ajouter les tests unitaires

- [ ] 3.1.2 Intégrer la validation dans le pipeline
  - [ ] 3.1.2.1 Modifier `anonymizer_core_refactored_onnx.py` pour appeler la validation
  - [ ] 3.1.2.2 Ajouter l'option `--validate` en CLI
  - [ ] 3.1.2.3 Ajouter l'option dans la GUI
  - [ ] 3.1.2.4 Tester sur le dataset annoté

### 3.2 Reporting

- [ ] 3.2.1 Créer le générateur de rapports
  - [ ] 3.2.1.1 Créer `tools/quality_reporter.py`
  - [ ] 3.2.1.2 Implémenter la classe `QualityReporter`
  - [ ] 3.2.1.3 Créer le template HTML (`templates/quality_report.html`)
  - [ ] 3.2.1.4 Implémenter la génération de graphiques (matplotlib)
  - [ ] 3.2.1.5 Implémenter l'export JSON
  - [ ] 3.2.1.6 Implémenter l'export HTML
  - [ ] 3.2.1.7 Ajouter les tests unitaires

- [ ] 3.2.2 Générer les rapports de qualité
  - [ ] 3.2.2.1 Générer le rapport baseline (avant optimisation)
  - [ ] 3.2.2.2 Générer le rapport après optimisation
  - [ ] 3.2.2.3 Créer un rapport comparatif (avant/après)
  - [ ] 3.2.2.4 Exporter en HTML et JSON

### 3.3 Tests de Régression

- [ ] 3.3.1 Créer la suite de tests de régression
  - [ ] 3.3.1.1 Créer `tests/regression/test_regression.py`
  - [ ] 3.3.1.2 Implémenter le test de qualité (Rappel ≥ 99.5%, Précision ≥ 97%)
  - [ ] 3.3.1.3 Implémenter le test de performance (temps < 30s/PDF)
  - [ ] 3.3.1.4 Implémenter le test de non-régression (vs baseline)
  - [ ] 3.3.1.5 Configurer pytest pour exécution automatique

- [ ] 3.3.2 Exécuter les tests de régression
  - [ ] 3.3.2.1 Exécuter sur le dataset annoté complet
  - [ ] 3.3.2.2 Vérifier que tous les tests passent
  - [ ] 3.3.2.3 Corriger les régressions si nécessaire

### 3.4 Validation sur Corpus Complet

- [ ] 3.4.1 Exécuter sur les 59 dossiers OGC complets
  - [ ] 3.4.1.1 Anonymiser les 130 fichiers avec le système optimisé
  - [ ] 3.4.1.2 Exécuter le scanner de fuite sur tous les fichiers
  - [ ] 3.4.1.3 Vérifier qu'aucune fuite critique n'est détectée
  - [ ] 3.4.1.4 Générer le rapport de qualité global

- [ ] 3.4.2 Validation manuelle (échantillon)
  - [ ] 3.4.2.1 Sélectionner 10 documents aléatoires
  - [ ] 3.4.2.2 Vérifier manuellement la qualité d'anonymisation
  - [ ] 3.4.2.3 Vérifier la lisibilité médicale
  - [ ] 3.4.2.4 Documenter les observations

- [ ] 3.4.3 Comparer avec la baseline
  - [ ] 3.4.3.1 Comparer les métriques de qualité (Rappel, Précision, F1)
  - [ ] 3.4.3.2 Comparer les métriques de performance (temps, CPU, RAM)
  - [ ] 3.4.3.3 Calculer le gain d'amélioration
  - [ ] 3.4.3.4 Documenter les résultats

---

## Phase 4 : Documentation et Finalisation (3 jours)

### 4.1 Documentation

- [ ] 4.1.1 Créer le guide d'annotation
  - [ ] 4.1.1.1 Créer `docs/annotation_guide.md`
  - [ ] 4.1.1.2 Documenter le processus d'annotation
  - [ ] 4.1.1.3 Documenter le format JSON
  - [ ] 4.1.1.4 Ajouter des exemples

- [ ] 4.1.2 Créer le guide d'évaluation
  - [ ] 4.1.2.1 Créer `docs/evaluation_guide.md`
  - [ ] 4.1.2.2 Documenter l'utilisation de l'évaluateur
  - [ ] 4.1.2.3 Documenter l'utilisation du scanner
  - [ ] 4.1.2.4 Documenter l'utilisation du benchmark
  - [ ] 4.1.2.5 Ajouter des exemples

- [ ] 4.1.3 Créer la référence API
  - [ ] 4.1.3.1 Créer `docs/api_reference.md`
  - [ ] 4.1.3.2 Documenter les classes principales
  - [ ] 4.1.3.3 Documenter les méthodes publiques
  - [ ] 4.1.3.4 Ajouter des exemples de code

- [ ] 4.1.4 Mettre à jour le README
  - [ ] 4.1.4.1 Ajouter la section "Évaluation de la Qualité"
  - [ ] 4.1.4.2 Ajouter les nouvelles dépendances
  - [ ] 4.1.4.3 Ajouter les exemples d'utilisation
  - [ ] 4.1.4.4 Ajouter les métriques de qualité

### 4.2 Finalisation

- [ ] 4.2.1 Revue de code
  - [ ] 4.2.1.1 Vérifier la qualité du code (pylint, black, mypy)
  - [ ] 4.2.1.2 Vérifier la couverture de tests (≥ 80%)
  - [ ] 4.2.1.3 Vérifier la documentation (docstrings)
  - [ ] 4.2.1.4 Corriger les problèmes identifiés

- [ ] 4.2.2 Préparer les livrables
  - [ ] 4.2.2.1 Dataset annoté (30+ documents)
  - [ ] 4.2.2.2 Code source (détecteurs + évaluation)
  - [ ] 4.2.2.3 Tests (unitaires + régression)
  - [ ] 4.2.2.4 Documentation (guides + API)
  - [ ] 4.2.2.5 Rapports (baseline + optimisé + comparatif)
  - [ ] 4.2.2.6 Configuration (`quality_config.yml`)

- [ ] 4.2.3 Validation finale
  - [ ] 4.2.3.1 Vérifier que tous les critères de succès sont atteints
  - [ ] 4.2.3.2 Vérifier que les métriques cibles sont atteintes (Rappel ≥ 99.5%, Précision ≥ 97%)
  - [ ] 4.2.3.3 Vérifier que les performances sont acceptables (< 30s/PDF)
  - [ ] 4.2.3.4 Obtenir la validation d'un expert médical (échantillon)

---

## Tâches Optionnelles (si temps disponible)

- [ ]* Implémenter un cache des résultats NER pour améliorer les performances
- [ ]* Implémenter la parallélisation du traitement par lots (déjà inclus dans Phase 2)
- [ ]* Créer une interface web pour l'annotation (alternative à la CLI)
- [ ]* Implémenter l'export des rapports en PDF
- [ ]* Créer un dashboard de monitoring (Grafana/Prometheus)
- [ ]* Implémenter l'analyse automatique des échecs (suggestions d'amélioration)
- [ ]* Fine-tuner EDS-Pseudo sur le dataset annoté
- [ ]* Implémenter un modèle ensemble (vote majoritaire)
- [ ]* Optimiser le batch size dynamiquement selon la VRAM disponible
- [ ]* Implémenter le préchargement asynchrone des modèles NER
- [ ]* Tester d'autres modèles VLM (Qwen3-VL 8B, LLaVA, etc.)
- [ ]* Implémenter un système de feedback utilisateur pour améliorer le VLM
- [ ]* Créer un mode "review" pour valider les détections VLM manuellement

---

## Dépendances entre Tâches

**Critiques** (bloquantes) :
- 1.1 (Dataset annoté) → 1.3 (Baseline) → 2.x (Amélioration) → 3.4 (Validation)
- 1.2.1 (Évaluateur) → 1.3.1 (Évaluation baseline)
- 1.2.2 (Scanner) → 3.1 (Validation post-anonymisation)
- 2.1 + 2.2 + 2.3 (Détecteurs) → 3.3 (Tests régression)

**Parallélisables** :
- 1.2.1 (Évaluateur) || 1.2.2 (Scanner) || 1.2.3 (Benchmark)
- 2.1.1 || 2.1.2 || 2.1.3 || 2.1.4 || 2.1.5 (Regex indépendantes)
- 4.1.1 || 4.1.2 || 4.1.3 (Documentation)

---

## Estimation de Charge

**Phase 1** : 10 jours (2 semaines)
- Annotation : 5 jours (30 docs × 1h = 30h)
- Évaluation : 3 jours
- Baseline : 2 jours

**Phase 2** : 15 jours (3 semaines)
- Regex : 5 jours
- Contextuel : 3 jours
- Hybride : 3 jours
- VLM optimization : 2 jours
- GPU optimization : 1 jour
- Config : 1 jour

**Phase 3** : 5 jours (1 semaine)
- Validation : 2 jours
- Reporting : 1 jour
- Tests régression : 1 jour
- Validation corpus : 1 jour

**Phase 4** : 3 jours
- Documentation : 2 jours
- Finalisation : 1 jour

**Total** : 33 jours (6.6 semaines) ≈ **7 semaines avec marge**
