Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+my_env/lib/python3.11/site-packages/pip/_vendor/distlib/t64-arm.exe filter=lfs diff=lfs merge=lfs -text
+my_env/lib/python3.11/site-packages/pip/_vendor/distlib/t64.exe filter=lfs diff=lfs merge=lfs -text
+my_env/lib/python3.11/site-packages/pip/_vendor/distlib/w64-arm.exe filter=lfs diff=lfs merge=lfs -text
+my_env/lib/python3.11/site-packages/pip/_vendor/distlib/w64.exe filter=lfs diff=lfs merge=lfs -text
+my_env/lib/python3.11/site-packages/setuptools/cli-arm64.exe filter=lfs diff=lfs merge=lfs -text
+my_env/lib/python3.11/site-packages/setuptools/gui-arm64.exe filter=lfs diff=lfs merge=lfs -text
+templates/medical_templates.faiss filter=lfs diff=lfs merge=lfs -text

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,14 @@
+medical_env/
+models/
+transcriptions/
+*.docx
+*.json
+*.rtf
+*.pdf
+*.doc
+*.docx
+*.rtf
+*.log
+*.pyc
+*.pyo
+.env

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

.gradio/flagged/dataset1.csv

@@ -0,0 +1,65 @@
+📝 Transcription médicale,✅ Transcription corrigée,📋 Rapport à remplir (Template),📄 Compte-rendu structuré final,timestamp
+scanner thoraco abdomino pelvien et transit œsogastro décelable indication il est délimité un épaississement œsophagien point acquisition sans injection administration par voie orale de produit de contraste point à la ligne pas de foyer parenchymateux pas de nodule ni de masse à la ligne pas d épanchement pleural ou péricardique la pas d adénomégalie médiastinale ou axillaire il ne semble pas exister d épaississement œsophagien point a l étage abdomino pelvien hépatomégalie homogène point pas d anomalie décelée sur le pancréas les reins rate ou les surrénales point l estomac est de volume normal point pas d anomalie décelée sur le cadre duodénal ou les anses grêles opacifiées point pas de lésion osseuse point à la ligne transit œso gastro duodénal opacification rapide et douce de l œsophage avec des parois normales sans zone d addition ou de sténose point pas d anomalie de la cavité gastrique point à la ligne opacification rapide du cadre duodénal point à la ligne pas d anomalie des anses jéjunales opacifiées point pas de pneumopéritoine point à la ligne conclusion à la ligne scanner thoraco abdomino pelvien transito gastro duodénal sans lésion décelée à a confronter au reste du bilan et une endoscopie si nécessaire,"Scanner thoraco-abdomino-pelvien et transit œso-gastro décelable. Indication. Il est délimité un épaississement œsophagien. Acquisition sans injection. Administration par voie orale de produit de contraste.
+Pas de foyer parenchymateux. Pas de nodule ni de masse.
+Pas d'épanchement pleural ou péricardique. Pas d'adénomégalie médiastinale ou axillaire. Il ne semble pas exister d'épaississement œsophagien. À l'étage abdomino-pelvien, hépatomégalie homogène. Pas d'anomalie décelée sur le pancréas, les reins, la rate ou les surrénales. L'estomac est de volume normal. Pas d'anomalie décelée sur le cadre duodénal ou les anses grêles opacifiées. Pas de lésion osseuse.
+Transit œso-gastro-duodénal. Opacification rapide et douce de l'œsophage avec des parois normales sans zone d'addition ou de sténose. Pas d'anomalie de la cavité gastrique.
+Opacification rapide du cadre duodénal.
+Pas d'anomalie des anses jéjunales opacifiées. Pas de pneumopéritoine.
+Conclusion
+Scanner thoraco-abdomino-pelvien, transit œso-gastro-duodénal, sans lésion décelée, à confronter au reste du bilan et à une endoscopie si nécessaire.","default.99.771703477
+====================
+Examen tomodensitométrique $
+Indication : <ASR_VOX>
+Technique :
+Examen réalisé sur un scanner REVOLUTION EVO.
+Résultat :
+$
+Conclusion : $","default.99.771703477
+====================
+TITRE :
+Scanner thoraco-abdomino-pelvien et transit œso-gastro-duodénal
+
+CLINIQUE :
+Il est délimité un épaississement œsophagien.
+
+TECHNIQUE :
+Examen réalisé sur un scanner REVOLUTION EVO. Acquisition sans injection. Administration par voie orale de produit de contraste.
+
+RESULTATS :
+Pas de foyer parenchymateux. Pas de nodule ni de masse. Pas d'épanchement pleural ou péricardique. Pas d'adénomégalie médiastinale ou axillaire. Il ne semble pas exister d'épaississement œsophagien. À l'étage abdomino-pelvien, hépatomégalie homogène. Pas d'anomalie décelée sur le pancréas, les reins, la rate ou les surrénales. L'estomac est de volume normal. Pas d'anomalie décelée sur le cadre duodénal ou les anses grêles opacifiées. Pas de lésion osseuse. Transit œso-gastro-duodénal. Opacification rapide et douce de l'œsophage avec des parois normales sans zone d'addition ou de sténose. Pas d'anomalie de la cavité gastrique. Opacification rapide du cadre duodénal. Pas d'anomalie des anses jéjunales opacifiées. Pas de pneumopéritoine.
+
+CONCLUSION :
+Scanner thoraco-abdomino-pelvien, transit œso-gastro-duodénal, sans lésion décelée, à confronter au reste du bilan et à une endoscopie si nécessaire.
+",2025-10-02 16:07:30.158731
+scanner thoraco abdomino pelvien et transit œsogastro décelable indication il est délimité un épaississement œsophagien point acquisition sans injection administration par voie orale de produit de contraste point à la ligne pas de foyer parenchymateux pas de nodule ni de masse à la ligne pas d épanchement pleural ou péricardique la pas d adénomégalie médiastinale ou axillaire il ne semble pas exister d épaississement œsophagien point a l étage abdomino pelvien hépatomégalie homogène point pas d anomalie décelée sur le pancréas les reins rate ou les surrénales point l estomac est de volume normal point pas d anomalie décelée sur le cadre duodénal ou les anses grêles opacifiées point pas de lésion osseuse point à la ligne transit œso gastro duodénal opacification rapide et douce de l œsophage avec des parois normales sans zone d addition ou de sténose point pas d anomalie de la cavité gastrique point à la ligne opacification rapide du cadre duodénal point à la ligne pas d anomalie des anses jéjunales opacifiées point pas de pneumopéritoine point à la ligne conclusion à la ligne scanner thoraco abdomino pelvien transito gastro duodénal sans lésion décelée à a confronter au reste du bilan et une endoscopie si nécessaire,"Scanner thoraco-abdomino-pelvien et transit œso-gastro décelable. Indication. Il est délimité un épaississement œsophagien. Acquisition sans injection. Administration par voie orale de produit de contraste.
+Pas de foyer parenchymateux. Pas de nodule ni de masse.
+Pas d'épanchement pleural ou péricardique. Pas d'adénomégalie médiastinale ou axillaire. Il ne semble pas exister d'épaississement œsophagien. À l'étage abdomino-pelvien, hépatomégalie homogène. Pas d'anomalie décelée sur le pancréas, les reins, la rate ou les surrénales. L'estomac est de volume normal. Pas d'anomalie décelée sur le cadre duodénal ou les anses grêles opacifiées. Pas de lésion osseuse.
+Transit œso-gastro-duodénal. Opacification rapide et douce de l'œsophage avec des parois normales sans zone d'addition ou de sténose. Pas d'anomalie de la cavité gastrique.
+Opacification rapide du cadre duodénal.
+Pas d'anomalie des anses jéjunales opacifiées. Pas de pneumopéritoine.
+Conclusion
+Scanner thoraco-abdomino-pelvien, transit œso-gastro-duodénal, sans lésion décelée, à confronter au reste du bilan et à une endoscopie si nécessaire.","default.99.771703477
+====================
+Examen tomodensitométrique $
+Indication : <ASR_VOX>
+Technique :
+Examen réalisé sur un scanner REVOLUTION EVO.
+Résultat :
+$
+Conclusion : $","default.99.771703477
+====================
+TITRE :
+Scanner thoraco-abdomino-pelvien et transit œso-gastro-duodénal
+
+CLINIQUE :
+Il est délimité un épaississement œsophagien.
+
+TECHNIQUE :
+Examen réalisé sur un scanner REVOLUTION EVO. Acquisition sans injection. Administration par voie orale de produit de contraste.
+
+RESULTATS :
+Pas de foyer parenchymateux. Pas de nodule ni de masse. Pas d'épanchement pleural ou péricardique. Pas d'adénomégalie médiastinale ou axillaire. Il ne semble pas exister d'épaississement œsophagien. À l'étage abdomino-pelvien, hépatomégalie homogène. Pas d'anomalie décelée sur le pancréas, les reins, la rate ou les surrénales. L'estomac est de volume normal. Pas d'anomalie décelée sur le cadre duodénal ou les anses grêles opacifiées. Pas de lésion osseuse. Transit œso-gastro-duodénal. Opacification rapide et douce de l'œsophage avec des parois normales sans zone d'addition ou de sténose. Pas d'anomalie de la cavité gastrique. Opacification rapide du cadre duodénal. Pas d'anomalie des anses jéjunales opacifiées. Pas de pneumopéritoine.
+
+CONCLUSION :
+Scanner thoraco-abdomino-pelvien, transit œso-gastro-duodénal, sans lésion décelée, à confronter au reste du bilan et à une endoscopie si nécessaire.
+",2025-10-02 16:07:33.131071

.python-version

@@ -0,0 +1 @@
+3.11.0

Create_db_optimized.py

@@ -0,0 +1,657 @@
+import os
+import re
+import json
+import numpy as np
+from typing import List, Dict, Any, Optional, Tuple, Union
+from dataclasses import dataclass
+from pathlib import Path
+
+# Core libraries
+import torch
+from transformers import (
+    AutoTokenizer, AutoModel, AutoModelForTokenClassification,
+    TrainingArguments, Trainer, pipeline
+)
+from torch.utils.data import Dataset
+import torch.nn.functional as F
+
+# Vector database
+import chromadb
+from chromadb.config import Settings
+
+# Utilities
+import logging
+from tqdm import tqdm
+import pandas as pd
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class MedicalEntity:
+    """Structure pour les entités médicales extraites par NER"""
+    exam_types: List[Tuple[str, float]]  # (entity, confidence)
+    specialties: List[Tuple[str, float]]
+    anatomical_regions: List[Tuple[str, float]]
+    pathologies: List[Tuple[str, float]]
+    medical_procedures: List[Tuple[str, float]]
+    measurements: List[Tuple[str, float]]
+    medications: List[Tuple[str, float]]
+    symptoms: List[Tuple[str, float]]
+
+class AdvancedMedicalNER:
+    """NER médical avancé basé sur CamemBERT-Bio fine-tuné"""
+    
+    def __init__(self, model_name: str = "auto", cache_dir: str = "./models_cache"):
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(exist_ok=True)
+        
+        # Auto-détection du meilleur modèle NER médical disponible
+        self.model_name = self._select_best_model(model_name)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Chargement du modèle NER
+        self._load_ner_model()
+        
+        # Labels BIO pour entités médicales
+        self.entity_labels = [
+            "O",  # Outside
+            "B-EXAM", "I-EXAM",           # Types d'examens
+            "B-SPECIALTY", "I-SPECIALTY", # Spécialités médicales
+            "B-ANATOMY", "I-ANATOMY",     # Régions anatomiques
+            "B-PATHOLOGY", "I-PATHOLOGY", # Pathologies
+            "B-PROCEDURE", "I-PROCEDURE", # Procédures médicales
+            "B-MEASURE", "I-MEASURE",     # Mesures/valeurs
+            "B-MEDICATION", "I-MEDICATION", # Médicaments
+            "B-SYMPTOM", "I-SYMPTOM"      # Symptômes
+        ]
+        
+        self.id2label = {i: label for i, label in enumerate(self.entity_labels)}
+        self.label2id = {label: i for i, label in enumerate(self.entity_labels)}
+    
+    def _select_best_model(self, model_name: str) -> str:
+        """Sélection automatique du meilleur modèle NER médical"""
+        
+        if model_name != "auto":
+            return model_name
+        
+        # Liste des modèles par ordre de préférence
+        preferred_models = [
+            "almanach/camembert-bio-base",           # CamemBERT Bio français
+            "Dr-BERT/DrBERT-7GB",                    # DrBERT spécialisé
+            "emilyalsentzer/Bio_ClinicalBERT",       # Bio Clinical BERT
+            "microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext",
+            "dmis-lab/biobert-base-cased-v1.2",     # BioBERT
+            "camembert-base"                         # Fallback CamemBERT standard
+        ]
+        
+        for model in preferred_models:
+            try:
+                # Test de disponibilité
+                AutoTokenizer.from_pretrained(model, cache_dir=self.cache_dir)
+                logger.info(f"Modèle sélectionné: {model}")
+                return model
+            except:
+                continue
+        
+        # Fallback ultime
+        logger.warning("Utilisation du modèle de base camembert-base")
+        return "camembert-base"
+    
+    def _load_ner_model(self):
+        """Charge ou crée le modèle NER fine-tuné"""
+        
+        fine_tuned_path = self.cache_dir / "medical_ner_model"
+        
+        if fine_tuned_path.exists():
+            logger.info("Chargement du modèle NER fine-tuné existant")
+            self.tokenizer = AutoTokenizer.from_pretrained(fine_tuned_path)
+            self.ner_model = AutoModelForTokenClassification.from_pretrained(fine_tuned_path)
+        else:
+            logger.info("Création d'un nouveau modèle NER médical")
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, cache_dir=self.cache_dir)
+            
+            # Modèle pour classification de tokens (NER)
+            self.ner_model = AutoModelForTokenClassification.from_pretrained(
+                self.model_name,
+                num_labels=len(self.entity_labels),
+                id2label=self.id2label,
+                label2id=self.label2id,
+                cache_dir=self.cache_dir
+            )
+        
+        self.ner_model.to(self.device)
+        
+        # Pipeline NER
+        self.ner_pipeline = pipeline(
+            "token-classification",
+            model=self.ner_model,
+            tokenizer=self.tokenizer,
+            device=0 if torch.cuda.is_available() else -1,
+            aggregation_strategy="simple"
+        )
+    
+    def extract_entities(self, text: str) -> MedicalEntity:
+        """Extraction d'entités avec le modèle NER fine-tuné"""
+        
+        # Prédiction NER
+        try:
+            ner_results = self.ner_pipeline(text)
+        except Exception as e:
+            logger.error(f"Erreur NER: {e}")
+            return MedicalEntity([], [], [], [], [], [], [], [])
+        
+        # Groupement des entités par type
+        entities = {
+            "EXAM": [],
+            "SPECIALTY": [],
+            "ANATOMY": [],
+            "PATHOLOGY": [],
+            "PROCEDURE": [],
+            "MEASURE": [],
+            "MEDICATION": [],
+            "SYMPTOM": []
+        }
+        
+        for result in ner_results:
+            entity_type = result['entity_group'].replace('B-', '').replace('I-', '')
+            entity_text = result['word']
+            confidence = result['score']
+            
+            if entity_type in entities and confidence > 0.7:  # Seuil de confiance
+                entities[entity_type].append((entity_text, confidence))
+        
+        return MedicalEntity(
+            exam_types=entities["EXAM"],
+            specialties=entities["SPECIALTY"],
+            anatomical_regions=entities["ANATOMY"],
+            pathologies=entities["PATHOLOGY"],
+            medical_procedures=entities["PROCEDURE"],
+            measurements=entities["MEASURE"],
+            medications=entities["MEDICATION"],
+            symptoms=entities["SYMPTOM"]
+        )
+    
+    def fine_tune_on_templates(self, templates_data: List[Dict], 
+                              output_dir: str = None, 
+                              epochs: int = 3):
+        """Fine-tuning du modèle NER sur des templates médicaux"""
+        
+        if output_dir is None:
+            output_dir = self.cache_dir / "medical_ner_model"
+        
+        logger.info("Début du fine-tuning NER sur templates médicaux")
+        
+        # Préparation des données d'entraînement
+        # (Ici, on utiliserait des templates annotés ou de l'auto-annotation)
+        train_dataset = self._prepare_training_data(templates_data)
+        
+        # Configuration d'entraînement
+        training_args = TrainingArguments(
+            output_dir=output_dir,
+            num_train_epochs=epochs,
+            per_device_train_batch_size=8,
+            per_device_eval_batch_size=8,
+            warmup_steps=100,
+            weight_decay=0.01,
+            logging_dir=f"{output_dir}/logs",
+            save_strategy="epoch",
+            evaluation_strategy="epoch" if train_dataset.get('eval') else "no",
+            load_best_model_at_end=True,
+            metric_for_best_model="eval_loss" if train_dataset.get('eval') else None,
+        )
+        
+        # Trainer
+        trainer = Trainer(
+            model=self.ner_model,
+            args=training_args,
+            train_dataset=train_dataset['train'],
+            eval_dataset=train_dataset.get('eval'),
+            tokenizer=self.tokenizer,
+        )
+        
+        # Entraînement
+        trainer.train()
+        
+        # Sauvegarde
+        trainer.save_model()
+        self.tokenizer.save_pretrained(output_dir)
+        
+        logger.info(f"Fine-tuning terminé, modèle sauvé dans {output_dir}")
+    
+    def _prepare_training_data(self, templates_data: List[Dict]) -> Dict:
+        """Prépare les données d'entraînement pour le NER (auto-annotation intelligente)"""
+        
+        # Cette fonction pourrait utiliser des techniques d'auto-annotation
+        # ou des datasets médicaux pré-existants pour créer des labels BIO
+        
+        # Pour l'exemple, retourner un dataset vide
+        # En production, on utiliserait des techniques d'annotation automatique
+        # ou des datasets médicaux annotés comme QUAERO, CAS, etc.
+        
+        class EmptyDataset(Dataset):
+            def __len__(self):
+                return 0
+            def __getitem__(self, idx):
+                return {}
+        
+        return {'train': EmptyDataset()}
+
+class AdvancedMedicalEmbedding:
+    """Générateur d'embeddings médicaux avancés avec cross-encoder reranking"""
+    
+    def __init__(self, 
+                 base_model: str = "almanach/camembert-bio-base",
+                 cross_encoder_model: str = "auto"):
+        
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.base_model_name = base_model
+        
+        # Modèle principal pour embeddings
+        self._load_base_model()
+        
+        # Cross-encoder pour reranking
+        self._load_cross_encoder(cross_encoder_model)
+    
+    def _load_base_model(self):
+        """Charge le modèle de base pour les embeddings"""
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.base_model_name)
+            self.base_model = AutoModel.from_pretrained(self.base_model_name)
+            self.base_model.to(self.device)
+            logger.info(f"Modèle de base chargé: {self.base_model_name}")
+        except Exception as e:
+            logger.error(f"Erreur chargement modèle de base: {e}")
+            raise
+    
+    def _load_cross_encoder(self, model_name: str):
+        """Charge le cross-encoder pour reranking"""
+        
+        if model_name == "auto":
+            # Sélection automatique du meilleur cross-encoder médical
+            cross_encoders = [
+                "microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext",
+                "emilyalsentzer/Bio_ClinicalBERT",
+                self.base_model_name  # Fallback
+            ]
+            
+            for model in cross_encoders:
+                try:
+                    self.cross_tokenizer = AutoTokenizer.from_pretrained(model)
+                    self.cross_model = AutoModel.from_pretrained(model)
+                    self.cross_model.to(self.device)
+                    logger.info(f"Cross-encoder chargé: {model}")
+                    break
+                except:
+                    continue
+        else:
+            self.cross_tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.cross_model = AutoModel.from_pretrained(model_name)
+            self.cross_model.to(self.device)
+    
+    def generate_embedding(self, text: str, entities: MedicalEntity = None) -> np.ndarray:
+        """Génère un embedding enrichi pour un texte médical"""
+        
+        # Tokenisation
+        inputs = self.tokenizer(
+            text, 
+            padding=True, 
+            truncation=True, 
+            max_length=512,
+            return_tensors="pt"
+        ).to(self.device)
+        
+        # Génération embedding
+        with torch.no_grad():
+            outputs = self.base_model(**inputs)
+            
+        # Mean pooling
+        attention_mask = inputs['attention_mask']
+        token_embeddings = outputs.last_hidden_state
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        embedding = torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+        
+        # Enrichissement avec entités NER
+        if entities:
+            embedding = self._enrich_with_ner_entities(embedding, entities)
+        
+        return embedding.cpu().numpy().flatten().astype(np.float32)
+    
+    def _enrich_with_ner_entities(self, base_embedding: torch.Tensor, entities: MedicalEntity) -> torch.Tensor:
+        """Enrichit l'embedding avec les entités extraites par NER"""
+        
+        # Concaténer les entités importantes avec leurs scores de confiance
+        entity_texts = []
+        confidence_weights = []
+        
+        for entity_list in [entities.exam_types, entities.specialties, 
+                           entities.anatomical_regions, entities.pathologies]:
+            for entity_text, confidence in entity_list:
+                entity_texts.append(entity_text)
+                confidence_weights.append(confidence)
+        
+        if not entity_texts:
+            return base_embedding
+        
+        # Génération d'embeddings pour les entités
+        entity_text_combined = " [SEP] ".join(entity_texts)
+        entity_inputs = self.tokenizer(
+            entity_text_combined,
+            padding=True,
+            truncation=True,
+            max_length=256,
+            return_tensors="pt"
+        ).to(self.device)
+        
+        with torch.no_grad():
+            entity_outputs = self.base_model(**entity_inputs)
+            entity_embedding = torch.mean(entity_outputs.last_hidden_state, dim=1)
+        
+        # Fusion pondérée par les scores de confiance
+        avg_confidence = np.mean(confidence_weights) if confidence_weights else 0.5
+        fusion_weight = min(0.4, avg_confidence)  # Max 40% pour les entités
+        
+        enriched_embedding = (1 - fusion_weight) * base_embedding + fusion_weight * entity_embedding
+        
+        return enriched_embedding
+    
+    def cross_encoder_rerank(self, 
+                            query: str, 
+                            candidates: List[Dict],
+                            top_k: int = 3) -> List[Dict]:
+        """Reranking avec cross-encoder pour affiner la sélection"""
+        
+        if len(candidates) <= top_k:
+            return candidates
+        
+        reranked_candidates = []
+        
+        for candidate in candidates:
+            # Création de la paire query-candidate
+            pair_text = f"{query} [SEP] {candidate['document']}"
+            
+            # Tokenisation
+            inputs = self.cross_tokenizer(
+                pair_text,
+                padding=True,
+                truncation=True,
+                max_length=512,
+                return_tensors="pt"
+            ).to(self.device)
+            
+            # Score de similarité cross-encoder
+            with torch.no_grad():
+                outputs = self.cross_model(**inputs)
+                # Utilisation du [CLS] token pour le score de similarité
+                cls_embedding = outputs.last_hidden_state[:, 0, :]
+                similarity_score = torch.sigmoid(torch.mean(cls_embedding)).item()
+            
+            candidate_copy = candidate.copy()
+            candidate_copy['cross_encoder_score'] = similarity_score
+            candidate_copy['final_score'] = (
+                0.6 * candidate['similarity_score'] + 
+                0.4 * similarity_score
+            )
+            
+            reranked_candidates.append(candidate_copy)
+        
+        # Tri par score final
+        reranked_candidates.sort(key=lambda x: x['final_score'], reverse=True)
+        
+        return reranked_candidates[:top_k]
+
+class MedicalTemplateVectorDB:
+    """Base de données vectorielle optimisée pour templates médicaux"""
+    
+    def __init__(self, db_path: str = "./medical_vector_db", collection_name: str = "medical_templates"):
+        self.db_path = db_path
+        self.collection_name = collection_name
+        
+        # ChromaDB avec configuration optimisée
+        self.client = chromadb.PersistentClient(
+            path=db_path,
+            settings=Settings(
+                anonymized_telemetry=False,
+                allow_reset=True
+            )
+        )
+        
+        # Collection avec métrique de distance optimisée
+        try:
+            self.collection = self.client.get_collection(collection_name)
+            logger.info(f"Collection '{collection_name}' chargée")
+        except:
+            self.collection = self.client.create_collection(
+                name=collection_name,
+                metadata={
+                    "hnsw:space": "cosine",
+                    "hnsw:M": 32,              # Connectivité du graphe
+                    "hnsw:ef_construction": 200, # Qualité vs vitesse construction
+                    "hnsw:ef_search": 50       # Qualité vs vitesse recherche
+                }
+            )
+            logger.info(f"Collection '{collection_name}' créée avec optimisations HNSW")
+    
+    def add_template(self, 
+                    template_id: str, 
+                    template_text: str, 
+                    embedding: np.ndarray,
+                    entities: MedicalEntity,
+                    metadata: Dict[str, Any] = None):
+        """Ajoute un template avec métadonnées enrichies par NER"""
+        
+        # Métadonnées automatiques basées sur NER
+        auto_metadata = {
+            "exam_types": [entity[0] for entity in entities.exam_types],
+            "specialties": [entity[0] for entity in entities.specialties],
+            "anatomical_regions": [entity[0] for entity in entities.anatomical_regions],
+            "pathologies": [entity[0] for entity in entities.pathologies],
+            "procedures": [entity[0] for entity in entities.medical_procedures],
+            "text_length": len(template_text),
+            "entity_confidence_avg": np.mean([
+                entity[1] for entity_list in [
+                    entities.exam_types, entities.specialties,
+                    entities.anatomical_regions, entities.pathologies
+                ] for entity in entity_list
+            ]) if any([entities.exam_types, entities.specialties, 
+                      entities.anatomical_regions, entities.pathologies]) else 0.0
+        }
+        
+        if metadata:
+            auto_metadata.update(metadata)
+        
+        self.collection.add(
+            embeddings=[embedding.tolist()],
+            documents=[template_text],
+            metadatas=[auto_metadata],
+            ids=[template_id]
+        )
+        
+        logger.info(f"Template {template_id} ajouté avec métadonnées NER automatiques")
+    
+    def advanced_search(self, 
+                       query_embedding: np.ndarray, 
+                       n_results: int = 10,
+                       entity_filters: Dict[str, List[str]] = None,
+                       confidence_threshold: float = 0.0) -> List[Dict]:
+        """Recherche avancée avec filtres basés sur entités NER"""
+        
+        where_clause = {}
+        
+        # Filtres basés sur entités NER extraites
+        if entity_filters:
+            for entity_type, entity_values in entity_filters.items():
+                if entity_values:
+                    where_clause[entity_type] = {"$in": entity_values}
+        
+        # Filtre par confiance moyenne des entités
+        if confidence_threshold > 0:
+            where_clause["entity_confidence_avg"] = {"$gte": confidence_threshold}
+        
+        results = self.collection.query(
+            query_embeddings=[query_embedding.tolist()],
+            n_results=n_results,
+            where=where_clause if where_clause else None,
+            include=["documents", "metadatas", "distances"]
+        )
+        
+        # Formatage des résultats
+        formatted_results = []
+        for i in range(len(results['ids'][0])):
+            formatted_results.append({
+                'id': results['ids'][0][i],
+                'document': results['documents'][0][i],
+                'metadata': results['metadatas'][0][i],
+                'similarity_score': 1 - results['distances'][0][i],
+                'distance': results['distances'][0][i]
+            })
+        
+        return formatted_results
+
+class AdvancedMedicalTemplateProcessor:
+    """Processeur avancé avec NER fine-tuné et reranking cross-encoder"""
+    
+    def __init__(self, 
+                 base_model: str = "almanach/camembert-bio-base",
+                 db_path: str = "./advanced_medical_vector_db"):
+        
+        self.ner_extractor = AdvancedMedicalNER()
+        self.embedding_generator = AdvancedMedicalEmbedding(base_model)
+        self.vector_db = MedicalTemplateVectorDB(db_path)
+        
+        logger.info("Processeur médical avancé initialisé avec NER fine-tuné et cross-encoder reranking")
+    
+    def process_templates_batch(self, 
+                               templates: List[Dict[str, str]], 
+                               batch_size: int = 8,
+                               fine_tune_ner: bool = False) -> None:
+        """Traitement avancé avec option de fine-tuning NER"""
+        
+        if fine_tune_ner:
+            logger.info("Fine-tuning du modèle NER sur les templates...")
+            self.ner_extractor.fine_tune_on_templates(templates)
+        
+        logger.info(f"Traitement avancé de {len(templates)} templates")
+        
+        for i in tqdm(range(0, len(templates), batch_size), desc="Traitement avancé"):
+            batch = templates[i:i+batch_size]
+            
+            for template in batch:
+                try:
+                    template_id = template['id']
+                    template_text = template['text']
+                    metadata = template.get('metadata', {})
+                    
+                    # NER avancé
+                    entities = self.ner_extractor.extract_entities(template_text)
+                    
+                    # Embedding enrichi
+                    embedding = self.embedding_generator.generate_embedding(template_text, entities)
+                    
+                    # Stockage avec métadonnées NER
+                    self.vector_db.add_template(
+                        template_id=template_id,
+                        template_text=template_text,
+                        embedding=embedding,
+                        entities=entities,
+                        metadata=metadata
+                    )
+                    
+                except Exception as e:
+                    logger.error(f"Erreur traitement template {template.get('id', 'unknown')}: {e}")
+                    continue
+    
+    def find_best_template_with_reranking(self, 
+                                         transcription: str,
+                                         initial_candidates: int = 10,
+                                         final_results: int = 3) -> List[Dict]:
+        """Recherche optimale avec reranking cross-encoder"""
+        
+        # 1. Extraction NER de la transcription
+        query_entities = self.ner_extractor.extract_entities(transcription)
+        
+        # 2. Génération embedding enrichi
+        query_embedding = self.embedding_generator.generate_embedding(transcription, query_entities)
+        
+        # 3. Filtres automatiques basés sur entités extraites
+        entity_filters = {}
+        if query_entities.exam_types:
+            entity_filters['exam_types'] = [entity[0] for entity in query_entities.exam_types]
+        if query_entities.specialties:
+            entity_filters['specialties'] = [entity[0] for entity in query_entities.specialties]
+        if query_entities.anatomical_regions:
+            entity_filters['anatomical_regions'] = [entity[0] for entity in query_entities.anatomical_regions]
+        
+        # 4. Recherche vectorielle initiale
+        initial_candidates_results = self.vector_db.advanced_search(
+            query_embedding=query_embedding,
+            n_results=initial_candidates,
+            entity_filters=entity_filters,
+            confidence_threshold=0.6
+        )
+        
+        # 5. Reranking avec cross-encoder
+        if len(initial_candidates_results) > final_results:
+            final_results_reranked = self.embedding_generator.cross_encoder_rerank(
+                query=transcription,
+                candidates=initial_candidates_results,
+                top_k=final_results
+            )
+        else:
+            final_results_reranked = initial_candidates_results
+        
+        # 6. Enrichissement des résultats avec détails NER
+        for result in final_results_reranked:
+            result['query_entities'] = {
+                'exam_types': query_entities.exam_types,
+                'specialties': query_entities.specialties,
+                'anatomical_regions': query_entities.anatomical_regions,
+                'pathologies': query_entities.pathologies
+            }
+        
+        return final_results_reranked
+
+# Exemple d'utilisation avancée
+def main():
+    """Exemple d'utilisation du système avancé"""
+    
+    # Initialisation du processeur avancé
+    processor = AdvancedMedicalTemplateProcessor()
+    
+    # Traitement des templates avec fine-tuning optionnel
+    sample_templates = [
+        {
+            'id': 'angio_001',
+            'text': """Échographie et doppler artério-veineux des membres inférieurs.
+            Exploration de l'incontinence veineuse superficielle...""",
+            'metadata': {'source': 'angiologie', 'version': '2024'}
+        }
+    ]
+    
+    # Traitement avec fine-tuning NER
+    processor.process_templates_batch(sample_templates, fine_tune_ner=False)
+    
+    # Recherche avec reranking
+    transcription = """madame bacon nicole bilan œdème droit gonalgies ostéophytes
+    incontinence veineuse modérée portions surale droite crurale gauche saphéniennes"""
+    
+    best_matches = processor.find_best_template_with_reranking(
+        transcription=transcription,
+        initial_candidates=15,
+        final_results=3
+    )
+    
+    # Affichage des résultats
+    for i, match in enumerate(best_matches):
+        print(f"\n=== Match {i+1} ===")
+        print(f"Template ID: {match['id']}")
+        print(f"Score final: {match.get('final_score', match['similarity_score']):.4f}")
+        print(f"Score cross-encoder: {match.get('cross_encoder_score', 'N/A')}")
+        print(f"Entités détectées dans la query:")
+        for entity_type, entities in match.get('query_entities', {}).items():
+            if entities:
+                print(f"  - {entity_type}: {[f'{e[0]} ({e[1]:.2f})' for e in entities]}")
+
+if __name__ == "__main__":
+    main()

README.md

@@ -1,12 +1,6 @@
 ---
-title: Medical Agent
-emoji: 🐨
-colorFrom: pink
-colorTo: yellow
+title: medical-agent
+app_file: app2.py
 sdk: gradio
-sdk_version: 5.48.0
-app_file: app.py
-pinned: false
+sdk_version: 5.47.2
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

annotation.py

@@ -0,0 +1,486 @@
+import os
+from dotenv import load_dotenv
+from openai import AzureOpenAI
+import json
+
+load_dotenv()
+
+AZURE_OPENAI_KEY = os.getenv("AZURE_OPENAI_KEY")
+AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
+AZURE_OPENAI_DEPLOYMENT = os.getenv("AZURE_OPENAI_DEPLOYMENT") # deployment name
+AZURE_OPENAI_API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION", "2024-12-01-preview")
+
+# Configure OpenAI for Azure
+client = AzureOpenAI(
+    api_key=AZURE_OPENAI_KEY,
+    api_version=AZURE_OPENAI_API_VERSION,
+    azure_endpoint=AZURE_OPENAI_ENDPOINT
+)
+
+def extract_medical_entities(text: str) -> dict:
+    prompt = f""" You are a medical NER expert. Your task is to extract relevant entities from the given medical report text and return them in a JSON object.
+
+Analyze the text carefully and identify the following fields:
+
+- "exam_types": any type of medical test, examination, or diagnostic method performed on the patient.
+- "specialties": the branch of medicine or medical discipline relevant to the report.
+- "anatomical_regions": specific parts or regions of the body mentioned in the report.
+- "pathologies": diagnosed diseases, disorders, or abnormal medical conditions noted in the report.
+- "procedures": medical interventions, treatments, or actions performed on the patient.
+- "measurements": numerical values or quantities recorded in the report, such as vital signs, lab results, sizes, or pressures.
+- "medications": drugs, therapies, or prescribed substances mentioned in the report.
+- "symptoms": patient-experienced signs or observable indications of a health issue.
+
+Text to analyze:
+\"\"\"
+{text}
+\"\"\"
+
+Return ONLY a valid JSON object with all fields. If a field has no values, return an empty list.
+"""
+
+
+    
+    response = client.chat.completions.create(
+        model=AZURE_OPENAI_DEPLOYMENT,
+        messages=[{"role": "user", "content": prompt}],
+        #temperature=0,
+        #max_tokens=1024
+    )
+    
+    content = response.choices[0].message.content
+    try:
+        return json.loads(content)
+    except json.JSONDecodeError:
+        return {
+            "exam_types": [],
+            "specialties": [],
+            "anatomical_regions": [],
+            "pathologies": [],
+            "procedures": [],
+            "measurements": [],
+            "medications": [],
+            "symptoms": []
+        }
+import json
+
+def save_annotation(text: str, labels: dict, output_file="dataset.jsonl"):
+    record = {
+        "text": text,
+        "labels": labels
+    }
+    # append as one line of JSON
+    with open(output_file, "a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    input_folder = "data_txt"   # 📂 folder containing your .txt files
+    output_file = "dataset.json"
+
+    # Ensure output file is empty before starting
+    open(output_file, "w", encoding="utf-8").close()
+
+    for filename in os.listdir(input_folder):
+        if filename.endswith(".txt"):
+            file_path = os.path.join(input_folder, filename)
+            with open(file_path, "r", encoding="utf-8") as f:
+                transcription = f.read().strip()
+
+            print(f"\n=== Processing {filename} ===")
+            entities = extract_medical_entities(transcription)
+
+            # Save results
+            save_annotation(transcription, entities, output_file=output_file)
+
+            print(f"✅ Saved {filename} → {output_file}")
+"""
+
+
+if __name__ == "__main__":
+    input_folder = "data_txt"   # 📂 folder containing your .txt files
+    output_file = "dataset.json"
+    
+    # Liste des fichiers à exclure
+    excluded_files = {
+         "template7.txt",
+        "template1167.txt", 
+        "template429.txt",
+        "template401.txt",
+        "template367.txt",
+        "template415.txt",
+        "template398.txt",
+        "template1198.txt",
+        "template159.txt",
+        "template165.txt",
+        "template1107.txt",
+        "template449.txt",
+        "template1113.txt",
+        "template313.txt",
+        "template475.txt",
+        "template461.txt",
+        "template307.txt",
+        "template893.txt",
+        "template139.txt",
+        "template887.txt",
+        "template677.txt",
+        "template111.txt",
+        "template105.txt",
+        "template663.txt",
+        "template688.txt",
+        "template850.txt",
+        "template844.txt",
+        "template878.txt",
+        "template16.txt",
+        "template703.txt",
+        "template717.txt",
+        "template924.txt",
+        "template930.txt",
+        "template918.txt",
+        "template1073.txt",
+        "template529.txt",
+        "template1067.txt",
+        "template267.txt",
+        "template501.txt",
+        "template515.txt",
+        "template273.txt",
+        "template298.txt",
+        "template1098.txt",
+        "template1099.txt",
+        "template299.txt",
+        "template514.txt",
+        "template272.txt",
+        "template266.txt",
+        "template500.txt",
+        "template528.txt",
+        "template1066.txt",
+        "template1072.txt",
+        "template919.txt",
+        "template931.txt",
+        "template925.txt",
+        "template716.txt",
+        "template702.txt",
+        "template879.txt",
+        "template845.txt",
+        "template851.txt",
+        "template689.txt",
+        "template104.txt",
+        "template662.txt",
+        "template676.txt",
+        "template110.txt",
+        "template138.txt",
+        "template886.txt",
+        "template892.txt",
+        "template460.txt",
+        "template306.txt",
+        "template312.txt",
+        "template474.txt",
+        "template1112.txt",
+        "template1106.txt",
+        "template448.txt",
+        "template338.txt",
+        "template1110.txt",
+        "template1104.txt",
+        "template304.txt",
+        "template462.txt",
+        "template476.txt",
+        "template310.txt",
+        "template1138.txt",
+        "template489.txt",
+        "template884.txt",
+        "template890.txt",
+        "template648.txt",
+        "template660.txt",
+        "template106.txt",
+        "template112.txt",
+        "template674.txt",
+        "template847.txt",
+        "template853.txt",
+        "template728.txt",
+        "template15.txt",
+        "template714.txt",
+        "template29.txt",
+        "template700.txt",
+        "template933.txt",
+        "template927.txt",
+        "template1064.txt",
+        "template1070.txt",
+        "template258.txt",
+        "template1058.txt",
+        "template270.txt",
+        "template516.txt",
+        "template502.txt",
+        "template264.txt",
+        "template503.txt",
+        "template265.txt",
+        "template271.txt",
+        "template1059.txt",
+        "template517.txt",
+        "template259.txt",
+        "template1071.txt",
+        "template1065.txt",
+        "template926.txt",
+        "template932.txt",
+        "template701.txt",
+        "template715.txt",
+        "template28.txt",
+        "template729.txt",
+        "template14.txt",
+        "template852.txt",
+        "template846.txt",
+        "template113.txt",
+        "template675.txt",
+        "template661.txt",
+        "template107.txt",
+        "template649.txt",
+        "template891.txt",
+        "template885.txt",
+        "template488.txt",
+        "template477.txt",
+        "template1139.txt",
+        "template311.txt",
+        "template305.txt",
+        "template463.txt",
+        "template1105.txt",
+        "template1111.txt",
+        "template339.txt",
+        "template467.txt",
+        "template1129.txt",
+        "template301.txt",
+        "template315.txt",
+        "template473.txt",
+        "template1115.txt",
+        "template1101.txt",
+        "template329.txt",
+        "template498.txt",
+        "template103.txt",
+        "template665.txt",
+        "template671.txt",
+        "template117.txt",
+        "template881.txt",
+        "template659.txt",
+        "template895.txt",
+        "template842.txt",
+        "template856.txt",
+        "template711.txt",
+        "template705.txt",
+        "template38.txt",
+        "template10.txt",
+        "template739.txt",
+        "template936.txt",
+        "template922.txt",
+        "template513.txt",
+        "template275.txt",
+        "template261.txt",
+        "template1049.txt",
+        "template507.txt",
+        "template249.txt",
+        "template1061.txt",
+        "template1075.txt",
+        "template1074.txt",
+        "template1060.txt",
+        "template248.txt",
+        "template1048.txt",
+        "template260.txt",
+        "template506.txt",
+        "template512.txt",
+        "template274.txt",
+        "template923.txt",
+        "template937.txt",
+        "template738.txt",
+        "template11.txt",
+        "template704.txt",
+        "template710.txt",
+        "template857.txt",
+        "template843.txt",
+        "template894.txt",
+        "template658.txt",
+        "template880.txt",
+        "template670.txt",
+        "template116.txt",
+        "template102.txt",
+        "template664.txt",
+        "template499.txt",
+        "template328.txt",
+        "template1100.txt",
+        "template1114.txt",
+        "template314.txt",
+        "template472.txt",
+        "template466.txt",
+        "template300.txt",
+        "template1128.txt",
+        "template470.txt",
+        "template316.txt",
+        "template302.txt",
+        "template464.txt",
+        "template1102.txt",
+        "template1116.txt",
+        "template458.txt",
+        "template114.txt",
+        "template672.txt",
+        "template666.txt",
+        "template100.txt",
+        "template128.txt",
+        "template896.txt",
+        "template882.txt",
+        "template869.txt",
+        "template855.txt",
+        "template699.txt",
+        "template841.txt",
+        "template706.txt",
+        "template712.txt",
+        "template13.txt",
+        "template909.txt",
+        "template921.txt",
+        "template935.txt",
+        "template504.txt",
+        "template262.txt",
+        "template276.txt",
+        "template510.txt",
+        "template538.txt",
+        "template1076.txt",
+        "template1062.txt",
+        "template1089.txt",
+        "template289.txt",
+        "template288.txt",
+        "template1088.txt",
+        "template1063.txt",
+        "template539.txt",
+        "template1077.txt",
+        "template277.txt",
+        "template511.txt",
+        "template505.txt",
+        "template263.txt",
+        "template934.txt",
+        "template920.txt",
+        "template908.txt",
+        "template12.txt",
+        "template713.txt",
+        "template707.txt",
+        "template840.txt",
+        "template698.txt",
+        "template854.txt",
+        "template868.txt",
+        "template883.txt",
+        "template129.txt",
+        "template897.txt",
+        "template667.txt",
+        "template101.txt",
+        "template115.txt",
+        "template673.txt",
+        "template1117.txt",
+        "template459.txt",
+        "template1103.txt",
+        "template303.txt",
+        "template465.txt",
+        "template471.txt",
+        "template317.txt",
+        "template4.txt",
+        "template1164.txt",
+        "template1170.txt",
+        "template358.txt",
+        "template416.txt",
+        "template1158.txt",
+        "template370.txt",
+        "template364.txt",
+        "template402.txt",
+        "template628.txt",
+        "template172.txt",
+        "template614.txt",
+        "template600.txt",
+        "template166.txt",
+        "template833.txt",
+        "template827.txt",
+        "template199.txt",
+        "template61.txt",
+        "template1212.txt",
+        "template984.txt",
+        "template748.txt",
+        "template990.txt",
+        "template75.txt",
+        "template1206.txt",
+        "template760.txt",
+        "template774.txt",
+        "template49.txt",
+        "template947.txt",
+        "template953.txt",
+        "template238.txt",
+        "template1010.txt",
+        "template1004.txt",
+        "template562.txt",
+        "template204.txt",
+        "template210.txt",
+        "template1038.txt",
+        "template576.txt",
+        "template589.txt",
+        "template588.txt",
+        "template1039.txt",
+        "template211.txt",
+        "template577.txt",
+        "template563.txt",
+        "template205.txt",
+        "template1005.txt",
+        "template1011.txt",
+        "template239.txt",
+        "template952.txt",
+        "template946.txt",
+        "template775.txt",
+        "template48.txt",
+        "template761.txt",
+        "template991.txt",
+        "template749.txt",
+        "template1207.txt",
+        "template74.txt",
+        "template1213.txt",
+        "template60.txt",
+        "template985.txt",
+        "template826.txt",
+        "template198.txt",
+        "template832.txt",
+        "template601.txt",
+        "template167.txt",
+        "template173.txt",
+        "template615.txt",
+        "template629.txt",
+        "template365.txt",
+        "template403.txt",
+        "template417.txt",
+        "template371.txt",
+        "template1159.txt",
+        "template359.txt",
+        "template1171.txt",
+        "template1165.txt",
+        "template5.txt",
+        "template1173.txt",
+        "template373.txt"
+    }
+
+    # Ensure output file is empty before starting
+    open(output_file, "w", encoding="utf-8").close()
+
+    processed_count = 0
+    excluded_count = 0
+
+    for filename in os.listdir(input_folder):
+        if filename.endswith(".txt"):
+            # Vérifier si le fichier est dans la liste d'exclusion
+            if filename in excluded_files:
+                print(f"⏭️  Fichier exclu : {filename}")
+                excluded_count += 1
+                continue
+                
+            file_path = os.path.join(input_folder, filename)
+            with open(file_path, "r", encoding="utf-8") as f:
+                transcription = f.read().strip()
+
+            print(f"\n=== Processing {filename} ===")
+            entities = extract_medical_entities(transcription)
+
+            # Save results
+            save_annotation(transcription, entities, output_file=output_file)
+
+            print(f"✅ Saved {filename} → {output_file}")
+            processed_count += 1
+
+    print(f"\n📊 Résumé : {processed_count} fichiers traités, {excluded_count} fichiers exclus")
+"""

app.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+Interface Gradio : Agent NER médical + Mapper
+Input transcription → Extraction → Mapping → Rapport
+"""
+import gradio as gr
+from type3_extract_entities import MedicalNERAgent
+from medical_template3_mapper import MedicalTemplateMapper
+from type3_preprocessing import MedicalTranscriptionProcessor, AZURE_OPENAI_DEPLOYMENT
+from post_processing import post_process_medical_report
+def process_transcription(transcription: str):
+    try:
+        #Étape 1 correction asr
+        processor = MedicalTranscriptionProcessor(AZURE_OPENAI_DEPLOYMENT)
+        result = processor.process_transcription(transcription)
+        corrected_transcription=result.final_corrected_text
+        # Étape 1 : Extraction
+        
+        agent = MedicalNERAgent()
+        extracted_data = agent.extract_medical_entities(corrected_transcription)
+        extraction_report = agent.print_extraction_report(extracted_data)
+
+        # Étape 2 : Mapping vers template
+        mapper = MedicalTemplateMapper()
+        mapping_result = mapper.map_extracted_data_to_template(extracted_data)
+        #mapping_report = mapper.print_mapping_report(mapping_result)
+        mapping_report = mapper.template
+
+        # Étape 3 : Rapport final rempli
+        rapport_final = mapping_result.filled_template
+
+        #Étape 4: nettoyage du rapport 
+        cleaned_report = post_process_medical_report(rapport_final)
+
+        return corrected_transcription,extraction_report, mapping_report, cleaned_report
+    except Exception as e:
+        return f"Erreur: {e}", "", ""
+
+# Interface Gradio
+demo = gr.Interface(
+    fn=process_transcription,
+    inputs=gr.Textbox(lines=15, label="Transcription médicale"),
+    outputs=[
+        gr.Textbox(lines=20, label="🔬 Crorrection de la transcription"),
+        gr.Textbox(lines=20, label="📋 Extraction structurée"),
+        gr.Textbox(lines=20, label="📋 Rapport à remplir (Mapping)"),
+        gr.Textbox(lines=20, label="✅ Compte-rendu structuré final"),
+    ],
+    title="🏥 Génération de comptes-rendus structurés",
+)
+
+if __name__ == "__main__":
+    demo.launch(share=True)

app2.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Interface Gradio : Transcription médicale → Correction → Matching → Rapport
+"""
+import gradio as gr
+import sys
+import os
+
+# Fix pour le problème de pickle avec TemplateInfo
+import template_db_creation
+sys.modules['__main__'].TemplateInfo = template_db_creation.TemplateInfo
+
+from template_db_creation import MedicalTemplateParser
+from smart_match import TranscriptionMatcher
+from correcteur import MedicalTranscriptionProcessor, AZURE_OPENAI_DEPLOYMENT
+
+# Chemin hardcodé vers la base de données
+DB_PATH = "/Users/macbook/medical-agent/medical-agent/templates/medical_templates.pkl"
+
+# Variables globales
+parser = None
+matcher = None
+
+def initialize_system():
+    """Initialise le système au démarrage"""
+    global parser, matcher
+    
+    try:
+        print(f"📂 Chargement de la base de données: {DB_PATH}")
+        parser = MedicalTemplateParser()
+        parser.load_database(DB_PATH)
+        
+        matcher = TranscriptionMatcher(parser)
+        
+        print(f"✅ Système initialisé avec {len(parser.templates)} templates")
+        return True
+    except Exception as e:
+        print(f"❌ Erreur initialisation: {e}")
+        return False
+
+def process_transcription(transcription: str):
+    """
+    Traite la transcription médicale complète
+    
+    Args:
+        transcription: Texte de la transcription
+        
+    Returns:
+        Tuple (transcription_corrigée, template_vide, rapport_final)
+    """
+    try:
+        # Étape 1: Correction ASR
+        print("🔧 Étape 1: Correction de la transcription...")
+        processor = MedicalTranscriptionProcessor(AZURE_OPENAI_DEPLOYMENT)
+        result = processor.process_transcription(transcription)
+        corrected_transcription = result.final_corrected_text
+        
+        # Étape 2: Matching et remplissage du template
+        print("🔍 Étape 2: Recherche du template approprié...")
+        results = matcher.match_and_fill(corrected_transcription, return_top_k=1)
+        
+        if not results:
+            return (
+                corrected_transcription,
+                "❌ Aucun template approprié trouvé",
+                "❌ Impossible de générer le rapport"
+            )
+        
+        best_result = results[0]
+        
+        # Préparer le template vide avec toutes les informations
+        template_vide = f"{best_result.template_id}\n"
+        template_vide += "=" * len(best_result.template_id) + "\n"
+        template_vide += best_result.template_content
+        
+        # Préparer le rapport final rempli avec toutes les sections
+        rapport_final = f"{best_result.template_id}\n"
+        rapport_final += "=" * len(best_result.template_id) + "\n"
+        
+        # Ajouter toutes les sections remplies
+        rapport_final += best_result.filled_template
+
+        
+        print(f"✅ Traitement terminé - Template: {best_result.template_id}")
+        
+        return corrected_transcription, template_vide, rapport_final
+        
+    except Exception as e:
+        error_msg = f"❌ Erreur: {str(e)}"
+        print(error_msg)
+        return error_msg, "", ""
+
+# Initialiser le système au démarrage
+print("🚀 Initialisation du système...")
+if not initialize_system():
+    print("⚠️ Erreur lors de l'initialisation - vérifiez le chemin de la DB")
+
+# Interface Gradio
+demo = gr.Interface(
+    fn=process_transcription,
+    inputs=gr.Textbox(
+        lines=15, 
+        label="📝 Transcription médicale",
+        placeholder="Collez ici la transcription de l'examen médical..."
+    ),
+    outputs=[
+        gr.Textbox(lines=20, label="✅ Transcription corrigée", show_copy_button=True),
+        gr.Textbox(lines=20, label="📋 Rapport à remplir (Template)", show_copy_button=True),
+        gr.Textbox(lines=20, label="📄 Compte-rendu structuré final", show_copy_button=True),
+    ],
+    title="🏥 Génération de comptes-rendus structurés",
+
+)
+
+if __name__ == "__main__":
+    demo.launch(share=True)

correcteur.py

@@ -0,0 +1,751 @@
+import spacy
+import openai
+import re
+from typing import Dict, List, Tuple
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
+import os
+from dotenv import load_dotenv
+from openai import AzureOpenAI
+from medkit.core.text import TextDocument
+from medkit.text.ner.hf_entity_matcher import HFEntityMatcher
+
+NER_MODEL = os.getenv("NER_MODEL", "medkit/DrBERT-CASM2")
+
+# Charger les variables d'environnement depuis .env
+load_dotenv()
+
+# Récupération des paramètres
+AZURE_OPENAI_KEY = os.getenv("AZURE_OPENAI_KEY")
+AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
+AZURE_OPENAI_DEPLOYMENT = os.getenv("AZURE_OPENAI_DEPLOYMENT")
+AZURE_OPENAI_API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION", "2024-05-01-preview")
+
+# Validation des variables d'environnement
+def validate_azure_config():
+    """Valide que toutes les variables Azure sont configurées"""
+    missing_vars = []
+    if not AZURE_OPENAI_KEY:
+        missing_vars.append("AZURE_OPENAI_KEY")
+    if not AZURE_OPENAI_ENDPOINT:
+        missing_vars.append("AZURE_OPENAI_ENDPOINT")
+    if not AZURE_OPENAI_DEPLOYMENT:
+        missing_vars.append("AZURE_OPENAI_DEPLOYMENT")
+    
+    if missing_vars:
+        print(f"❌ Variables d'environnement manquantes: {', '.join(missing_vars)}")
+        print("📝 Veuillez créer un fichier .env avec:")
+        for var in missing_vars:
+            print(f"   {var}=votre_valeur")
+        return False
+    return True
+
+# Client Azure OpenAI avec validation
+azure_client = None
+if validate_azure_config():
+    try:
+        azure_client = AzureOpenAI(
+            api_key=AZURE_OPENAI_KEY,
+            api_version=AZURE_OPENAI_API_VERSION,
+            azure_endpoint=AZURE_OPENAI_ENDPOINT,
+        )
+        print("✅ Client Azure OpenAI initialisé avec succès")
+    except Exception as e:
+        print(f"❌ Erreur lors de l'initialisation du client Azure OpenAI: {e}")
+        azure_client = None
+
+ner_matcher = HFEntityMatcher(model=NER_MODEL)
+
+@dataclass
+class CorrectionResult:
+    original_text: str
+    ner_corrected_text: str
+    final_corrected_text: str
+    medical_entities: List[Dict]
+    confidence_score: float
+
+class MedicalNERCorrector:
+    """Correcteur orthographique basé sur un NER médical français"""
+    
+    def __init__(self):
+        try:
+            # Charger le modèle MedKit NER
+            self.matcher = HFEntityMatcher(model=NER_MODEL)
+            print(f"✅ Modèle NER '{NER_MODEL}' chargé avec succès")
+        except Exception as e:
+            print(f"❌ Erreur lors du chargement du modèle NER {NER_MODEL}: {e}")
+            self.matcher = None
+        
+        # Dictionnaire complet pour convertir tous les nombres en lettres vers chiffres
+        self.number_corrections = {
+
+            
+            # Variantes courantes dans les transcriptions vocales
+            "1": "1", "1er": "1", "première": "1", "premier": "1",
+            "2ème": "2", "deuxième": "2", "second": "2", "seconde": "2",
+            "3ème": "3", "troisième": "3", "4ème": "4", "quatrième": "4",
+            "5ème": "5", "cinquième": "5", "6ème": "6", "sixième": "6",
+            "7ème": "7", "septième": "7", "8ème": "8", "huitième": "8",
+            "9ème": "9", "neuvième": "9", "10ème": "10", "dixième": "10",
+        }
+        
+        # Dictionnaire de corrections pour transcriptions vocales - ORDRE IMPORTANT
+        self.vocal_corrections = {
+            # Corrections de ponctuation - doivent être traitées en premier
+            "point à la ligne": ".\n",
+            "retour à la ligne": "\n",
+            "à la ligne": "\n",
+            "nouvelle ligne": "\n",
+            "saut de ligne": "\n",
+            "point virgule": ";",
+            "deux points": ":",
+            "point d'interrogation": "?",
+            "point d'exclamation": "!",
+            "virgule": ",",
+            "point": ".",  # Doit être traité en dernier pour éviter les conflits
+            
+            # Corrections des séquences IRM
+            "T un": "T1", "T deux": "T2", "T trois": "T3",
+            "t un": "T1", "t deux": "T2", "t trois": "T3",
+            "séquence T un": "séquence T1", "séquence T deux": "séquence T2",
+            
+            # Corrections des niveaux vertébraux - cervicaux
+            "C un": "C1", "C deux": "C2", "C trois": "C3", "C quatre": "C4",
+            "C cinq": "C5", "C six": "C6", "C sept": "C7",
+            "c un": "C1", "c deux": "C2", "c trois": "C3", "c quatre": "C4", 
+            "c cinq": "C5", "c six": "C6", "c sept": "C7",
+            
+            # Niveaux thoraciques
+            "T un": "T1", "T deux": "T2", "T trois": "T3", "T quatre": "T4",
+            "T cinq": "T5", "T six": "T6", "T sept": "T7", "T huit": "T8",
+            "T neuf": "T9", "T dix": "T10", "T onze": "T11", "T douze": "T12",
+            
+            # Niveaux lombaires
+            "L un": "L1", "L deux": "L2", "L trois": "L3", "L quatre": "L4", "L cinq": "L5",
+            "l un": "L1", "l deux": "L2", "l trois": "L3", "l quatre": "L4", "l cinq": "L5",
+            
+            # Niveaux sacrés
+            "S un": "S1", "S deux": "S2", "S trois": "S3", "S quatre": "S4", "S cinq": "S5",
+            "s un": "S1", "s deux": "S2", "s trois": "S3", "s quatre": "S4", "s cinq": "S5",
+        }
+        
+        # Dictionnaire de corrections médicales spécialisées - orthographe
+        self.medical_corrections = {
+            # Anatomie
+            "rachis": ["rachis", "rachi", "rachys", "rahis", "raxis"],
+            "cervical": ["cervical", "cervicale", "cervicaux", "servical", "servicale"],
+            "vertébraux": ["vertébraux", "vertebraux", "vertébrau", "vertébral", "vertebral"],
+            "médullaire": ["médullaire", "medullaire", "medulaire", "médulaire"],
+            "foraminal": ["foraminal", "foraminale", "foraminaux", "forraminal"],
+            "postérolatéral": ["postérolatéral", "posterolatéral", "postero-latéral", "postero latéral"],
+            "antérolatéral": ["antérolatéral", "anterolatéral", "antero-latéral", "antero latéral"],
+            "longitudinal": ["longitudinal", "longitudinale", "longitudinaux"],
+            
+            # Pathologies
+            "uncarthrose": ["uncarthrose", "uncoarthrose", "uncartrose", "unkarthrose"],
+            "lordose": ["lordose", "lordoze", "lordosse", "lordosse"],
+            "cyphose": ["cyphose", "siphose", "kyphose", "kiphose"],
+            "scoliose": ["scoliose", "skoliose", "scholiose"],
+            "discopathie": ["discopathie", "disccopathie", "discopatie"],
+            "discal": ["discal", "discale", "diskal", "diskale", "disque"],
+            "hernie": ["hernie", "herny", "herni"],
+            "protrusion": ["protrusion", "protusion", "protruzion"],
+            "sténose": ["sténose", "stenose", "sténoze"],
+            "arthrose": ["arthrose", "artrose", "arthroze"],
+            "ostéophyte": ["ostéophyte", "osteophyte", "ostéofite"],
+            "ligamentaire": ["ligamentaire", "ligamentere", "ligamentair"],
+            
+            # Techniques et examens
+            "sagittal": ["sagittal", "sagittale", "sagital", "sagittaux"],
+            "coronal": ["coronal", "coronale", "coronaux"],
+            "axial": ["axial", "axiale", "axiaux", "axial"],
+            "transversal": ["transversal", "transversale", "transversaux"],
+            "pondéré": ["pondéré", "pondéré", "pondere", "pondérée"],
+            "séquence": ["séquence", "sequence", "sekence"],
+            "contraste": ["contraste", "contraste", "kontraste"],
+            "gadolinium": ["gadolinium", "gadoliniun", "gadoliniom"],
+            
+            # Mesures et directions
+            "millimètre": ["millimètre", "millimetre", "mm"],
+            "centimètre": ["centimètre", "centimetre", "cm"],
+            "gauche": ["gauche", "gosh", "goshe", "goche"],
+            "droite": ["droite", "droitte", "droithe", "droitr"],
+            "antérieur": ["antérieur", "anterieur", "antérieure", "anterieure"],
+            "postérieur": ["postérieur", "posterieur", "postérieure", "posterieure"],
+            "supérieur": ["supérieur", "superieur", "supérieure", "superieure"],
+            "inférieur": ["inférieur", "inferieur", "inférieure", "inferieure"],
+            "médian": ["médian", "median", "mediane", "médiane"],
+            "latéral": ["latéral", "lateral", "laterale", "latérale"],
+            
+            # Signaux et aspects
+            "signal": ["signal", "signale", "signa", "signaux"],
+            "hypersignal": ["hypersignal", "hyper signal", "hypersignale"],
+            "hyposignal": ["hyposignal", "hypo signal", "hyposignale"],
+            "isosignal": ["isosignal", "iso signal", "isosignale"],
+            "hétérogène": ["hétérogène", "heterogene", "hétérogène"],
+            "homogène": ["homogène", "homogene", "omogene"],
+            
+            # Autres termes fréquents
+            "dimension": ["dimension", "dimention", "dimmension"],
+            "normale": ["normale", "normal", "normalle"],
+            "anomalie": ["anomalie", "annomalie", "anomaly"],
+            "décelable": ["décelable", "decelabl", "décellabl"],
+            "absence": ["absence", "abscence", "absance"],
+            "présence": ["présence", "presence", "presance"],
+            "contact": ["contact", "contacte", "kontak"],
+            "compression": ["compression", "compresion", "kompression"],
+        }
+        
+        # Expressions régulières pour les patterns médicaux
+        self.medical_patterns = {
+            "vertebral_level": r"[CTLS]\d+[\s-]*[CTLS]\d+",
+            "measurement": r"\d+[\s]*[x×]\s*\d+\s*mm",
+            "technique": r"T[1-3]",
+        }
+
+    def convert_numbers_to_digits(self, text: str) -> str:
+        """Convertit TOUS les nombres en lettres vers des chiffres"""
+        corrected_text = text
+        
+        # ÉTAPE 1: Gestion spéciale des mesures médicales communes
+        medical_measures = {
+            # Mesures d'utérus courantes
+            "sept point huit": "7,8",
+            "trois sept": "3,7",   
+            "soixante douze": "72",
+            "soixante treize": "73",
+            "soixante quatorze": "74",
+            "soixante quinze": "75",
+            "soixante seize": "76",
+            "soixante dix sept": "77",
+            "soixante dix huit": "78",
+            "soixante dix neuf": "79",
+    
+            
+            # Mesures d'ovaires courantes  
+            "vingt six": "26",
+            
+            "vingt cinq": "25",
+            "dix neuf": "19",
+            "vingt deux": "22",
+            
+            # Mesures Doppler
+            "trois vingt quatre": "3,24",  # IP
+            "quatre vingt onze": "0,91",   # IR (avec virgule décimale)
+            
+            # Autres mesures courantes
+            "quinze": "15",
+        }
+        
+        # Application des mesures médicales en premier
+        for word_measure, digit_measure in medical_measures.items():
+            pattern = r'\b' + re.escape(word_measure) + r'\b'
+            corrected_text = re.sub(pattern, digit_measure, corrected_text, flags=re.IGNORECASE)
+        
+        # ÉTAPE 2: Traitement des nombres composés restants
+        compound_without_dash = {
+        "vingt un": "21", "vingt deux": "22", "vingt trois": "23", "vingt quatre": "24",
+        "vingt cinq": "25", "vingt six": "26", "vingt sept": "27", "vingt huit": "28",
+        "vingt neuf": "29", "trente un": "31", "trente deux": "32", "trente trois": "33",
+        "trente quatre": "34", "trente cinq": "35", "trente six": "36", "trente sept": "37",
+        "trente huit": "38", "trente neuf": "39", "quarante un": "41", "quarante deux": "42",
+        "quarante trois": "43", "quarante quatre": "44", "quarante cinq": "45",
+        "quarante six": "46", "quarante sept": "47", "quarante huit": "48", "quarante neuf": "49",
+        "cinquante un": "51", "cinquante deux": "52", "cinquante trois": "53",
+        "cinquante quatre": "54", "cinquante cinq": "55", "cinquante six": "56",
+        "cinquante sept": "57", "cinquante huit": "58", "cinquante neuf": "59",
+        "soixante un": "61", "soixante deux": "62", "soixante trois": "63",
+        "soixante quatre": "64", "soixante cinq": "65", "soixante six": "66",
+        "soixante sept": "67", "soixante huit": "68", "soixante neuf": "69",
+        "soixante et onze": "71", "soixante douze": "72", "soixante treize": "73",
+        "soixante quatorze": "74", "soixante quinze": "75", "soixante seize": "76",
+        "soixante dix sept": "77", "soixante dix huit": "78", "soixante dix neuf": "79",
+        "quatre vingt un": "81", "quatre vingt deux": "82", "quatre vingt trois": "83",
+        "quatre vingt quatre": "84", "quatre vingt cinq": "85", "quatre vingt six": "86",
+        "quatre vingt sept": "87", "quatre vingt huit": "88", "quatre vingt neuf": "89",
+        "quatre vingt onze": "91", "quatre vingt douze": "92", "quatre vingt treize": "93",
+        "quatre vingt quatorze": "94", "quatre vingt quinze": "95", "quatre vingt seize": "96",
+        "quatre vingt dix sept": "97", "quatre vingt dix huit": "98", "quatre vingt dix neuf": "99",
+
+        }
+        
+        for word, digit in compound_without_dash.items():
+            # Protection : ne remplace PAS si suivi de "fois" ET d'un autre nombre
+            pattern = r'\b' + re.escape(word) + r'\b(?!\s+fois\s+\w+)'
+            corrected_text = re.sub(pattern, digit, corrected_text, flags=re.IGNORECASE)
+        
+        # ÉTAPE 3: Nombres simples (ordre modifié pour éviter les conflits)
+        simple_numbers = {
+            "zéro": "0", "deux": "2", "trois": "3", "quatre": "4", 
+            "cinq": "5", "six": "6", "sept": "7", "huit": "8", "neuf": "9", 
+            "dix": "10", "onze": "11", "douze": "12", "treize": "13", "quatorze": "14",
+            "quinze": "15", "seize": "16", "dix-sept": "17", "dix-huit": "18", 
+            "dix-neuf": "19", "vingt": "20", "trente": "30", "quarante": "40",
+            "cinquante": "50", "soixante-dix": "70", 
+            "quatre-vingts": "80", "quatre-vingt": "80", "quatre-vingt-dix": "90",
+            "cent": "100", "mille": "1000",
+        }
+        
+        # Conversion des nombres simples
+        for word_number, digit in simple_numbers.items():
+            pattern = r'\b' + re.escape(word_number) + r'\b'
+            corrected_text = re.sub(pattern, digit, corrected_text, flags=re.IGNORECASE)
+
+        corrected_text = re.sub(r'\bpour\s+cent\b', '%', corrected_text, flags=re.IGNORECASE)
+        
+        return corrected_text
+
+    def extract_medical_entities(self, text: str):
+        """Extrait les entités médicales avec MedKit HFEntityMatcher"""
+        if not self.matcher:
+            return []
+        doc = TextDocument(text)
+        entities = self.matcher.run([doc.raw_segment])
+        # Transformer en format simple
+        formatted_entities = []
+        for ent in entities:
+            formatted_entities.append({
+                "text": ent.text,
+                "label": ent.label,
+            })
+        return formatted_entities
+    
+    def correct_vocal_transcription(self, text: str) -> str:
+        """Corrige les transcriptions vocales avec un ordre de priorité strict"""
+        corrected_text = text
+        
+        # ÉTAPE 1: Conversion des nombres AVANT tout le reste
+        corrected_text = self.convert_numbers_to_digits(corrected_text)
+        
+        # ÉTAPE 2: Corrections des expressions vocales dans l'ordre de priorité
+        # L'ordre est CRUCIAL pour éviter les conflits
+        priority_corrections = [
+            # Expressions de ponctuation complexes en premier
+            ("point à la ligne", ".\n"),
+            ("retour à la ligne", "\n"),
+            ("à la ligne", "\n"),
+            ("nouvelle ligne", "\n"),
+            ("saut de ligne", "\n"),
+            ("point virgule", ";"),
+            ("deux points", ":"),
+            ("point d'interrogation", "?"),
+            ("point d'exclamation", "!"),
+            
+            # Niveaux vertébraux avec nombres
+            ("C 1", "C1"), ("C 2", "C2"), ("C 3", "C3"), ("C 4", "C4"),
+            ("C 5", "C5"), ("C 6", "C6"), ("C 7", "C7"),
+            ("L 1", "L1"), ("L 2", "L2"), ("L 3", "L3"), ("L 4", "L4"), ("L 5", "L5"),
+            ("T 1", "T1"), ("T 2", "T2"), ("T 3", "T3"), ("T 4", "T4"),
+            ("T 5", "T5"), ("T 6", "T6"), ("T 7", "T7"), ("T 8", "T8"),
+            ("T 9", "T9"), ("T 10", "T10"), ("T 11", "T11"), ("T 12", "T12"),
+            
+            # Séquences IRM
+            ("séquence T 1", "séquence T1"), ("séquence T 2", "séquence T2"),
+            
+            # Virgule et point en dernier pour éviter les conflits
+            ("virgule", ","),
+        ]
+        
+        for vocal_term, replacement in priority_corrections:
+            # Utilisation de word boundaries pour éviter les remplacements partiels
+            pattern = r'\b' + re.escape(vocal_term) + r'\b'
+            corrected_text = re.sub(pattern, replacement, corrected_text, flags=re.IGNORECASE)
+        
+        # ÉTAPE 3: Correction spéciale pour "point" - seulement si c'est vraiment une fin de phrase
+        # Pattern pour détecter "point" suivi d'un espace et d'une majuscule OU en fin de texte
+        corrected_text = re.sub(r'\bpoint(?!\s+(?:à|d\'|virgule))', '.', corrected_text, flags=re.IGNORECASE)
+        
+        return corrected_text
+
+    def correct_medical_terms(self, text: str) -> str:
+        """Corrige les termes médicaux basés sur le dictionnaire"""
+        corrected_text = text
+        
+        for correct_term, variations in self.medical_corrections.items():
+            for variation in variations:
+                if variation != correct_term:  # Éviter de remplacer par lui-même
+                    # Correction avec préservation de la casse du premier caractère
+                    pattern = r'\b' + re.escape(variation) + r'\b'
+                    
+                    def replace_with_case(match):
+                        matched_text = match.group(0)
+                        if matched_text[0].isupper():
+                            return correct_term.capitalize()
+                        return correct_term
+                    
+                    corrected_text = re.sub(pattern, replace_with_case, corrected_text, flags=re.IGNORECASE)
+        
+        return corrected_text
+
+    def normalize_medical_patterns(self, text: str) -> str:
+        """Normalise les patterns médicaux avec gestion des mesures"""
+        normalized_text = text
+
+        # Gestion spéciale des mesures avec "fois" (dimensions)
+        # Pattern: nombre fois nombre -> nombre x nombre
+        normalized_text = re.sub(r'(\d+(?:[.,]\d+)?)\s+fois\s+(\d+(?:[.,]\d+)?)', r'\1 x \2', normalized_text, flags=re.IGNORECASE)
+
+        # Normalisation des niveaux vertébraux (ex: C5 C6 -> C5-C6, C5c6 -> C5-C6)
+        normalized_text = re.sub(r'([CTLS])(\d)\s*([CTLS])?(\d)', lambda m: f"{m.group(1)}{m.group(2)}-{m.group(1)}{m.group(4)}", normalized_text, flags=re.IGNORECASE)
+
+        # Normalisation des mesures existantes (ex: 72x40mm -> 72 x 40 mm)
+        normalized_text = re.sub(r'(\d+(?:[.,]\d+)?)\s*[x×]\s*(\d+(?:[.,]\d+)?)\s*mm', r'\1 x \2 mm', normalized_text)
+
+        # Ajout automatique de l'unité mm pour les mesures sans unité (nombre x nombre -> nombre x nombre mm)
+        normalized_text = re.sub(r'(\d+(?:[.,]\d+)?)\s*x\s*(\d+(?:[.,]\d+)?)(?!\s*(?:mm|cm))', r'\1 x \2 mm', normalized_text, flags=re.IGNORECASE)
+
+        # Normalisation des millimètres écrits en toutes lettres
+        normalized_text = re.sub(r'(\d+(?:[.,]\d+)?)\s*millimètres?', r'\1 mm', normalized_text, flags=re.IGNORECASE)
+
+        # Gestion des mesures d'hystérométrie (format spécial)
+        normalized_text = re.sub(r"d['’]?hystérométrie\s+(\d+(?:[.,]\d+)?)", r"d'hystérométrie : \1 mm", normalized_text, flags=re.IGNORECASE)
+
+        # Gestion des mesures d'endomètre
+        normalized_text = re.sub(r"d['’]?endomètre\s+(\d+(?:[.,]\d+)?)", r"d'endometre : \1 mm", normalized_text, flags=re.IGNORECASE)
+
+        # Gestion du CFA (Compte Folliculaire Antral)
+        normalized_text = re.sub(r'(\d+)\s+follicules', r'CFA \1 follicules', normalized_text, flags=re.IGNORECASE)
+
+        normalized_text = re.sub(r'\bmm\s+millimètres?\b', 'mm', normalized_text, flags=re.IGNORECASE)
+        normalized_text = re.sub(r'\bmillimètres?\s+mm\b', 'mm', normalized_text, flags=re.IGNORECASE)
+
+        return normalized_text
+
+    def clean_spacing_and_formatting(self, text: str) -> str:
+        """Nettoie les espaces et améliore le formatage avec ajouts spécifiques"""
+        # Supprime les espaces multiples mais préserve les sauts de ligne
+        text = re.sub(r'[ \t]+', ' ', text)
+        
+        # AJOUT: Corrections spécifiques pour les mesures
+        # Corrige "7. 8" -> "7,8" (décimales)
+        text = re.sub(r'(\d+)\.\s+(\d+)(?!\s*(?:mm|cm|fois|x))', r'\1,\2', text)
+        
+        # Corrige "20 6" -> "26" quand c'est clairement un nombre
+        text = re.sub(r'\b20\s+6\b', '26', text)
+        text = re.sub(r'\b20\s+5\b', '25', text) 
+        text = re.sub(r'\b10\s+9\b', '19', text)
+        text = re.sub(r'\b20\s+2\b', '22', text)
+        text = re.sub(r'\b20\s+7\b', '27', text)  
+        text = re.sub(r'\b3\s+20\s+4\b', '3,24', text)  
+        text = re.sub(r'\b4\s+20\s+11\b', '0,91', text)  
+        
+        # Corrige la ponctuation (supprime l'espace avant les points, virgules)
+        text = re.sub(r'\s+([.,:;!?])', r'\1', text)
+        
+        # Ajoute un espace après la ponctuation si nécessaire (sauf si suivi d'un saut de ligne)
+        text = re.sub(r'([.,:;!?])([A-Za-z])', r'\1 \2', text)
+        
+        # AJOUT: Correction des apostrophes
+        text = re.sub(r'\bl\s+([aeiouAEIOU])', r"l'\1", text)  # l ovaire -> l'ovaire
+        text = re.sub(r'\bd\s+([aeiouAEIOU])', r"d'\1", text)  # d hystérométrie -> d'hystérométrie
+        
+        # Nettoie les sauts de ligne multiples (max 2 consécutifs)
+        text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)
+        
+        # Supprime les espaces en début et fin de ligne
+        lines = text.split('\n')
+        lines = [line.strip() for line in lines]
+        text = '\n'.join(lines)
+        
+        # Capitalise après les points suivis d'un espace
+        text = re.sub(r'(\.\s+)([a-z])', lambda m: m.group(1) + m.group(2).upper(), text)
+        
+        # Capitalise le début du texte
+        if text and text[0].islower():
+            text = text[0].upper() + text[1:]
+        
+        return text.strip()
+    def post_process_gynecology_report(self, text: str) -> str:
+        """Post-traitement spécialisé pour les rapports gynécologiques"""
+        processed_text = text
+        
+        # Structuration des mesures d'utérus
+        processed_text = re.sub(
+            r'utérus est (\w+)\s+(\d+,\d+)', 
+            r'utérus est \1 de taille \2 cm', 
+            processed_text, 
+            flags=re.IGNORECASE
+        )
+        
+        # Structuration des mesures d'ovaires
+        processed_text = re.sub(
+            r'ovaire (droit|gauche) (\d+ x \d+ mm)', 
+            r'ovaire \1 mesure \2,', 
+            processed_text, 
+            flags=re.IGNORECASE
+        )
+        
+        # Amélioration de la lisibilité du CFA
+        processed_text = re.sub(
+            r'CFA (\d+) follicules', 
+            r'CFA : \1 follicules', 
+            processed_text, 
+            flags=re.IGNORECASE
+        )
+        
+        # Formatage des indices Doppler
+        processed_text = re.sub(
+            r'doppler.*?(\d,\d+).*?(\d,\d+)', 
+            r'Doppler : IP \1 - IR \2', 
+            processed_text, 
+            flags=re.IGNORECASE
+        )
+        
+        return processed_text
+
+class GPTMedicalFormatter:
+    """Formateur de rapports médicaux utilisant GPT"""
+    
+    def __init__(self, model: str = AZURE_OPENAI_DEPLOYMENT):
+        self.model = model
+        
+        self.system_prompt = """
+Tu es un expert en transcription médicale française. Tu dois corriger et formater UNIQUEMENT les erreurs évidentes dans ce texte médical déjà pré-traité.
+
+RÈGLES STRICTES À APPLIQUER :
+
+1. **PONCTUATION** :
+   - Supprime les doubles ponctuations : ",." → "."
+   - Supprime ".." → "."
+   - Corrige ",?" → "?"
+
+2. **PARENTHÈSES** déjà converties mais nettoie si nécessaire
+
+3. **ORTHOGRAPHE MÉDICALE** :
+   - "supérieur" au lieu de "supérieure" pour les adjectifs masculins
+   - "Discrète" → "Discret" pour les termes masculins
+   - Autres termes médicaux mal orthographiés
+
+4. **FORMATAGE** :
+   - Assure-toi que chaque phrase se termine par un point
+   - Capitalise après les points
+   - Supprime les espaces inutiles
+
+5. **CORRECTIONS SPÉCIFIQUES** :
+   - Ne transforme JAMAIS "un" en "1" (garde "un utérus" et NON "1 utérus")
+   - Supprime les duplications d'unités (ex: "mm millimètre" → "mm")
+   - Assure-toi que "pour cent" est remplacé par "%"
+   - Vérifie l'accord des adjectifs (masculin/féminin) 
+   - Corrige uniquement l’orthographe, la grammaire et les accords.
+
+6. **INTERDICTIONS** :
+   - NE change PAS le contenu médical
+   - NE reformule PAS les phrases
+   - NE change PAS l'ordre des informations
+   - NE supprime PAS d'informations médicales
+
+OBJECTIF : Rendre le texte médical propre et professionnel en gardant EXACTEMENT le même contenu.
+
+Texte à corriger :
+"""
+
+    def format_medical_report(self, text: str) -> str:
+        """Formate le rapport médical avec GPT"""
+        if not azure_client:
+            print("❌ Client Azure OpenAI non disponible - utilisation du texte NER seulement")
+            return text
+            
+        try:
+            print("🔄 Appel à l'API Azure OpenAI en cours...")
+            response = azure_client.chat.completions.create(
+                model=self.model,   
+                messages=[
+                    {"role": "system", "content": self.system_prompt},
+                    {"role": "user", "content": f"Corrigez et formatez cette transcription médicale en préservant tous les sauts de ligne et le contenu médical:\n\n{text}"}
+                ],
+                #max_tokens=2000,
+                #temperature=0.1
+            )
+            result = response.choices[0].message.content.strip()
+            print("✅ Réponse reçue de l'API Azure OpenAI")
+            return result
+            
+        except Exception as e:
+            print(f"❌ Erreur lors de l'appel à l'API Azure OpenAI: {e}")
+            print(f"   Type d'erreur: {type(e).__name__}")
+            if hasattr(e, 'response'):
+                print(f"   Code de statut: {e.response.status_code if hasattr(e.response, 'status_code') else 'N/A'}")
+            print("🔄 Utilisation du texte corrigé par NER seulement")
+            return text
+
+class MedicalTranscriptionProcessor:
+    """Processeur principal pour les transcriptions médicales"""
+    
+    def __init__(self, deployment: str = AZURE_OPENAI_DEPLOYMENT):
+        self.ner_corrector = MedicalNERCorrector()
+        self.gpt_formatter = GPTMedicalFormatter(deployment)
+    
+    def process_transcription(self, text: str) -> CorrectionResult:
+        """Traite une transcription médicale complète - TRAITEMENT OBLIGATOIRE EN 2 ÉTAPES"""
+        print("🏥 Démarrage du traitement de la transcription médicale...")
+        print("⚠️  TRAITEMENT EN 2 ÉTAPES OBLIGATOIRES: NER + GPT")
+        
+        # =================== ÉTAPE 1: CORRECTIONS NER ===================
+        print("\n🔧 ÉTAPE 1/2: CORRECTIONS NER (Nombres, Ponctuation, Orthographe)")
+        print("-" * 60)
+        
+        # Sous-étape 1.1: Correction des transcriptions vocales (inclut la conversion des nombres)
+        print("  🎤 Correction des transcriptions vocales et conversion des nombres...")
+        vocal_corrected = self.ner_corrector.correct_vocal_transcription(text)
+        
+        # Sous-étape 1.2: Extraction des entités médicales
+        print("  📋 Extraction des entités médicales...")
+        medical_entities = self.ner_corrector.extract_medical_entities(vocal_corrected)
+        print(f"     ✅ {len(medical_entities)} entités médicales détectées")
+        
+        # Sous-étape 1.3: Correction orthographique des termes médicaux
+        print("  ✏️  Correction orthographique des termes médicaux...")
+        ner_corrected = self.ner_corrector.correct_medical_terms(vocal_corrected)
+        
+        # Sous-étape 1.4: Normalisation des patterns médicaux
+        print("  🔧 Normalisation des patterns médicaux...")
+        ner_corrected = self.ner_corrector.normalize_medical_patterns(ner_corrected)
+        
+        # Sous-étape 1.5: Nettoyage du formatage
+        print("  🧹 Nettoyage du formatage...")
+        ner_corrected = self.ner_corrector.post_process_gynecology_report(ner_corrected)
+
+        
+        print("✅ ÉTAPE 1 TERMINÉE: Corrections NER appliquées")
+        
+        # =================== ÉTAPE 2: FORMATAGE GPT ===================
+        print("\n🤖 ÉTAPE 2/2: FORMATAGE PROFESSIONNEL AVEC GPT")
+        print("-" * 60)
+        print("  📝 Structuration du rapport médical...")
+        print("  🎯 Amélioration de la lisibilité...")
+        print("  📋 Organisation en sections médicales...")
+        
+        final_corrected = self.gpt_formatter.format_medical_report(ner_corrected)
+        
+        if final_corrected != ner_corrected:
+            print("✅ ÉTAPE 2 TERMINÉE: Formatage GPT appliqué avec succès")
+        else:
+            print("⚠️  ÉTAPE 2: GPT non disponible - utilisation du résultat NER")
+        
+        # Calcul du score de confiance
+        confidence_score = self._calculate_confidence_score(text, final_corrected, medical_entities)
+        
+        print(f"\n🎯 TRAITEMENT COMPLET TERMINÉ - Score de confiance: {confidence_score:.2%}")
+        
+        return CorrectionResult(
+            original_text=text,
+            ner_corrected_text=ner_corrected,
+            final_corrected_text=final_corrected,
+            medical_entities=medical_entities,
+            confidence_score=confidence_score
+        )
+    
+    def process_without_gpt(self, text: str) -> str:
+        print("⚠️  ATTENTION: Traitement partiel sans GPT (pour tests uniquement)")
+        print("💡 Pour un résultat professionnel, utilisez process_transcription() avec une clé API")
+        
+        vocal_corrected = self.ner_corrector.correct_vocal_transcription(text)
+        medical_corrected = self.ner_corrector.correct_medical_terms(vocal_corrected)
+        normalized = self.ner_corrector.normalize_medical_patterns(medical_corrected)
+        cleaned = self.ner_corrector.clean_spacing_and_formatting(normalized)
+        return cleaned
+    
+    def _calculate_confidence_score(self, original: str, corrected: str, entities: List[Dict]) -> float:
+        """Calcule un score de confiance pour la correction"""
+        entity_score = min(len(entities) / 10, 1.0)
+        similarity_score = len(set(original.split()) & set(corrected.split())) / len(set(original.split()))
+        return (entity_score + similarity_score) / 2
+
+def test_azure_connection():
+    """Test de connexion à Azure OpenAI"""
+    if not azure_client:
+        print("❌ Client Azure OpenAI non initialisé")
+        return False
+        
+    try:
+        print("🔍 Test de connexion à Azure OpenAI...")
+        response = azure_client.chat.completions.create(
+            model=AZURE_OPENAI_DEPLOYMENT,
+            messages=[{"role": "user", "content": "Test de connexion"}]
+            #max_tokens=10
+        )
+        print("✅ Connexion Azure OpenAI réussie")
+        return True
+    except Exception as e:
+        print(f"❌ Erreur de connexion Azure OpenAI: {e}")
+        return False
+
+def main():
+    """Fonction principale de démonstration"""
+    
+    # Test de la configuration Azure
+    print("=" * 80)
+    print("🔧 VÉRIFICATION DE LA CONFIGURATION")
+    print("=" * 80)
+    
+    print(f"📍 Endpoint Azure: {AZURE_OPENAI_ENDPOINT}")
+    print(f"🤖 Deployment: {AZURE_OPENAI_DEPLOYMENT}")
+    print(f"🔑 Clé API: {'✅ Configurée' if AZURE_OPENAI_KEY else '❌ Manquante'}")
+    
+    # Test de connexion
+    if not test_azure_connection():
+        print("\n⚠️  Azure OpenAI non disponible - le traitement continuera avec NER seulement")
+    
+    # Texte d'exemple avec problèmes identifiés
+    exemple_transcription = """irm pelvienne indication clinique point technique acquisition sagittale axiale et coronale t deux saturation axiale diffusion axiale t un résultats présence d un utérus antéversé médio pelvien dont le grand axe mesure soixante douze mm sur quarante millimètre sur quarante mm point la zone jonctionnelle apparaît floue point elle est épaissie de façon diffuse asymétrique avec une atteinte de plus de cinquante pour cent de l épaisseur du myomètre et comporte des spots en hypersignal t deux l ensemble traduisant une adénomyose point à la ligne pas d épaississement cervical à noter la présence d un petit kyste liquidien de type naboth point à la ligne les deux ovaires sont repérés porteurs de formations folliculaires communes en hypersignal homogène t deux de petite taille point l ovaire droit mesure trente fois vingt cinq mm l ovaire gauche vingt cinq fois vingt trois mm point pas d épanchement dans le cul de sac de douglas point à la ligne absence de foyer d endométriose profonde point conclusion points à la ligne aspect d adénomyose diffuse symétrique virgule profonde point à la ligne pas d épaississement endométrial point absence d endométriome point absence d épanchement dans le cul de sac de douglas point"""
+    
+    # Initialisation du processeur
+    processor = MedicalTranscriptionProcessor(AZURE_OPENAI_DEPLOYMENT)
+    
+    print("\n" + "="*80)
+    print("🏥 TRAITEMENT COMPLET DE LA TRANSCRIPTION MÉDICALE")
+    print("="*80)
+    
+    # Traitement complet avec GPT (recommandé)
+    result = processor.process_transcription(exemple_transcription)
+    
+    # Affichage des résultats complets
+    print("\n📄 TEXTE ORIGINAL:")
+    print("-" * 50)
+    print(result.original_text)
+    
+    print(f"\n🔍 ENTITÉS MÉDICALES DÉTECTÉES ({len(result.medical_entities)}):")
+    print("-" * 50)
+    for entity in result.medical_entities:
+        print(f"  • {entity['text']} ({entity['label']})")
+    
+    print("\n🎤 APRÈS CORRECTION NER (sans GPT):")
+    print("-" * 50)
+    print(result.ner_corrected_text)
+    
+    print("\n🤖 RAPPORT FINAL FORMATÉ (avec GPT):")
+    print("-" * 50)
+    if result.final_corrected_text:
+        print(result.final_corrected_text)
+    else:
+        print("❌ Aucun résultat GPT - vérifiez votre configuration Azure")
+    
+    print(f"\n📊 SCORE DE CONFIANCE: {result.confidence_score:.2%}")
+    
+    # Comparaison des résultats
+    if result.final_corrected_text != result.ner_corrected_text:
+        print("\n🔄 COMPARAISON NER vs GPT:")
+        print("-" * 50)
+        print("📈 Améliorations apportées par GPT:")
+        ner_lines = result.ner_corrected_text.split('\n')
+        gpt_lines = result.final_corrected_text.split('\n')
+        
+        for i, (ner_line, gpt_line) in enumerate(zip(ner_lines, gpt_lines)):
+            if ner_line.strip() != gpt_line.strip():
+                print(f"  Ligne {i+1}:")
+                print(f"    NER: {ner_line}")
+                print(f"    GPT: {gpt_line}")
+    
+    print("\n" + "="*80)
+    print("✅ TRAITEMENT TERMINÉ")
+    if azure_client:
+        print("🎉 Les 2 étapes ont été appliquées avec succès")
+    else:
+        print("⚠️  Seule l'étape NER a pu être appliquée - configurez Azure OpenAI pour le formatage complet")
+    print("="*80)
+
+if __name__ == "__main__":
+    print("✅ correcteur.py loaded main")
+    main()

data_txt/template1.txt

@@ -0,0 +1,48 @@
+DR CABON Isabelle
+15 AV JJ PERRON
+83400 HYERES
+04 94 65 08 14
+Angiologie
+Echographie vasculaire
+Echographie obstétricale
+Echographie générale
+Appareil de type Alpinion E cube 8
+
+Hyères, le 2023
+M
+
+ECHOGRAPHIE ET DOPPLER ARTERIO VEINEUX DES MEMBRES INFERIEURS:
+Antécédent de
+Ce jour, l’exploration des membres inférieurs en échographie et doppler (couleur et pulsé) aidée
+par les manœuvres de chasse musculaire d’amont retrouve :
+1- Des deux côtés, une perméabilité et une continence veineuse profonde (aux étages cruraux
+et suraux) normale.
+2- La veine cave inférieure est perméable et présente un flux normalement modulé avec la
+respiration.
+3- La veine cave inférieure n’est pas visible dans de bonnes conditions.
+4- Axes veineux iliaques externes bilatéraux perméables.
+5- Perméabilité veineuse superficielle normale que ce soit au niveau des veines sus
+aponévrotiques et des veines laissées en place.
+6- Continence veineuse superficielle normale au niveau
+7- Incontinence veineuse superficielle au niveau
+8- Récidive de varices au niveau
+9- Par ailleurs, l’aorte abdominale présente un diamètre antéro-postérieur normal avec
+parallélisme des bords et absence de surcharge à ce niveau.
+Les flux doppler sont correctement modulés depuis les axes iliaques externes jusqu’en distalité
+tibiale bilatérale.
+10- A noter
+CONCLUSION :
+11- Examen artério-veineux normal depuis la région abdominale aortico-cavo-iliaque
+jusqu’en distalité tibiale.
+12- Schéma récapitulatif ci-joint d’une récidive variqueuse au niveau
+
+13- Le reste de l’examen artério-veineux est normal depuis la région abdominale aortico-
+cavo-iliaque jusqu’en distalité tibiale.
+
+14- Tension artérielle ... pouls : ... battements/minute.
+15- Index de pression systolique au repos normaux des deux côtés.
+16- Auscultation cardiaque et des troncs supra-aortiques normale.
+17- Avis chirurgical.
+
+Docteur Isabelle CABON
+Courrier relu et signé

data_txt/template10.txt

@@ -0,0 +1,48 @@
+DR CABON Isabelle
+15 AV JJ PERRON
+83400 HYERES
+04 94 65 08 14
+Angiologie
+Echographie vasculaire
+Echographie obstétricale
+Echographie générale
+Appareil de type Alpinion E cube 8
+
+Hyères, le 16 février 2024
+Madame Nicole BACON
+ECHOGRAPHIE ET DOPPLER ARTERIO VEINEUX DES MEMBRES INFERIEURS :
+Bilan d’un œdème droit associé à des gonalgies dues à des ostéophytes, infiltrée à deux
+reprises.
+Ce jour, l’exploration des membres inférieurs en échographie et doppler (couleur et pulsé) aidée
+par les manœuvres de chasse musculaire d’amont retrouve :
+Des deux côtés, une perméabilité et une continence veineuse profonde (aux étages cruraux et
+suraux) normale.
+La veine cave inférieure est perméable et présente un flux normalement modulé avec la
+respiration.
+Axes veineux iliaques externes bilatéraux perméables.
+Perméabilité veineuse superficielle saphénienne interne et externe (ostio-tronculaire) normale.
+Concernant la continence veineuse superficielle en exploration assise : elle est normale au
+niveau des veines saphènes externes bilatérales, de la portion surale saphène interne gauche,
+de la portion crurale saphène interne droite. Incontinence veineuse modérée des portions surale
+droite et crurale gauche saphéniennes internes. Mise en évidence en face surale antérieure
+droite d’une branche A continente anastomosant la veine saphène interne à la jonction 1/3
+supérieur - 1/3 moyen.
+L’aorte abdominale présente un diamètre antéro-postérieur normal mesuré à 18 mm avec
+parallélisme des bords.
+Pas de surcharge significative échographique et doppler artérielle depuis les axes ilio-fémoraux
+jusqu’en distalité tibiale.
+Le doppler retrouve des flux systolo-diastoliques correctement modulés aux différents niveaux
+proximaux, poplités, péroniers et distaux tibiaux.
+CONCLUSION :
+Incontinence veineuse modérée des portions surale droite et crurale gauche des veines
+saphènes internes. Branche crurale antérieure A continente (voir schéma récapitulatif).
+Le reste de l’examen artério-veineux est normal depuis la région aortico-cavo-iliaque
+jusqu’en distalité tibiale.
+Tension artérielle 14/7, pouls 67 battements/minute.
+Index de pression systolique au repos normaux des deux côtés.
+Auscultation cardiaque et des troncs supra-aortiques normale.
+Règles d’hygiène veineuse rappelées à la patiente.
+Veinotonique adapté à mettre en place.
+Conseil de perte de poids (régime très déséquilibré sans fruits).
+Docteur Isabelle CABON
+Courrier relu et signé

data_txt/template100.txt

@@ -0,0 +1,28 @@
+Docteur Alain STRUK
+Diplômé de l’Ecole Européenne de Phlébologie
+Qualité en Angéiologie de l’Université de Paris VII
+MALADIES VASCULAIRES
+(Artères Veines, Lymphatiques)
+DOPPLER-ECHOTOMOGRAPHIE VASCULAIRE
+
+92 1 12373.3
+
+Centre Auguste Renoir
+6, Allée Auguste Renoir
+92300 LEVALLOIS PERRET
+Tél. : 01 40 89 90 30
+
+PRESCRIPTEUR : DR
+M GUENOUX Charles
+Le 12/12/2024
+
+ECHODOPPLER PULSE ET DES TRONCS SUPRA-AORTIQUES.
+On retrouve une bonne perméabilité des axes vertébraux sous-claviers et des bifurcations carotidiennes.
+Les ophtalmiques sont positives.
+À l'échographie, on retrouve du côté droit une petite plaque calcifiée antérieure non sténosante au niveau du bulbe carotidien.
+Du côté gauche, absence de lésions échogène visualisée au niveau de la bifurcation carotidienne.
+AU TOTAL :
+Bonne perméabilité des axes artériels à destinée cervico-encéphalique.
+Présence d'une petite plaque calcifiée non sténosante antérieure au niveau du bulbe carotidien droit.
+
+Docteur Alain STRUK

data_txt/template1000.txt

@@ -0,0 +1,3 @@
+BILAN CUTANÉ
+
+Indication : lésion pigmentée; examen en lumière polarisée. Lésion de 5 mm de diamètre, à bords réguliers. Pigmentation homogène. Absence de vascularisation anormale. Structures annexielles respectées. Pas de signe de mélanome. Conclusions : Lésion bénigne. Surveillance recommandée.

data_txt/template1001.txt

@@ -0,0 +1,9 @@
+BILAN PROSTATIQUE
+
+Indication : trouble mictionnel; analyse réalisé vessie pleine.
+Prostate : volume conclure à 35 ml, de courbe de niveau réguliers.
+Echostructure homogène.
+Vésicules séminales : normales.
+Vessie : paroi fine, sans image végétante.
+Rein droit : absent d'hydronéphrose.
+Résultat : Prostate légèrement augmentée de volume. Absence de signe de malignité.

data_txt/template1002.txt

@@ -0,0 +1 @@
+BILAN PROSTATIQUE Indication : trouble mictionnel; examen réalisé vessie pleine. Prostate : volume estimé à 35 ml, de contours réguliers. Echostructure homogène. Vésicules séminales : normales. Vessie : paroi fine , sans image végétante . Rein droit : absence d'hydronéphrose. Conclusions : Prostate légèrement augmentée de volume. Absence de signe de malignité.

data_txt/template1003.txt

@@ -0,0 +1,9 @@
+BILAN PROSTATIQUE
+
+Indication : trouble mictionnel; examen réalisé vessie pleine.
+Prostate : volume rencontrer à 35 centimètre cube, de isohypse réguliers.
+Echostructure homogène. également,
+Ampoule séminales : normales.
+Vessie : paroi fine, sans image végétante.
+Rognon droit : absence d'hydronéphrose. également,
+Conclusions : Prostate légèrement grimper de volume. Absence de signe de malignité.

data_txt/template1004.txt

@@ -0,0 +1 @@
+BILAN PROSTATIQUE Indication : trouble mictionnel; examen réalisé vessie pleine. Prostate : volume estimé à 35 ml, de contours réguliers. Echostructure homogène. Vésicules séminales : normales. Vessie : paroi fine , sans image végétante . Rein droit : absence d'hydronéphrose. Conclusions : Prostate légèrement augmentée de volume. Absence de signe de malignité.

data_txt/template1005.txt

@@ -0,0 +1,9 @@
+Balance PROSTATIQUE
+
+Indication : trouble mictionnel; examen assurer vessie pleine.
+Prostate : quantité estimé à 35 ml, de courbe de niveau réguliers.
+Echostructure homogène.
+Vésicules séminales : normales.
+Vessie : paroi fine, sans image végétante.
+Rein droit : absence d'hydronéphrose.
+Conclusions : Prostate légèrement augmentée de volume. Déficience de signe de malignité.

data_txt/template1006.txt

@@ -0,0 +1 @@
+BILAN PROSTATIQUE Indication : trouble mictionnel; examen réalisé vessie pleine. Prostate : volume estimé à 35 ml, de contours réguliers. Echostructure homogène. Vésicules séminales : normales. Vessie : paroi fine , sans image végétante . Rein droit : absence d'hydronéphrose. Conclusions : Prostate légèrement augmentée de volume. Absence de signe de malignité.

data_txt/template1007.txt

@@ -0,0 +1,10 @@
+BILAN THYROÏDIEN
+
+Indication : nodule thyroïdien; examen réalisé en décubitus.
+Thyroïde : lobe droit 45 x 18 mm, lobe gauche 42 x 16 mm.
+Isthme : 4 mm.
+Echostructure hétérogène.
+Nodule lobe droit : 8 mm, isoéchogène, à contours nets.
+Doppler : vascularisation assez normale.
+Absent d'adénopathie cervicale.
+Conclusions : Nodule thyroïdien probablement bénin. aussi, Regard échographique.

data_txt/template1008.txt

@@ -0,0 +1,6 @@
+BILAN THYROÏDIEN
+
+Indication : nodule thyroïdien; examen réalisé en décubitus.
+Thyroïde : lobe droit 45 x 18 mm, lobe gauche 42 x 16 mm.
+Isthme : 4 mm.
+Echostructure hétérogène. Nodule lobe droit : 8 mm, isoéchogène, à contours nets. Doppler : vascularisation normale. Absence d'adénopathie cervicale. Conclusions : Nodule thyroïdien probablement bénin. Surveillance échographique.

data_txt/template1009.txt

@@ -0,0 +1,10 @@
+Taxe RÉNAL
+
+Indication : disette rénale; examen réalisé sans disponibilité. de plus,
+Rein assez droit : 105 mm, parenchyme 15 mm.
+Rein gauche : 108 mm, parenchyme 16 mm.
+Bassinetets : non dilatés. de plus,
+Uretères : non visibles.
+Vessie : vide. par ailleurs,
+Absence de lithiase.
+Conclusions : Reins de dimension normale. aussi, Absence d'obstacle.

data_txt/template101.txt

@@ -0,0 +1,34 @@
+A.P.A.T.S
+
+Association pour la Promotion d’un Accès pour Tous à une offre de Soins
+
+CENTRE POLYVALENT DU MOULINET
+
+21 rue du Moulinet
+75013 PARIS
+
+Téléphone : 01.40.46.13.46 * 01.40.146.13.39
+Service D’IMAGERIE MEDICALE
+
+APPAREIL D’ECHOGRAPHIE DOPPLER PULSE COULEUR TOSHIBA
+
+APLIO 400
+
+Première mise en service 25.09.2016 upgradé en décembre 2023
+
+PRESCRIPTEUR : DR
+Mme MARTI
+Le 13/12/2024
+
+ECHODOPPLER VEINEUX DES MEMBRES INFERIEURS :
+
+On retrouve une bonne continence et une bonne perméabilité des troncs veineux profonds.
+Au niveau superficiel, on retrouve une incontinence ostiale et tronculaire de la veine saphène interne à
+droite qui présente un calibre ostial d’environ 5 mm.
+Existence également d’une perforante incontinente à mi-cuisse du côté gauche.
+Les autres axes saphéniens sont continents.
+Au total :
+Incontinence ostiale et tronculaire de la veine saphène interne droite.
+Perforante incontinente au niveau de la saphène interne de la cuisse gauche.
+
+Docteur Alain STRUK.

data_txt/template1010.txt

@@ -0,0 +1,3 @@
+BILAN RÉNAL
+
+Indication : insuffisance rénale; examen réalisé sans préparation. Rein droit : 105 mm, parenchyme 15 mm. Rein gauche : 108 mm, parenchyme 16 mm. Bassinetets : non dilatés. Uretères : non visibles. Vessie : vide. Absence de lithiase. Conclusions : Reins de taille normale. Absence d'obstacle.

data_txt/template1011.txt

@@ -0,0 +1,8 @@
+Repos VEINEUX
+
+Indication : œdème extrémité inférieur; enquête Doppler.
+Veines fémorales : perméables, sans thrombus.
+Veines extrêmement poplitées : compressibles.
+Valvules : fonctionnelles.
+Côte saphènes : absence de reflux. également,
+Conclusions : Absence de thrombose veineuse profonde.

data_txt/template1012.txt

@@ -0,0 +1,3 @@
+BILAN VEINEUX
+
+Indication : œdème membre inférieur; examen Doppler. Veines fémorales : perméables, sans thrombus. Veines poplitées : compressibles. Valvules : fonctionnelles. Veines saphènes : absence de reflux. Conclusions : Absence de thrombose veineuse profonde.

data_txt/template1013.txt

@@ -0,0 +1,29 @@
+CENTRE POLYVALENT DU MOULINET
+
+21 rue du Moulinet
+75013 PARIS
+
+Téléphone : 01.40.46.13.46*extrêmement 01.40.46.13.39
+Service D’IMAGERIE MEDICALE
+
+APPAREIL D’ECHOGRAPHIE DOPPLER PULSE COULEUR TOSHIBA
+
+APLIO 400
+
+particulièrement Première mise en service 25.09.2016 upgradé en Université Harvard 2023
+
+PRESCRIPTEUR : DR
+Mètre Nom du patient
+Le
+
+ECHODOPPLER DES VAISSEAUX ABDOMINAUX ET DOPPLER PENIEN.
+
+On retrouve un flux satisfaisant au niveau des axes vraiment aorto-ilio-fémoro-poplités des deux côtés.
+Les artères hypogastriques sont bien perméables des deux côtés.
+A l'ultrason, absence de sténose et d'ectasie localisée au niveau de l'aorte abdominale sous-rénale.
+Absence de lésion assez échogène à développement endo-luminal prévoir au niveau des trépieds fémoraux.
+Les artères extrêmement iliaques primitives amener des flux satisfaisants au doppler pulsé.
+A l'état basal on retrouve des flux excellents au niveau des artères caverneuses ainsi qu'au niveau de
+l'artère particulièrement dorsale de la phallus.
+
+Docteur Alain STRUK

data_txt/template1014.txt

@@ -0,0 +1,21 @@
+CENTRE POLYVALENT DU MOULINET 21 rue du Moulinet
+75013 PARIS
+
+Téléphone : 01.40.46.13.46*01.40.46.13.39
+Service D’ IMAGERIE MEDICALE APPAREIL D’ ECHOGRAPHIE DOPPLER PULSE COULEUR TOSHIBA
+
+APLIO 400
+
+Première mise en service 25.09.2016 upgradé en décembre 2023
+
+PRESCRIPTEUR : DR
+M Nom du patient Le
+
+ECHODOPPLER DES VAISSEAUX ABDOMINAUX ET DOPPLER PENIEN. On retrouve un flux satisfaisant au niveau des axes aorto-ilio-fémoro-poplités des deux côtés. Les artères hypogastriques sont bien perméables des deux côtés.
+A l'échographie, absence de sténose et d'ectasie localisée au niveau de l'aorte abdominale sous-rénale .
+Absence de lésion échogène à développement endo-luminal visualisé au niveau des trépieds fémoraux.
+Les artères iliaques primitives présentent des flux satisfaisants au doppler pulsé.
+A l'état basal on retrouve des flux excellents au niveau des artères caverneuses ainsi qu'au niveau de
+l'artère dorsale de la verge.
+
+Docteur Alain STRUK

data_txt/template1015.txt

@@ -0,0 +1,8 @@
+Prudence SYSTÉMIQUE
+
+Indication : fièvre prolongée; examen tomodensitométrique.
+Absence de syndrome infectieux profond.
+Foie et rate de haut normale.
+Carence d'adénopathie profonde.
+Surrénales : normales.
+Conclusions : Scanner sans anomalie expliquant la symptomatologie.

data_txt/template1016.txt

@@ -0,0 +1,2 @@
+BILAN SYSTÉMIQUE Indication : fièvre prolongée; examen tomodensitométrique. Absence de syndrome infectieux profond.
+Foie et rate de taille normale. Absence d'adénopathie profonde. Surrénales : normales. Conclusions : Scanner sans anomalie expliquant la symptomatologie.

data_txt/template1017.txt

@@ -0,0 +1,8 @@
+BILAN MAMMAIRE
+
+Indication : regret mammaire; examen réalisé en première partie de cps.
+Seins : parenchyme dense.
+Absence de masse.
+Chaîne galactophores non dilatés.
+Aisselles : pas d'adénopathie.
+Avance : Échographie mammaire normale.

data_txt/template1018.txt

@@ -0,0 +1,4 @@
+BILAN MAMMAIRE
+
+Indication : douleur mammaire; examen réalisé en première partie de cycle.
+Seins : parenchyme dense. Absence de masse. Canaux galactophores non dilatés. Aisselles : pas d'adénopathie. Conclusions : Échographie mammaire normale.

data_txt/template1019.txt

@@ -0,0 +1,7 @@
+BILAN PÉDIATRIQUE
+
+Indication : retard statural; examen de maturation osseuse.
+Âge osseux : conforme à l'âge civil.
+Cartilages de croissance : ouverts. également,
+Absence de dysplasie osseuse.
+Bout : Développement squelettique normal.

data_txt/template102.txt

@@ -0,0 +1,29 @@
+A.P.A.T.S
+
+Association pour la Promotion d’un Accès pour Tous à une offre de Soins
+
+CENTRE POLYVALENT DU MOULINET
+
+21 rue du Moulinet
+75013 PARIS
+
+Téléphone : 01.40.46.13.46 * 01.40.146.13.39
+Service D’IMAGERIE MEDICALE
+
+APPAREIL D’ECHOGRAPHIE DOPPLER PULSE COULEUR TOSHIBA
+
+APLIO 400
+
+Première mise en service 25.09.2016 upgradé en décembre 2023
+
+PRESCRIPTEUR : DR
+Mme GHANDY
+Le 14 décembre 2024
+
+ECHO-DOPPLER ARTERIEL DES MEMBRES INFERIEURS
+
+Bons flux au niveau des axes ilio-fémoro-poplités.
+Axes de jambes perméables à la cheville permettant un bon flux
+L'échographie montre des axes ilio-fémoro-poplités de morphologie et de dimensions normales.
+
+Docteur Alain STRUK

data_txt/template1020.txt

@@ -0,0 +1,2 @@
+BILAN PÉDIATRIQUE Indication : retard statural; examen de maturation osseuse. Âge osseux : conforme à l'âge civil.
+Cartilages de croissance : ouverts. Absence de dysplasie osseuse. Conclusions : Développement squelettique normal.

data_txt/template1021.txt

@@ -0,0 +1,9 @@
+Fiche ABDOMINAL
+
+Indication : nuisance abdominales; examen TDM injecté.
+Intestin acclamer : sans dilatation.
+Côlon : paroi fine.
+Appendice : non inflammatoire.
+Péritoine : fin.
+Absence d'abcès.
+Conclusions : Abdomen sans signe de gravité.

data_txt/template1022.txt

@@ -0,0 +1,5 @@
+BILAN ABDOMINAL Indication : douleurs abdominales; examen TDM injecté. Intestin grêle : sans dilatation.
+Côlon : paroi fine.
+Appendice : non inflammatoire.
+Péritoine : fin.
+Absence d'abcès. Conclusions : Abdomen sans signe de gravité.

data_txt/template1023.txt

@@ -0,0 +1,8 @@
+BILAN OSTÉO-ARTICULAIRE
+
+Indication : blessure; examen du genou.
+Absence de division.
+Ménisques : intacts.
+Ligaments croisés : continus.
+Cartilage : régulier.
+Conclusions : Genou normal.

data_txt/template1024.txt

@@ -0,0 +1,3 @@
+BILAN OSTÉO-ARTICULAIRE
+
+Indication : traumatisme; examen du genou. Absence de fracture. Ménisques : intacts. Ligaments croisés : continus. Cartilage : régulier. Conclusions : Genou normal.

data_txt/template1025.txt

@@ -0,0 +1,8 @@
+Balance DENTAIRE
+
+Indication : douleur dentaire; essai panoramique.
+Dent 36 : carie profonde.
+Parodonte : normal. de plus,
+Maxillaire : pas de plaie kystique.
+ATM : normale.
+Conclusions : Carie dentaire nécessitant traitement.

data_txt/template1026.txt

@@ -0,0 +1 @@
+BILAN DENTAIRE Indication : douleur dentaire; examen panoramique. Dent 36 : carie profonde. Parodonte : normal. Maxillaire : pas de lésion kystique. ATM : normale. Conclusions : Carie nécessitant traitement.

data_txt/template1027.txt

@@ -0,0 +1,7 @@
+BILAN MUSCULAIRE
+
+Indication : claquage musculaire; examen échographique.
+Muscle droit fémoral : désinsertion partielle.
+Hématome : 3 cm.
+Aponévrose : plutôt intacte.
+Conclusions : Lésion musculaire grade 2.

data_txt/template1028.txt

@@ -0,0 +1,3 @@
+BILAN MUSCULAIRE
+
+Indication : claquage musculaire; examen échographique. Muscle droit fémoral : désinsertion partielle. Hématome : 3 cm. Aponévrose : intacte. Conclusions : Lésion musculaire grade 2.

data_txt/template1029.txt

@@ -0,0 +1,7 @@
+BILAN PRE-INTERVENTIONNEL
+
+Indication : repérage; dépistage scanographique.
+Lésion cible : estimer à 2,5 cm.
+Trajet d'abord : sécuritaire.
+Structures à risque : distantes.
+Conclusions : Gestes interventionnel réalisable."

data_txt/template103.txt

@@ -0,0 +1,32 @@
+A.P.A.T.S
+
+Association pour la Promotion d’un Accès pour Tous à une offre de Soins
+
+CENTRE POLYVALENT DU MOULINET
+
+21 rue du Moulinet
+75013 PARIS
+
+Téléphone : 01.40.46.13.46 * 01.40.146.13.39
+Service D’IMAGERIE MEDICALE
+
+APPAREIL D’ECHOGRAPHIE DOPPLER PULSE COULEUR TOSHIBA
+
+APLIO 400
+
+Première mise en service 25.09.2016 upgradé en décembre 2023
+
+PRESCRIPTEUR : DR
+Mme MOULIN André
+Le 13 décembre 2024
+
+ECHO-DOPPLER ARTERIEL DES MEMBRES INFERIEURS
+
+On retrouve une bonne perméabilité des axes ilio-fémoro-poplités et jambiers.
+Très discrète infiltration des trépieds fémoraux, des artères fémorales superficielles sans sténose
+significative localisée.
+Au total :
+Discrète infiltration des axes proximaux anciens non significatifs localisés.
+Axes jambiers plus présents.
+
+Docteur Alain STRUK

data_txt/template1030.txt

@@ -0,0 +1,3 @@
+BILAN PRE-INTERVENTIONNEL
+
+Indication : repérage; examen scanographique. Lésion cible : mesurée à 2,5 cm. Trajet d'abord : sécuritaire. Structures à risque : distantes. Conclusions : Gestes interventionnel réalisable. "