api en fastapi para el prediagnosctico

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.11-slim
+
+ENV PIP_NO_CACHE_DIR=1 \
+    HF_HOME=/data/hf \
+    TOKENIZERS_PARALLELISM=false \
+    PYTHONUNBUFFERED=1
+
+# Paquetes de sistema mínimos para compilar wheels si hace falta
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY requirements.txt .
+# CPU-only torch (importante para no exceder memoria)
+RUN pip install --no-cache-dir --extra-index-url https://download.pytorch.org/whl/cpu -r requirements.txt
+
+# Copiamos el código
+COPY app ./app
+COPY model ./model
+
+# Puerto esperado por Spaces
+EXPOSE 7860
+
+# Iniciar FastAPI
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

app/main.py

@@ -0,0 +1,136 @@
+# 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
+
+#=== configuracion del 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"           # o "main"
+MODEL_FILE = "best_model.pt"
+LMAP_FILE  = "label_mapping.json"
+HF_TOKEN   = os.getenv("HF_TOKEN")  # opcional si el repo es público
+
+# ===== Hiperparámetros de inferencia =====
+MAX_LEN   = 64
+THRESHOLD = 0.55  # ajusta tras validar
+
+# ===== Descarga artefactos del Hub =====
+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 tokenizer y 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()
+
+# ===== FastAPI =====
+app = FastAPI(title="Prediagnóstico Médico")
+
+class InputText(BaseModel):
+    texto: str
+
+# --- Limpieza de saludos / fillers ---
+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:
+    t = text.lower()
+    for pat in GREET_PATTERNS:
+        t = re.sub(pat, "", t)
+    return re.sub(r"\s{2,}", " ", t).strip()
+
+# --- Conjunto de síntomas canónicos (guardarraíl de producción) ---
+RESP_SYMPTOMS = {
+    "fiebre", "alzas térmicas", "tos seca", "tos con expectoración", "tos productiva",
+    "disnea", "dificultad para respirar", "sibilancias", "rinorrea", "congestión nasal",
+    "dolor torácico", "taquipnea", "retracción intercostal", "cianosis",
+    "odinofagia", "hiporexia", "somnolienta", "malestar general"
+}
+def contains_symptom(text: str) -> bool:
+    for term in RESP_SYMPTOMS:
+        if re.search(rf"\b{re.escape(term)}\b", text):
+            return True
+    if re.search(r"\btos\b", text):
+        return True
+    return False
+
+@app.post("/predict")
+def predict(data: InputText):
+    texto_original = data.texto
+
+    # 1) Normalización igual que en entrenamiento + quitar saludos
+    texto_norm = normalize_text(texto_original.lower(), synonym_dict)
+    texto_proc = strip_greetings(texto_norm)
+
+    # 2) 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()}
+
+    # 3) Inferencia (logits -> softmax aquí)
+    with torch.no_grad():
+        logits = model(inputs["input_ids"], inputs["attention_mask"])
+      # probs: tensor shape [1, num_classes]
+        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())
+
+    # 4) Regla práctica: si hay síntomas, evita 3 ("No enfermedad")
+    if contains_symptom(texto_proc):
+        if final_pred == 3 or final_conf < THRESHOLD:
+            probs012 = probs[:3]  # clases 0,1,2
+            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
+
+    return {
+        "texto_original": texto_original,
+        "texto_normalizado": texto_proc,
+        "diagnóstico": id2label[final_pred],
+        "confianza": round(final_conf, 3)
+    }
+
+@app.get("/health")
+def health():
+    return {
+        "status": "ok",
+        "num_classes": NUM_CLASSES,
+        "labels": id2label,
+        "device": str(device),
+        "repo": {"id": REPO_ID, "rev": REVISION}
+    }

app/prewarm.py

@@ -0,0 +1,13 @@
+import os
+from huggingface_hub import hf_hub_download
+
+REPO_ID = "esteban7856/respiratorio-beto"
+REVISION = "main"  
+_ = hf_hub_download(REPO_ID, "label_mapping.json", revision=REVISION, token=os.getenv("HF_TOKEN"))
+_ = hf_hub_download(REPO_ID, "best_model.pt",      revision=REVISION, token=os.getenv("HF_TOKEN"))
+
+# Precaliento del beto 
+from transformers import AutoModel
+from model.model import TOKENIZER_ID
+AutoModel.from_pretrained(TOKENIZER_ID)
+print("prewarm listo")

app/utils/synonym_dict.py

@@ -0,0 +1,42 @@
+import re
+
+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"],
+}
+
+def normalize_text(text: str, synonym_dict: dict) -> str:
+    text = text.lower()
+    replacements = []
+    for medical_term, synonyms in synonym_dict.items():
+        if re.search(r'\b' + re.escape(medical_term) + r'\b', text, re.IGNORECASE):
+            continue
+        for synonym in synonyms:
+            if synonym.lower() != medical_term.lower():
+                replacements.append((synonym, medical_term))
+
+    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, flags=re.IGNORECASE)
+
+    return text

model/model.py

@@ -0,0 +1,41 @@
+from transformers import AutoModel
+import torch.nn as nn
+import torch
+
+# Debe coincidir con el usado en train/main
+TOKENIZER_ID = "dccuchile/bert-base-spanish-wwm-cased"
+
+class BETO_LSTM(nn.Module):
+    def __init__(self, hidden_dim=256, num_classes=4, bidirectional=True, freeze_bert=True, dropout=0.2):
+        super().__init__()
+        self.bert = AutoModel.from_pretrained(TOKENIZER_ID)
+
+        # Congelar BERT (útil si entrenaste la cabeza primero)
+        if freeze_bert:
+            for p in self.bert.parameters():
+                p.requires_grad = False
+
+        self.lstm = nn.LSTM(
+            input_size=768,
+            hidden_size=hidden_dim,
+            batch_first=True,
+            bidirectional=bidirectional
+        )
+        self.dropout = nn.Dropout(dropout)
+        out_dim = hidden_dim * (2 if bidirectional else 1)
+        self.fc = nn.Linear(out_dim, num_classes)
+
+    def forward(self, input_ids, attention_mask):
+        # Devolver LOGITS (sin softmax)
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        seq = outputs.last_hidden_state  # [B, T, 768]
+        lstm_out, _ = self.lstm(seq)     # [B, T, H*dir]
+
+        # Último token real (no padding) usando attention_mask
+        lengths = attention_mask.sum(dim=1)          # [B]
+        last_idx = (lengths - 1).clamp(min=0)        # [B]
+        batch_idx = torch.arange(lstm_out.size(0), device=lstm_out.device)
+        last_hidden = lstm_out[batch_idx, last_idx, :]  # [B, H*dir]
+
+        logits = self.fc(self.dropout(last_hidden))  # [B, num_classes]
+        return logits

requirements.txt

@@ -0,0 +1,10 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.1.0+cpu
+transformers==4.33.0
+huggingface_hub==0.36.0
+fastapi==0.110.0
+uvicorn==0.29.0
+numpy==1.26.0
+scikit-learn==1.3.0|
+pandas==2.1.0
+openpyxl==3.1.2