correcciones

app/main.py

@@ -1,138 +1,140 @@
-# app/main.py
-from fastapi import FastAPI
-from pydantic import BaseModel
-import os, json, re, torch
-from huggingface_hub import hf_hub_download
-from transformers import AutoTokenizer
-from model.model import BETO_LSTM, TOKENIZER_ID
-from app.utils.synonym_dict import synonym_dict, normalize_text
-from fastapi.middleware.cors import CORSMiddleware
-from app.services.message_service import generate_diagnosis_message
-
-# Configuración CORS
-app = FastAPI(title="Prediagnóstico Médico")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"], 
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Configuración del modelo en Hugging Face
-REPO_ID = "esteban7856/respiratorio-beto"
-REVISION = "main"          
-MODEL_FILE = "best_model.pt"
-LMAP_FILE = "label_mapping.json"
-HF_TOKEN = os.getenv("HF_TOKEN") 
-
-# Hiperparámetros
-MAX_LEN = 64
-THRESHOLD = 0.55
-
-# Descarga de artefactos
-model_path = hf_hub_download(REPO_ID, MODEL_FILE, revision=REVISION, token=HF_TOKEN)
-lmap_path = hf_hub_download(REPO_ID, LMAP_FILE, revision=REVISION, token=HF_TOKEN)
-
-with open(lmap_path, "r", encoding="utf-8") as f:
-    id2label = {int(k): v for k, v in json.load(f).items()}
-NUM_CLASSES = len(id2label)
-
-# Carga del modelo
-tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_ID)
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-model = BETO_LSTM(hidden_dim=256, bidirectional=True, num_classes=NUM_CLASSES, freeze_bert=True)
-state = torch.load(model_path, map_location="cpu")
-model.load_state_dict(state)
-model.to(device).eval()
-
-class InputText(BaseModel):
-    text: str
-
-# Limpieza de saludos
-GREET_PATTERNS = [
-    r"^\s*hola[!,.\s]*", r"^\s*buenos dias[!,.\s]*", 
-    r"^\s*buenas tardes[!,.\s]*", r"^\s*buenas noches[!,.\s]*", 
-    r"^\s*buen dia[!,.\s]*"
-]
-
-def strip_greetings(text: str) -> str:
-    """Elimina saludos iniciales del texto."""
-    for pattern in GREET_PATTERNS:
-        text = re.sub(pattern, "", text, flags=re.IGNORECASE)
-    return text.strip()
-
-def contains_symptom(text: str) -> bool:
-    """Verifica si el texto contiene síntomas respiratorios."""
-    symptoms = {
-        "fiebre", "tos", "dificultad para respirar", "dolor de garganta",
-        "congestión nasal", "estornudos", "dolor de cabeza", "dolor muscular",
-        "escalofríos", "fatiga", "sibilancias", "dolor en el pecho",
-        "secreción nasal", "malestar general", "dolor de cuerpo"
-    }
-    text_lower = text.lower()
-    return any(symptom in text_lower for symptom in symptoms)
-
-@app.post("/predict")
-def predict(data: InputText):
-    texto_original = data.text
-
-    # Normalización del texto
-    texto_norm = normalize_text(texto_original.lower(), synonym_dict)
-    texto_proc = strip_greetings(texto_norm)
-
-    # Tokenización
-    inputs = tokenizer(
-        texto_proc,
-        return_tensors="pt",
-        truncation=True,
-        padding=True,
-        max_length=MAX_LEN
-    )
-    inputs = {k: v.to(device) for k, v in inputs.items()}
-
-    # Inferencia
-    with torch.no_grad():
-        logits = model(inputs["input_ids"], inputs["attention_mask"])
-        probs = torch.softmax(logits, dim=1)[0].cpu()
-
-    pmax, pred = torch.max(probs, dim=0)
-    final_pred = int(pred.item())
-    final_conf = float(pmax.item())
-
-    # Lógica de predicción
-    if contains_symptom(texto_proc):
-        if final_pred == 3 or final_conf < THRESHOLD:
-            probs012 = probs[:3] 
-            best012 = int(torch.argmax(probs012).item())
-            final_pred = best012
-            final_conf = float(probs012[best012].item())
-    else:
-        if final_pred != 3 and final_conf < THRESHOLD:
-            final_pred = 3
-
-    # Obtener el diagnóstico
-    diagnostico = id2label[final_pred]
-    
-    # Generar mensaje usando el servicio
-    mensaje_info = generate_diagnosis_message(
-        original_text=texto_original,
-        diagnosis=diagnostico,
-        confidence=final_conf
-    )
-
-    # Retornar respuesta
-    return {
-        "texto_original": texto_original,
-        "texto_normalizado": texto_proc,
-        "diagnóstico": diagnostico,
-        "probabilidad": mensaje_info["probabilidad"],
-        "nivel_confianza": mensaje_info["nivel_confianza"],
-        "mensaje": mensaje_info["mensaje"],
-        "sugerencia": mensaje_info["sugerencia"]
-    }
-
-if __name__ == "__main__":
-    import uvicorn
+# app/main.py
+from fastapi import FastAPI
+from pydantic import BaseModel
+import os, json, re, torch
+from huggingface_hub import hf_hub_download
+from transformers import AutoTokenizer
+from model.model import BETO_LSTM, TOKENIZER_ID
+from app.utils.synonym_dict import synonym_dict, normalize_text
+from fastapi.middleware.cors import CORSMiddleware
+from app.services.message_service import generate_diagnosis_message
+
+# Configuración CORS
+app = FastAPI(title="Prediagnóstico Médico")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Configuración del modelo en Hugging Face
+REPO_ID = "esteban7856/respiratorio-beto"
+REVISION = "main"          
+MODEL_FILE = "best_model.pt"
+LMAP_FILE = "label_mapping.json"
+HF_TOKEN = os.getenv("HF_TOKEN") 
+
+# Hiperparámetros
+MAX_LEN = 64
+THRESHOLD = 0.55
+
+# Descarga de artefactos
+model_path = hf_hub_download(REPO_ID, MODEL_FILE, revision=REVISION, token=HF_TOKEN)
+lmap_path = hf_hub_download(REPO_ID, LMAP_FILE, revision=REVISION, token=HF_TOKEN)
+
+with open(lmap_path, "r", encoding="utf-8") as f:
+    id2label = {int(k): v for k, v in json.load(f).items()}
+NUM_CLASSES = len(id2label)
+
+# Carga del modelo
+tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_ID)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+model = BETO_LSTM(hidden_dim=256, bidirectional=True, num_classes=NUM_CLASSES, freeze_bert=True)
+state = torch.load(model_path, map_location="cpu")
+model.load_state_dict(state)
+model.to(device).eval()
+
+class InputText(BaseModel):
+    text: str
+
+# Limpieza de saludos
+GREET_PATTERNS = [
+    r"^\s*hola[!,.\s]*", r"^\s*buenos dias[!,.\s]*", 
+    r"^\s*buenas tardes[!,.\s]*", r"^\s*buenas noches[!,.\s]*", 
+    r"^\s*buen dia[!,.\s]*"
+]
+
+def strip_greetings(text: str) -> str:
+    """Elimina saludos iniciales del texto."""
+    for pattern in GREET_PATTERNS:
+        text = re.sub(pattern, "", text, flags=re.IGNORECASE)
+    return text.strip()
+
+def contains_symptom(text: str) -> bool:
+    """Verifica si el texto contiene síntomas respiratorios."""
+    symptoms = {
+        "fiebre", "tos", "dificultad para respirar", "dolor de garganta",
+        "congestión nasal", "estornudos", "dolor de cabeza", "dolor muscular",
+        "escalofríos", "fatiga", "sibilancias", "dolor en el pecho",
+        "secreción nasal", "malestar general", "dolor de cuerpo"
+    }
+    text_lower = text.lower()
+    return any(symptom in text_lower for symptom in symptoms)
+
+@app.post("/predict")
+def predict(data: InputText):
+    texto_original = data.text
+
+    # Normalización del texto
+    texto_norm = normalize_text(texto_original.lower(), synonym_dict)
+    texto_proc = strip_greetings(texto_norm)
+
+    # Tokenización
+    inputs = tokenizer(
+        texto_proc,
+        return_tensors="pt",
+        truncation=True,
+        padding=True,
+        max_length=MAX_LEN
+    )
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    # Inferencia
+    with torch.no_grad():
+        logits = model(inputs["input_ids"], inputs["attention_mask"])
+        probs = torch.softmax(logits, dim=1)[0].cpu()
+
+    pmax, pred = torch.max(probs, dim=0)
+    final_pred = int(pred.item())
+    final_conf = float(pmax.item())
+
+    # Lógica de predicción
+    if contains_symptom(texto_proc):
+        if final_pred == 3 or final_conf < THRESHOLD:
+            probs012 = probs[:3] 
+            best012 = int(torch.argmax(probs012).item())
+            final_pred = best012
+            final_conf = float(probs012[best012].item())
+    else:
+        if final_pred != 3 and final_conf < THRESHOLD:
+            final_pred = 3
+
+    # Obtener el diagnóstico
+    diagnostico = id2label[final_pred]
+    
+    # Generar mensaje usando el servicio
+    mensaje_info = generate_diagnosis_message(
+        original_text=texto_original,
+        diagnosis=diagnostico,
+        confidence=final_conf
+    )
+
+    # Retornar respuesta
+    return {
+        "texto_original": texto_original,
+        "texto_normalizado": texto_norm,  # Texto después de normalize_text
+        "texto_procesado": texto_proc,    # Texto después de strip_greetings
+        "diagnostico": diagnostico,
+        "confianza": final_conf,
+        "mensaje": mensaje_info["mensaje"],
+        "sugerencia": mensaje_info["sugerencia"],
+        "nivel_confianza": mensaje_info["nivel_confianza"],
+        "probabilidad": mensaje_info["probabilidad"]
+    }
+
+if __name__ == "__main__":
+    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)

app/utils/synonym_dict.py

@@ -1,160 +1,246 @@
-# app/utils/synonym_dict.py
-import re
-import unicodedata
-from difflib import get_close_matches
-
-# === Diccionario original de sinónimos (tal como lo definiste) ===
-synonym_dict = {
-    "rinorrea": ["mocos como agua", "agua en la nariz", "nariz mocosa", "goteo de mocos como agua"],
-    "fiebre": ["temperatura alta", "calor", "alta temperatura", "calor intenso"],
-    "tos seca esporadica": ["tos espontanea", "a veces tos"],
-    "tos con expectoración": ["tos con flema", "tos con moco", "tos con expectoración"],
-    "alzas térmicas": ["temperaturas altas", "calor intenso"],
-    "piel pálida": ["piel pálida"],
-    "piel y mucosas pálidas": ["mucosas pálidas"],
-    "disnea": ["dificultad para respirar", "respiración rápida", "respiración difícil", "respiración dificultada"],
-    "somnolienta": ["cansancio", "sueño", "agotado"],
-    "cefalea": ["dolor de cabeza", "dolor de cabeza intenso", "dolor de cabeza severo", "dolor de cabeza fuerte"],
-    "tos seca sin secreciones": ["tos sin flema", "tos irritativa"],
-    "tos seca": ["tos seca sin secreciones"],
-    "hiporexia": ["rechaza alimentos", "no quiere comer", "no quiere lactar", "no tiene apetito"],
-    "disfonía": ["dificultad para hablar", "habla con dificultad", "ronco", "voz ronca"],
-    "malestar general": ["malestar", "no se siente bien", "malestar generalizado"],
-    "aumento de frecuencia respiratoria": ["frecuencia respiratoria aumentada", "respiración rápida", "respiración difícil"],
-    "sibilancias": ["silbido al respirar", "sonido al respirar", "respiración con silbido", "resoplido", "silbido"],
-    "astenica": ["sensación de debilidad", "falta de energía", "cansancio"],
-    "eructos fétidos": ["eructos de mal olor", "eructos fuertes", "eructos intensos"],
-    "febril": ["temperatura alta", "calor corporal"],
-}
-
-
-# === Normalización básica ===
-
-def remove_accents(text: str) -> str:
-    """Elimina tildes/acentos del texto."""
-    return ''.join(
-        c for c in unicodedata.normalize('NFD', text)
-        if unicodedata.category(c) != 'Mn'
-    )
-
-
-def basic_cleanup(text: str) -> str:
-    """
-    Limpieza básica:
-    - minúsculas
-    - sin tildes
-    - quitar signos raros
-    - colapsar letras repetidas (fieeebre -> fiebre)
-    """
-    if not isinstance(text, str):
-        text = str(text)
-
-    text = text.lower()
-    text = remove_accents(text)
-    # dejar solo letras, números, ñ y espacios
-    text = re.sub(r'[^a-z0-9ñ\s]', ' ', text)
-    # colapsar letras repetidas de 3+ a 2
-    text = re.sub(r'(.)\1{2,}', r'\1\1', text)
-    # espacios múltiples
-    text = re.sub(r'\s+', ' ', text).strip()
-    return text
-
-
-# === Normalizar diccionario y construir vocabulario ===
-
-def normalize_synonym_dict(sd: dict) -> dict:
-    """
-    Devuelve una versión normalizada (sin tildes, minúsculas) del diccionario.
-    """
-    new_sd = {}
-    for term, synonyms in sd.items():
-        norm_term = basic_cleanup(term)
-        norm_syns = [basic_cleanup(s) for s in synonyms]
-        # quitar duplicados y el propio término
-        norm_syns = sorted({s for s in norm_syns if s and s != norm_term})
-        new_sd[norm_term] = norm_syns
-    return new_sd
-
-
-synonym_dict_norm = normalize_synonym_dict(synonym_dict)
-
-
-def build_vocab(sd: dict) -> set:
-    """
-    Construye un vocabulario de palabras a partir de términos y sinónimos.
-    """
-    vocab = set()
-    for term, synonyms in sd.items():
-        frases = [term] + synonyms
-        for frase in frases:
-            for palabra in frase.split():
-                vocab.add(palabra)
-    return vocab
-
-
-VOCAB = build_vocab(synonym_dict_norm)
-
-
-# === Corrección ortográfica fuzzy ===
-
-def correct_spelling(text: str, vocab: set, cutoff: float = 0.8) -> str:
-    """
-    Corrige palabras que no estén en el vocabulario usando similitud aproximada.
-    """
-    tokens = text.split()
-    corrected = []
-    for tok in tokens:
-        if tok in vocab:
-            corrected.append(tok)
-        else:
-            matches = get_close_matches(tok, list(vocab), n=1, cutoff=cutoff)
-            if matches:
-                corrected.append(matches[0])
-            else:
-                corrected.append(tok)
-    return " ".join(corrected)
-
-
-# === Aplicar sinónimos -> término médico canónico ===
-
-def normalize_with_synonyms(text: str, sd_norm: dict) -> str:
-    """
-    Reemplaza frases sinónimas por el término médico canónico.
-    text ya debe estar normalizado (basic_cleanup + correct_spelling).
-    """
-    replacements = []
-
-    for medical_term, synonyms in sd_norm.items():
-        # si ya está el término médico, no tocamos sus sinónimos
-        if re.search(r'\b' + re.escape(medical_term) + r'\b', text):
-            continue
-        for synonym in synonyms:
-            if synonym:
-                replacements.append((synonym, medical_term))
-
-    # primero las frases más largas
-    replacements.sort(key=lambda x: len(x[0]), reverse=True)
-
-    for synonym, medical_term in replacements:
-        pattern = r'\b' + re.escape(synonym) + r'\b'
-        text = re.sub(pattern, medical_term, text)
-
-    return text
-
-
-# === Función principal utilizada por la API y el entrenamiento ===
-
-def normalize_text(user_text: str, _unused_dict=None) -> str:
-    """
-    Pipeline robusto:
-    1) limpieza básica (acentos, ruido, letras repetidas)
-    2) corrección ortográfica aproximada (fuzzy)
-    3) mapeo de sinónimos a términos médicos canónicos
-
-    La firma mantiene el parámetro synonym_dict por compatibilidad,
-    pero internamente usamos synonym_dict_norm global.
-    """
-    text = basic_cleanup(user_text)
-    text = correct_spelling(text, VOCAB)
-    text = normalize_with_synonyms(text, synonym_dict_norm)
-    return text
+# app/utils/synonym_dict.py
+import re
+import unicodedata
+from difflib import get_close_matches
+from spellchecker import SpellChecker
+
+# Configurar el corrector ortográfico en español
+spell = SpellChecker(language='es')
+
+# Términos médicos personalizados para el diccionario
+medical_terms = [
+    # Síntomas comunes
+    'rinorrea', 'fiebre', 'tos', 'expectoración', 'alzas', 'térmicas',
+    'pálida', 'mucosas', 'disnea', 'somnolienta', 'cefalea', 'hiporexia',
+    'disfonía', 'astenia', 'sibilancias', 'eructos', 'fétidos', 'febril',
+    # Sistemas corporales
+    'respiratorio', 'digestivo', 'cardíaco', 'gastrointestinal', 'urinario',
+    # Medicamentos comunes
+    'paracetamol', 'ibuprofeno', 'amoxicilina', 'omeprazol', 'loratadina',
+    # Exámenes y procedimientos
+    'radiografía', 'análisis', 'hemograma', 'cultivo', 'ecografía'
+]
+
+# Añadir términos médicos al diccionario del corrector
+spell.word_frequency.load_words(medical_terms)
+
+# Términos adicionales del diccionario de sinónimos
+additional_terms = [
+    'mocos', 'agua', 'nariz', 'temperatura', 'calor', 'tos', 'secreciones',
+    'alimentos', 'apetito', 'habla', 'respiración', 'dolor', 'cabeza'
+]
+spell.word_frequency.load_words(additional_terms)
+
+# === Diccionario original de sinónimos (tal como lo definiste) ===
+synonym_dict = {
+    "rinorrea": ["mocos como agua", "agua en la nariz", "nariz mocosa", "goteo de mocos como agua"],
+    "fiebre": ["temperatura alta", "calor", "alta temperatura", "calor intenso"],
+    "tos seca esporadica": ["tos espontanea", "a veces tos"],
+    "tos con expectoración": ["tos con flema", "tos con moco", "tos con expectoración"],
+    "alzas térmicas": ["temperaturas altas", "calor intenso"],
+    "piel pálida": ["piel pálida"],
+    "piel y mucosas pálidas": ["mucosas pálidas"],
+    "disnea": ["dificultad para respirar", "respiración rápida", "respiración difícil", "respiración dificultada"],
+    "somnolienta": ["cansancio", "sueño", "agotado"],
+    "cefalea": ["dolor de cabeza", "dolor de cabeza intenso", "dolor de cabeza severo", "dolor de cabeza fuerte"],
+    "tos seca sin secreciones": ["tos sin flema", "tos irritativa", "toz seca", "tis sica"],
+    "tos seca": ["tos seca sin secreciones"],
+    "hiporexia": ["rechaza alimentos", "no quiere comer", "no quiere lactar", "no tiene apetito"],
+    "disfonía": ["dificultad para hablar", "habla con dificultad", "ronco", "voz ronca"],
+    "malestar general": ["malestar", "no se siente bien", "malestar generalizado"],
+    "aumento de frecuencia respiratoria": ["frecuencia respiratoria aumentada", "respiración rápida", "respiración difícil"],
+    "sibilancias": ["silbido al respirar", "sonido al respirar", "respiración con silbido", "resoplido", "silbido"],
+    "astenica": ["sensación de debilidad", "falta de energía", "cansancio"],
+    "eructos fétidos": ["eructos de mal olor", "eructos fuertes", "eructos intensos"],
+    "febril": ["temperatura alta", "calor corporal"],
+}
+
+
+# === Normalización básica ===
+
+def remove_accents(text: str) -> str:
+    """Elimina tildes/acentos del texto."""
+    return ''.join(
+        c for c in unicodedata.normalize('NFD', text)
+        if unicodedata.category(c) != 'Mn'
+    )
+
+
+def basic_cleanup(text: str) -> str:
+    """
+    Limpieza básica:
+    - minúsculas
+    - sin tildes
+    - quitar signos raros
+    - colapsar letras repetidas (fieeebre -> fiebre)
+    """
+    if not isinstance(text, str):
+        text = str(text)
+
+    text = text.lower()
+    text = remove_accents(text)
+    # dejar solo letras, números, ñ y espacios
+    text = re.sub(r'[^a-z0-9ñ\s]', ' ', text)
+    # colapsar letras repetidas de 3+ a 2
+    text = re.sub(r'(.)\1{2,}', r'\1\1', text)
+    # espacios múltiples
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+
+# === Normalizar diccionario y construir vocabulario ===
+
+def normalize_synonym_dict(sd: dict) -> dict:
+    """
+    Devuelve una versión normalizada (sin tildes, minúsculas) del diccionario.
+    """
+    new_sd = {}
+    for term, synonyms in sd.items():
+        norm_term = basic_cleanup(term)
+        norm_syns = [basic_cleanup(s) for s in synonyms]
+        # quitar duplicados y el propio término
+        norm_syns = sorted({s for s in norm_syns if s and s != norm_term})
+        new_sd[norm_term] = norm_syns
+    return new_sd
+
+
+synonym_dict_norm = normalize_synonym_dict(synonym_dict)
+
+
+def build_vocab(sd: dict) -> set:
+    """
+    Construye un vocabulario de palabras a partir de términos y sinónimos.
+    """
+    vocab = set()
+    for term, synonyms in sd.items():
+        frases = [term] + synonyms
+        for frase in frases:
+            for palabra in frase.split():
+                vocab.add(palabra)
+    return vocab
+
+
+VOCAB = build_vocab(synonym_dict_norm)
+
+
+# === Corrección ortográfica fuzzy ===
+
+def correct_spelling(text: str, vocab: set = None, cutoff: float = 0.6) -> str:
+    """
+    Corrige la ortografía del texto usando pyspellchecker con soporte para términos médicos.
+    
+    Args:
+        text: Texto a corregir
+        vocab: Conjunto de palabras del vocabulario conocido
+        cutoff: Umbral de confianza para la corrección (0-1)
+    
+    Returns:
+        Texto con las correcciones ortográficas aplicadas
+    """
+    def calculate_similarity(w1: str, w2: str) -> float:
+        """Calcula la similitud entre dos palabras."""
+        if not w1 or not w2:
+            return 0.0
+        
+        # Peso más alto para las primeras letras
+        min_len = min(len(w1), len(w2))
+        if min_len == 0:
+            return 0.0
+            
+        # Verificar si las primeras letras coinciden
+        first_letter_match = 1.0 if w1[0] == w2[0] else 0.0
+        
+        # Calcular similitud de conjuntos de caracteres
+        set1, set2 = set(w1), set(w2)
+        intersection = len(set1 & set2)
+        union = len(set1 | set2)
+        jaccard = intersection / union if union > 0 else 0
+        
+        # Ponderar la similitud (50% primera letra, 50% similitud general)
+        return (first_letter_match * 0.5) + (jaccard * 0.5)
+    
+    tokens = text.split()
+    corrected = []
+    
+    for word in tokens:
+        # Si la palabra está en el vocabulario médico, no la corregimos
+        if word in spell or (vocab and word in vocab):
+            corrected.append(word)
+            continue
+            
+        # Obtener la mejor corrección
+        best_correction = spell.correction(word)
+        
+        # Si no hay corrección o es la misma palabra, mantener la original
+        if not best_correction or best_correction == word:
+            corrected.append(word)
+            continue
+            
+        # Calcular similitud
+        similarity = calculate_similarity(word, best_correction)
+        
+        # Aplicar corrección si la similitud es suficiente
+        if similarity >= cutoff:
+            # Priorizar términos médicos
+            if best_correction in medical_terms:
+                corrected.append(best_correction)
+            # Para palabras no médicas, ser más estricto
+            elif similarity >= 0.8:
+                corrected.append(best_correction)
+            else:
+                corrected.append(word)
+        else:
+            corrected.append(word)
+    
+    return " ".join(corrected)
+
+
+# === Aplicar sinónimos -> término médico canónico ===
+
+def normalize_with_synonyms(text: str, sd_norm: dict) -> str:
+   
+    replacements = []
+
+    for medical_term, synonyms in sd_norm.items():
+        # si ya está el término médico, no tocamos sus sinónimos
+        if re.search(r'\b' + re.escape(medical_term) + r'\b', text):
+            continue
+        for synonym in synonyms:
+            if synonym:
+                replacements.append((synonym, medical_term))
+
+    # primero las frases más largas
+    replacements.sort(key=lambda x: len(x[0]), reverse=True)
+
+    for synonym, medical_term in replacements:
+        pattern = r'\b' + re.escape(synonym) + r'\b'
+        text = re.sub(pattern, medical_term, text)
+
+    return text
+
+
+# === Función principal utilizada por la API y el entrenamiento ===
+
+def normalize_text(user_text: str, _unused_dict=None) -> str:
+    """
+    Pipeline robusto:
+    1) limpieza básica (acentos, ruido, letras repetidas)
+    2) corrección ortográfica aproximada (fuzzy)
+    3) mapeo de sinónimos a términos médicos canónicos
+    """
+    # 1. Limpieza básica
+    text = basic_cleanup(user_text)
+    
+    # 2. Corrección ortográfica
+    # Primero intentamos con el vocabulario médico
+    corrected = correct_spelling(text, VOCAB)
+    
+    # Si no hubo cambios, intentamos con el diccionario general
+    if corrected == text:
+        corrected = ' '.join([spell.correction(word) or word for word in text.split()])
+    
+    # 3. Normalización de sinónimos
+    normalized = normalize_with_synonyms(corrected, synonym_dict_norm)
+    
+    # Si después de todo el proceso no hay cambios, devolvemos el texto original
+    return normalized if normalized.strip() else text