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()