Spaces:
Sleeping
Sleeping
| 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) | |
| 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() |