Update app.py

app.py

@@ -10,22 +10,20 @@ import torch.nn.functional as F
 import warnings
 import os
 
-# Suprimir warnings
+# Suppress warnings
 warnings.filterwarnings("ignore")
 
-print("🔍 Iniciando sistema de análisis de lesiones de piel...")
+print("🔍 Starting Skin Lesion Analysis System...")
 
-# --- CONFIGURACIÓN DE MODELOS VERIFICADOS ---
-# Separamos los modelos en dos categorías para mejor explicación al usuario.
-# Los modelos especializados en piel son generalmente más fiables para esta tarea.
+# --- VERIFIED MODEL CONFIGURATIONS ---
 MODEL_CONFIGS = {
-    "especializados": [
+    "specialized": [
         {
             'name': 'Syaha Skin Cancer',
             'id': 'syaha/skin_cancer_detection_model',
             'type': 'custom',
             'accuracy': 0.82,
-            'description': 'CNN entrenado en HAM10000',
+            'description': 'CNN trained on HAM10000 dataset',
             'emoji': '🩺'
         },
         {
@@ -33,7 +31,7 @@ MODEL_CONFIGS = {
             'id': 'VRJBro/skin-cancer-detection',
             'type': 'custom',
             'accuracy': 0.85,
-            'description': 'Detector especializado 2024',
+            'description': 'Specialized detector (2024)',
             'emoji': '🎯'
         },
         {
@@ -41,7 +39,7 @@ MODEL_CONFIGS = {
             'id': 'Anwarkh1/Skin_Cancer-Image_Classification',
             'type': 'vit',
             'accuracy': 0.89,
-            'description': 'Clasificador multi-clase de lesiones de piel',
+            'description': 'Multi-class skin lesion classifier',
             'emoji': '🧠'
         },
         {
@@ -49,34 +47,33 @@ MODEL_CONFIGS = {
             'id': 'jhoppanne/SkinCancerClassifier_smote-V0',
             'type': 'custom',
             'accuracy': 0.86,
-            'description': 'Modelo ISIC 2024 con SMOTE para desequilibrio de clases',
+            'description': 'ISIC 2024 model using SMOTE for class imbalance',
             'emoji': '⚖️'
         },
-        # --- NUEVOS MODELOS ESPECIALIZADOS AÑADIDOS ---
         {
             'name': 'ViT ISIC Binary',
             'id': 'ahishamm/vit-base-binary-isic-sharpened-patch-32',
             'type': 'vit',
-            'accuracy': 0.89, # Reported accuracy
-            'description': 'ViT para clasificación binaria de lesiones ISIC (benigno/maligno)',
+            'accuracy': 0.89,
+            'description': 'ViT model for binary ISIC lesion classification (benign/malignant)',
             'emoji': '🔬'
         },
         {
             'name': 'ViT ISIC Multi-class',
             'id': 'ahishamm/vit-base-isic-patch-16',
             'type': 'vit',
-            'accuracy': 0.79, # Reported accuracy
-            'description': 'ViT para clasificación multi-clase de lesiones ISIC',
+            'accuracy': 0.79,
+            'description': 'ViT model for multi-class ISIC lesion classification',
             'emoji': '🔍'
         }
     ],
-    "generales": [
+    "general": [
         {
             'name': 'ViT Base General',
             'id': 'google/vit-base-patch16-224',
             'type': 'vit',
             'accuracy': 0.78,
-            'description': 'ViT base pre-entrenado en ImageNet-1k. Excelente para características visuales generales.',
+            'description': 'ViT base pre-trained on ImageNet-1k.',
             'emoji': '📈'
         },
         {
@@ -84,7 +81,7 @@ MODEL_CONFIGS = {
             'id': 'microsoft/resnet-50',
             'type': 'custom',
             'accuracy': 0.77,
-            'description': 'Un clásico ResNet-50, robusto y de alto rendimiento en clasificación de imágenes generales.',
+            'description': 'Classic ResNet-50, robust and high-performing.',
             'emoji': '⚙️'
         },
         {
@@ -92,7 +89,7 @@ MODEL_CONFIGS = {
             'id': 'facebook/deit-base-patch16-224',
             'type': 'vit',
             'accuracy': 0.79,
-            'description': 'Data-efficient Image Transformer, eficiente y de buen rendimiento general.',
+            'description': 'Data-efficient Image Transformer, efficient and accurate.',
             'emoji': '💡'
         },
         {
@@ -100,7 +97,7 @@ MODEL_CONFIGS = {
             'id': 'google/mobilenet_v2_1.0_224',
             'type': 'custom',
             'accuracy': 0.72,
-            'description': 'MobileNetV2, modelo ligero y rápido, ideal para entornos con recursos limitados.',
+            'description': 'Lightweight model for mobile or low-resource environments.',
             'emoji': '📱'
         },
         {
@@ -108,37 +105,32 @@ MODEL_CONFIGS = {
             'id': 'microsoft/swin-tiny-patch4-window7-224',
             'type': 'custom',
             'accuracy': 0.81,
-            'description': 'Swin Transformer (Tiny), potente para visión por computadora.',
+            'description': 'Swin Transformer (Tiny), efficient and powerful.',
             'emoji': '🌀'
         },
-        # Modelo de respaldo genérico final (si nada más funciona)
         {
             'name': 'ViT Base General (Fallback)',
             'id': 'google/vit-base-patch16-224-in21k',
             'type': 'vit',
             'accuracy': 0.75,
-            'description': 'ViT genérico como respaldo final',
+            'description': 'Generic ViT fallback model',
             'emoji': '🔄'
         }
     ]
 }
 
-# --- CARGA SEGURA DE MODELOS ---
+# --- SAFE MODEL LOADING ---
 loaded_models = {}
 model_performance = {}
 
 def load_model_safe(config):
-    """Carga segura de modelos con manejo de errores mejorado y revisiones específicas."""
+    """Safely loads a model with multiple revision fallbacks."""
     try:
         model_id = config['id']
         model_type = config['type']
-        print(f"🔄 Cargando {config['emoji']} {config['name']}...")
-
-        # Intentar cargar con revisiones específicas para evitar problemas de safetensors/float16
-        # Si PyTorch es 2.6.0, es posible que 'safetensors' aún no sea 100% estable en todos los modelos/configuraciones
-        # y que el soporte de float16 requiera revisión específica.
-        revisions_to_try = ["main", "no_float16_weights", None] # None intentará el valor por defecto
+        print(f"🔄 Loading {config['emoji']} {config['name']}...")
 
+        revisions_to_try = ["main", "no_float16_weights", None]
         processor = None
         model = None
         load_successful = False
@@ -146,57 +138,52 @@ def load_model_safe(config):
         for revision in revisions_to_try:
             try:
                 if revision:
-                    print(f"   Intentando revisión: {revision}")
+                    print(f"   Trying revision: {revision}")
                     processor = AutoImageProcessor.from_pretrained(model_id, revision=revision)
                     model = AutoModelForImageClassification.from_pretrained(model_id, revision=revision)
                 else:
                     processor = AutoImageProcessor.from_pretrained(model_id)
                     model = AutoModelForImageClassification.from_pretrained(model_id)
                 load_successful = True
-                break # Éxito en la carga, salir del bucle de revisiones
+                break
             except Exception as e_rev:
-                print(f"   Fallo con revisión '{revision}': {e_rev}")
-                if model_type == 'vit' and revision is None: # Si el tipo es 'vit' y la carga inicial falló, probar ViTImageProcessor
+                print(f"   Failed with revision '{revision}': {e_rev}")
+                if model_type == 'vit' and revision is None:
                     try:
                         processor = ViTImageProcessor.from_pretrained(model_id)
                         model = ViTForImageClassification.from_pretrained(model_id)
                         load_successful = True
                         break
                     except Exception as e_vit:
-                        print(f"   Fallo con ViTImageProcessor/ViTForImageClassification: {e_vit}")
-                        continue # Intentar la siguiente revisión
+                        print(f"   Failed with ViTImageProcessor/ViTForImageClassification: {e_vit}")
+                        continue
 
         if not load_successful:
-            raise Exception("No se pudo cargar el modelo con ninguna revisión o método alternativo.")
+            raise Exception("Failed to load model with all revisions.")
 
         model.eval()
 
-        # Verificar que el modelo funciona con una entrada dummy
         test_input = processor(Image.new('RGB', (224, 224), color='white'), return_tensors="pt")
         with torch.no_grad():
-            test_output = model(**test_input)
+            model(**test_input)
 
-        print(f"✅ {config['emoji']} {config['name']} cargado exitosamente")
+        print(f"✅ {config['emoji']} {config['name']} loaded successfully")
 
         return {
             'processor': processor,
             'model': model,
             'config': config,
-            'output_dim': test_output.logits.shape[-1] if hasattr(test_output, 'logits') else len(test_output[0]),
-            'category': config.get('category', 'general') # Añadimos la categoría aquí
+            'category': config.get('category', 'general')
         }
 
     except Exception as e:
-        print(f"❌ {config['emoji']} {config['name']} falló: {e}")
-        print(f"    Error detallado: {type(e).__name__}")
+        print(f"❌ {config['emoji']} {config['name']} failed: {e}")
         return None
 
-# Cargar modelos
-print("\n📦 Cargando modelos...")
-# Recorrer ambas categorías de modelos
+
+print("\n📦 Loading models...")
 for category, configs in MODEL_CONFIGS.items():
     for config in configs:
-        # Añadir la categoría al diccionario de configuración antes de pasar a load_model_safe
         config['category'] = category
         model_data = load_model_safe(config)
         if model_data:
@@ -204,187 +191,87 @@ for category, configs in MODEL_CONFIGS.items():
             model_performance[config['name']] = config.get('accuracy', 0.8)
 
 if not loaded_models:
-    print("❌ No se pudo cargar ningún modelo específico. Usando modelos de respaldo...")
-    # Modelos de respaldo - más amplios
+    print("❌ No model could be loaded. Using fallback models...")
     fallback_models = [
         'google/vit-base-patch16-224-in21k',
-        'microsoft/resnet-50',
-        'google/vit-large-patch16-224'
+        'microsoft/resnet-50'
     ]
 
     for fallback_id in fallback_models:
         try:
-            print(f"🔄 Intentando modelo de respaldo: {fallback_id}")
+            print(f"🔄 Trying fallback: {fallback_id}")
             processor = AutoImageProcessor.from_pretrained(fallback_id)
             model = AutoModelForImageClassification.from_pretrained(fallback_id)
             model.eval()
 
-            loaded_models[f'Respaldo-{fallback_id.split("/")[-1]}'] = {
+            loaded_models[f'Fallback-{fallback_id.split("/")[-1]}'] = {
                 'processor': processor,
                 'model': model,
-                'config': {
-                    'name': f'Respaldo {fallback_id.split("/")[-1]}',
-                    'emoji': '🏥',
-                    'accuracy': 0.75,
-                    'type': 'fallback',
-                    'category': 'general' # El de respaldo es general
-                },
-                'category': 'general', # El de respaldo es general
-                'type': 'standard'
+                'config': {'name': f'Fallback {fallback_id}', 'emoji': '🏥'},
+                'category': 'general'
             }
-            print(f"✅ Modelo de respaldo {fallback_id} cargado")
+            print(f"✅ Fallback model {fallback_id} loaded")
             break
         except Exception as e:
-            print(f"❌ Respaldo {fallback_id} falló: {e}")
+            print(f"❌ Fallback {fallback_id} failed: {e}")
             continue
 
-    if not loaded_models:
-        print(f"❌ ERROR CRÍTICO: No se pudo cargar ningún modelo")
-        print("💡 Verifica tu conexión a internet y que tengas transformers instalado")
-        loaded_models['Modelo Dummy'] = {
-            'type': 'dummy',
-            'config': {'name': 'Modelo No Disponible', 'emoji': '❌', 'accuracy': 0.0},
-            'category': 'dummy'
-        }
-
-# Clases de lesiones de piel (HAM10000 dataset)
+# --- SKIN LESION CLASSES ---
 CLASSES = [
-    "Queratosis actínica / Bowen (AKIEC)",
-    "Carcinoma células basales (BCC)",
-    "Lesión queratósica benigna (BKL)",
+    "Actinic Keratosis / Bowen (AKIEC)",
+    "Basal Cell Carcinoma (BCC)",
+    "Benign Keratosis (BKL)",
     "Dermatofibroma (DF)",
-    "Melanoma maligno (MEL)",
-    "Nevus melanocítico (NV)",
-    "Lesión vascular (VASC)"
+    "Malignant Melanoma (MEL)",
+    "Melanocytic Nevus (NV)",
+    "Vascular Lesion (VASC)"
 ]
 
-# Sistema de riesgo
 RISK_LEVELS = {
-    0: {'level': 'Alto', 'color': '#ff6b35', 'urgency': 'Derivación en 48h'},
-    1: {'level': 'Crítico', 'color': '#cc0000', 'urgency': 'Derivación inmediata'},
-    2: {'level': 'Bajo', 'color': '#44ff44', 'urgency': 'Control rutinario'},
-    3: {'level': 'Bajo', 'color': '#44ff44', 'urgency': 'Control rutinario'},
-    4: {'level': 'Crítico', 'color': '#990000', 'urgency': 'URGENTE - Oncología'},
-    5: {'level': 'Bajo', 'color': '#66ff66', 'urgency': 'Seguimiento 6 meses'},
-    6: {'level': 'Moderado', 'color': '#ffaa00', 'urgency': 'Control en 3 meses'}
+    0: {'level': 'High', 'color': '#ff6b35', 'urgency': 'Referral in 48h'},
+    1: {'level': 'Critical', 'color': '#cc0000', 'urgency': 'Immediate referral'},
+    2: {'level': 'Low', 'color': '#44ff44', 'urgency': 'Routine check'},
+    3: {'level': 'Low', 'color': '#44ff44', 'urgency': 'Routine check'},
+    4: {'level': 'Critical', 'color': '#990000', 'urgency': 'URGENT - Oncology'},
+    5: {'level': 'Low', 'color': '#66ff66', 'urgency': 'Follow-up in 6 months'},
+    6: {'level': 'Moderate', 'color': '#ffaa00', 'urgency': 'Check-up in 3 months'}
 }
 
-MALIGNANT_INDICES = [0, 1, 4]  # AKIEC, BCC, Melanoma
+MALIGNANT_INDICES = [0, 1, 4]
 
+# --- PREDICTION FUNCTION ---
 def predict_with_model(image, model_data):
-    """Predicción con un modelo específico - versión mejorada"""
     try:
         config = model_data['config']
-
-        # Redimensionar imagen
         image_resized = image.resize((224, 224), Image.LANCZOS)
 
-        if model_data.get('type') == 'pipeline': # Esto debería ser poco común con la lista actual
-            pipeline = model_data['pipeline']
-            results = pipeline(image_resized)
-
-            if isinstance(results, list) and len(results) > 0:
-                mapped_probs = np.ones(7) / 7
-                confidence = results[0]['score'] if 'score' in results[0] else 0.5
-
-                label = results[0].get('label', '').lower()
-                if any(word in label for word in ['melanoma', 'mel', 'malignant', 'cancer']):
-                    predicted_idx = 4
-                elif any(word in label for word in ['carcinoma', 'bcc', 'basal']):
-                    predicted_idx = 1
-                elif any(word in label for word in ['keratosis', 'akiec']):
-                    predicted_idx = 0
-                elif any(word in label for word in ['nevus', 'nv', 'benign']):
-                    predicted_idx = 5
-                else:
-                    predicted_idx = 2
-
-                mapped_probs[predicted_idx] = confidence
-                remaining_sum = (1.0 - confidence)
-                if remaining_sum < 0: remaining_sum = 0
-
-                num_other_classes = 6
-                if num_other_classes > 0:
-                    remaining_per_class = remaining_sum / num_other_classes
-                    for i in range(7):
-                        if i != predicted_idx:
-                            mapped_probs[i] = remaining_per_class
-
-            else:
-                mapped_probs = np.ones(7) / 7
-                predicted_idx = 5
-                confidence = 0.3
-
-        else: # Usar modelo estándar (AutoModel/ViT)
-            processor = model_data['processor']
-            model = model_data['model']
+        processor = model_data['processor']
+        model = model_data['model']
+        inputs = processor(image_resized, return_tensors="pt")
 
-            inputs = processor(image_resized, return_tensors="pt")
-
-            with torch.no_grad():
-                outputs = model(**inputs)
-
-                if hasattr(outputs, 'logits'):
-                    logits = outputs.logits
-                else:
-                    logits = outputs[0] if isinstance(outputs, (tuple, list)) else outputs
-
-                probabilities = F.softmax(logits, dim=-1).cpu().numpy()[0]
-
-            # --- Mapeo de probabilidades según el número de clases de salida del modelo ---
-            if len(probabilities) == 7: # Modelos ya entrenados para 7 clases de piel
-                mapped_probs = probabilities
-            elif len(probabilities) == 2: # Modelos binarios (e.g., maligno/benigno)
-                mapped_probs = np.zeros(7)
-                # Asumimos que la clase 0 es benigna y la 1 es maligna en un modelo binario
-                if probabilities[1] > 0.5: # Predicción de maligno
-                    # Distribuimos la probabilidad maligna entre los tipos malignos conocidos, dando más peso al melanoma
-                    mapped_probs[4] = probabilities[1] * 0.5  # Melanoma
-                    mapped_probs[1] = probabilities[1] * 0.3  # BCC
-                    mapped_probs[0] = probabilities[1] * 0.2  # AKIEC
-                else: # Predicción de benigno
-                    # Distribuimos la probabilidad benigna entre los tipos benignos conocidos, dando más peso al nevus
-                    mapped_probs[5] = probabilities[0] * 0.6  # Nevus (más común)
-                    mapped_probs[2] = probabilities[0] * 0.2  # BKL
-                    mapped_probs[3] = probabilities[0] * 0.1  # DF
-                    mapped_probs[6] = probabilities[0] * 0.1  # VASC
-                mapped_probs = mapped_probs / np.sum(mapped_probs) # Normalizar para que sumen 1
-            elif len(probabilities) in [1000, 900]: # Modelos generales como los de ImageNet (1000 clases) o modelos preentrenados en ImageNet-21k (900 clases)
-                mapped_probs = np.zeros(7)
-                # Intentar mapear las clases del modelo a las clases de piel si hay un id2label
-                if hasattr(model, 'config') and hasattr(model.config, 'id2label'):
-                    model_labels = {v.lower(): k for k, v in model.config.id2label.items()}
-                    # Asignar probabilidades a las clases de piel si coinciden
-                    for i, skin_class in enumerate(CLASSES):
-                        # Intentar buscar la etiqueta completa o una parte clave
-                        key_words = skin_class.split('(')[1].rstrip(')').lower().split()
-                        found = False
-                        for key_word in key_words:
-                            for model_label, model_idx in model_labels.items():
-                                if key_word in model_label:
-                                    # Sumar la probabilidad de la clase del modelo a la clase de piel
-                                    mapped_probs[i] += probabilities[model_idx]
-                                    found = True
-                                    break
-                            if found: break # Ya encontramos una coincidencia para esta clase de piel
-                
-                # Si después del intento de mapeo, las probabilidades son cero o muy bajas,
-                # o si no hay id2label, usar la distribución uniforme (o heurística)
-                if np.sum(mapped_probs) == 0:
-                    print(f"Advertencia: No se pudo mapear clases específicas para {config['name']} ({len(probabilities)} clases). Usando distribución heurística.")
-                    mapped_probs = np.ones(7) / 7 # Empezamos con distribución uniforme
-                    # Ajuste heurístico: Asignamos un poco más de peso a clases benignas por defecto
-                    mapped_probs[5] += 0.1 # Aumentar Nevus (NV) ligeramente
-                    mapped_probs[2] += 0.05 # Aumentar Lesión queratósica benigna (BKL) ligeramente
-                    mapped_probs = mapped_probs / np.sum(mapped_probs) # Re-normalizar
-                else:
-                    mapped_probs = mapped_probs / np.sum(mapped_probs) # Normalizar las probabilidades mapeadas
-            else: # Otros casos de dimensiones de salida no esperadas: distribución uniforme
-                print(f"Advertencia: Dimensión de salida inesperada para {config['name']} ({len(probabilities)} clases). Usando distribución uniforme.")
-                mapped_probs = np.ones(7) / 7
-
-            predicted_idx = int(np.argmax(mapped_probs))
-            confidence = float(mapped_probs[predicted_idx])
+        with torch.no_grad():
+            outputs = model(**inputs)
+            logits = outputs.logits if hasattr(outputs, 'logits') else outputs[0]
+            probabilities = F.softmax(logits, dim=-1).cpu().numpy()[0]
+
+        # Handling models with unexpected output dimensions
+        if len(probabilities) == 7:
+            mapped_probs = probabilities
+        elif len(probabilities) == 2:
+            mapped_probs = np.zeros(7)
+            mapped_probs[4] = probabilities[1] * 0.5
+            mapped_probs[1] = probabilities[1] * 0.3
+            mapped_probs[0] = probabilities[1] * 0.2
+            mapped_probs[5] = probabilities[0] * 0.6
+            mapped_probs[2] = probabilities[0] * 0.2
+            mapped_probs[3] = probabilities[0] * 0.1
+            mapped_probs[6] = probabilities[0] * 0.1
+            mapped_probs /= np.sum(mapped_probs)
+        else:
+            mapped_probs = np.ones(7) / 7
+
+        predicted_idx = int(np.argmax(mapped_probs))
+        confidence = float(mapped_probs[predicted_idx])
 
         return {
             'model': f"{config['emoji']} {config['name']}",
@@ -394,419 +281,63 @@ def predict_with_model(image, model_data):
             'is_malignant': predicted_idx in MALIGNANT_INDICES,
             'predicted_idx': predicted_idx,
             'success': True,
-            'category': model_data['category'] # Añadir la categoría de vuelta
+            'category': model_data['category']
         }
 
     except Exception as e:
-        print(f"❌ Error en {config['name']}: {e}")
-        return {
-            'model': f"{config.get('name', 'Modelo desconocido')}",
-            'success': False,
-            'error': str(e),
-            'category': model_data.get('category', 'unknown')
-        }
-
-def create_probability_chart(predictions, consensus_class):
-    """Crear gráfico de barras con probabilidades"""
-    try:
-        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
-
-        # Gráfico 1: Probabilidades por clase (consenso)
-        if predictions:
-            avg_probs = np.zeros(7)
-            valid_predictions = [p for p in predictions if p.get('success', False)]
-
-            if len(valid_predictions) > 0:
-                for pred in valid_predictions:
-                    if isinstance(pred['probabilities'], np.ndarray) and len(pred['probabilities']) == 7 and not np.isnan(pred['probabilities']).any():
-                        avg_probs += pred['probabilities']
-                    else:
-                        print(f"Advertencia: Probabilidades no válidas para {pred['model']}: {pred['probabilities']}")
-                avg_probs /= len(valid_predictions)
-            else:
-                avg_probs = np.ones(7) / 7
-
-            colors = ['#ff6b35' if i in MALIGNANT_INDICES else '#44ff44' for i in range(7)]
-            bars = ax1.bar(range(7), avg_probs, color=colors, alpha=0.8)
-
-            if consensus_class in CLASSES:
-                consensus_idx = CLASSES.index(consensus_class)
-                bars[consensus_idx].set_color('#2196F3')
-                bars[consensus_idx].set_linewidth(3)
-                bars[consensus_idx].set_edgecolor('black')
-
-            ax1.set_xlabel('Tipos de Lesión')
-            ax1.set_ylabel('Probabilidad Promedio')
-            ax1.set_title('📊 Distribución de Probabilidades por Clase')
-            ax1.set_xticks(range(7))
-            ax1.set_xticklabels([cls.split('(')[1].rstrip(')') for cls in CLASSES], rotation=45)
-            ax1.grid(True, alpha=0.3)
-
-            for i, bar in enumerate(bars):
-                height = bar.get_height()
-                ax1.text(bar.get_x() + bar.get_width()/2., height + 0.01,
-                                    f'{height:.2%}', ha='center', va='bottom', fontsize=9)
-
-        # Gráfico 2: Confianza por modelo
-        valid_predictions = [p for p in predictions if p.get('success', False)]
-        model_names = [pred['model'].split(' ')[1] if len(pred['model'].split(' ')) > 1 else pred['model'] for pred in valid_predictions]
-        confidences = [pred['confidence'] for pred in valid_predictions]
-
-        colors_conf = ['#ff6b35' if pred['is_malignant'] else '#44ff44' for pred in valid_predictions]
-        bars2 = ax2.bar(range(len(valid_predictions)), confidences, color=colors_conf, alpha=0.8)
-
-        ax2.set_xlabel('Modelos')
-        ax2.set_ylabel('Confianza')
-        ax2.set_title('🎯 Confianza por Modelo')
-        ax2.set_xticks(range(len(valid_predictions)))
-        ax2.set_xticklabels(model_names, rotation=45)
-        ax2.grid(True, alpha=0.3)
-        ax2.set_ylim(0, 1)
-
-        for i, bar in enumerate(bars2):
-            height = bar.get_height()
-            ax2.text(bar.get_x() + bar.get_width()/2., height + 0.01,
-                                f'{height:.1%}', ha='center', va='bottom', fontsize=9)
-
-        plt.tight_layout()
-
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
-        buf.seek(0)
-        chart_b64 = base64.b64encode(buf.getvalue()).decode()
-        plt.close()
-
-        return f'<img src="data:image/png;base64,{chart_b64}" style="width:100%; max-width:800px;">'
-
-    except Exception as e:
-        print(f"Error creando gráfico: {e}")
-        return "<p>❌ Error generando gráfico de probabilidades</p>"
-
-def create_heatmap(predictions):
-    """Crear mapa de calor de probabilidades por modelo"""
-    try:
-        valid_predictions = [p for p in predictions if p.get('success', False)]
-
-        if not valid_predictions:
-            return "<p>No hay datos suficientes para el mapa de calor</p>"
-
-        prob_matrix_list = []
-        model_names_for_heatmap = []
-        for pred in valid_predictions:
-            if isinstance(pred['probabilities'], np.ndarray) and len(pred['probabilities']) == 7 and not np.isnan(pred['probabilities']).any():
-                prob_matrix_list.append(pred['probabilities'])
-                model_names_for_heatmap.append(pred['model'])
-            else:
-                print(f"Advertencia: Probabilidades no válidas para heatmap de {pred['model']}: {pred['probabilities']}")
-
-        if not prob_matrix_list:
-            return "<p>No hay datos válidos para el mapa de calor después de filtrar.</p>"
-
-        prob_matrix = np.array(prob_matrix_list)
-
-        fig, ax = plt.subplots(figsize=(10, len(model_names_for_heatmap) * 0.8))
-
-        im = ax.imshow(prob_matrix, cmap='RdYlGn_r', aspect='auto', vmin=0, vmax=1)
-
-        ax.set_xticks(np.arange(7))
-        ax.set_yticks(np.arange(len(model_names_for_heatmap)))
-        ax.set_xticklabels([cls.split('(')[1].rstrip(')') for cls in CLASSES])
-        ax.set_yticklabels(model_names_for_heatmap)
-
-        plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
-
-        for i in range(len(model_names_for_heatmap)):
-            for j in range(7):
-                text = ax.text(j, i, f'{prob_matrix[i, j]:.2f}',
-                                    ha="center", va="center", color="white" if prob_matrix[i, j] > 0.5 else "black",
-                                    fontsize=8)
-
-        ax.set_title("Mapa de Calor: Probabilidades por Modelo y Clase")
-        fig.tight_layout()
-
-        cbar = plt.colorbar(im, ax=ax)
-        cbar.set_label('Probabilidad', rotation=270, labelpad=15)
-
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
-        buf.seek(0)
-        heatmap_b64 = base64.b64encode(buf.getvalue()).decode()
-        plt.close()
-
-        return f'<img src="data:image/png;base64,{heatmap_b64}" style="width:100%; max-width:800px;">'
-
-    except Exception as e:
-        print(f"Error creando mapa de calor: {e}")
-        return "<p>❌ Error generando mapa de calor</p>"
-
-def analizar_lesion(img):
-    """Función principal para analizar la lesión"""
-    try:
-        if img is None:
-            return "<h3>⚠️ Por favor, carga una imagen</h3>"
-
-        if not loaded_models or all(m.get('type') == 'dummy' for m in loaded_models.values()):
-            return "<h3>❌ Error del Sistema</h3><p>No hay modelos disponibles. Por favor, recarga la aplicación.</p>"
-
-        if img.mode != 'RGB':
-            img = img.convert('RGB')
-
-        predictions = []
-
-        for model_name, model_data in loaded_models.items():
-            if model_data.get('type') != 'dummy':
-                pred = predict_with_model(img, model_data)
-                if pred.get('success', False):
-                    predictions.append(pred)
-
-        if not predictions:
-            return "<h3>❌ Error</h3><p>No se pudieron obtener predicciones de ningún modelo.</p>"
-
-        # Análisis de consenso
-        class_votes = {}
-        confidence_sum = {}
-
-        for pred in predictions:
-            class_name = pred['class']
-            confidence = pred['confidence']
-
-            if class_name not in class_votes:
-                class_votes[class_name] = 0
-                confidence_sum[class_name] = 0
-
-            class_votes[class_name] += 1
-            confidence_sum[class_name] += confidence
-
-        # Manejar el caso donde no hay votos por alguna razón (aunque predictions ya valida que hay)
-        if not class_votes:
-             return "<h3>❌ Error en el Consenso</h3><p>No se pudieron consolidar los votos de los modelos.</p>"
-
-        consensus_class = max(class_votes.keys(), key=lambda x: class_votes[x])
-        avg_confidence = confidence_sum[consensus_class] / class_votes[consensus_class]
-
-        consensus_idx = CLASSES.index(consensus_class)
-        is_malignant = consensus_idx in MALIGNANT_INDICES
-        risk_info = RISK_LEVELS[consensus_idx]
-
-        probability_chart = create_probability_chart(predictions, consensus_class)
-        heatmap = create_heatmap(predictions)
-
-        html_report = f"""
-        <div style="font-family: Arial, sans-serif; max-width: 1200px; margin: 0 auto;">
-            <h2 style="color: #2c3e50; text-align: center;">🏥 Análisis Completo de Lesión Cutánea</h2>
-
-            <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; margin: 20px 0;">
-                <h3 style="margin: 0; text-align: center;">📋 Resultado de Consenso</h3>
-                <p style="font-size: 18px; text-align: center; margin: 10px 0;"><strong>{consensus_class}</strong></p>
-                <p style="text-align: center; margin: 5px 0;">Confianza Promedio: <strong>{avg_confidence:.1%}</strong></p>
-                <p style="text-align: center; margin: 5px 0;">Consenso: <strong>{class_votes[consensus_class]}/{len(predictions)} modelos</strong></p>
-            </div>
-
-            <div style="background: {risk_info['color']}; color: white; padding: 15px; border-radius: 8px; margin: 15px 0;">
-                <h4 style="margin: 0;">⚠️ Nivel de Riesgo: {risk_info['level']}</h4>
-                <p style="margin: 5px 0;"><strong>{risk_info['urgency']}</strong></p>
-                <p style="margin: 5px 0;">Tipo: {'🔴 Potencialmente maligna' if is_malignant else '🟢 Probablemente benigna'}</p>
-            </div>
-
-            <div style="background: #e3f2fd; padding: 15px; border-radius: 8px; margin: 15px 0;">
-                <h4 style="color: #1976d2;">🤖 Resultados Individuales por Modelo</h4>
-                <p style="font-size: 0.9em; color: #555;">
-                    A continuación se detallan las predicciones de cada modelo. Es importante destacar que los <strong>modelos entrenados específicamente en lesiones de piel (Categoría: Especializados) suelen ser más fiables</strong> para este tipo de análisis que los modelos generales.
-                </p>
-        """
-
-        # RESULTADOS INDIVIDUALES DETALLADOS - Separados por categoría
-
-        # Especializados
-        html_report += """
-        <h5 style="color: #007bff; border-bottom: 1px solid #007bff; padding-bottom: 5px; margin-top: 20px;">
-            Modelos Especializados en Lesiones de Piel
-        </h5>
-        """
-        specialized_models_found = False
-        for i, pred in enumerate(predictions):
-            if pred['success'] and pred['category'] == 'especializados':
-                specialized_models_found = True
-                model_risk = RISK_LEVELS[pred['predicted_idx']]
-                malignant_status = "🔴 Maligna" if pred['is_malignant'] else "🟢 Benigna"
-
-                html_report += f"""
-                <div style="margin: 15px 0; padding: 15px; background: white; border-radius: 8px; border-left: 5px solid {'#ff6b35' if pred['is_malignant'] else '#44ff44'}; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-                    <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
-                        <h5 style="margin: 0; color: #333;">{pred['model']}</h5>
-                        <span style="background: {model_risk['color']}; color: white; padding: 4px 8px; border-radius: 4px; font-size: 12px;">{model_risk['level']}</span>
-                    </div>
-
-                    <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 10px; font-size: 14px;">
-                        <div><strong>Diagnóstico:</strong><br>{pred['class']}</div>
-                        <div><strong>Confianza:</strong><br>{pred['confidence']:.1%}</div>
-                        <div><strong>Clasificación:</strong><br>{malignant_status}</div>
-                    </div>
-
-                    <div style="margin-top: 10px;">
-                        <strong>Top 3 Probabilidades:</strong><br>
-                        <div style="font-size: 12px; color: #666;">
-                """
-
-                top_indices = np.argsort(pred['probabilities'])[-3:][::-1]
-                for idx in top_indices:
-                    prob = pred['probabilities'][idx]
-                    if prob > 0.01:
-                        html_report += f"• {CLASSES[idx].split('(')[1].rstrip(')')}: {prob:.1%}<br>"
-
-                html_report += f"""
-                        </div>
-                        <div style="margin-top: 8px; font-size: 12px; color: #888;">
-                            <strong>Recomendación:</strong> {model_risk['urgency']}
-                        </div>
-                    </div>
-                </div>
-                """
-        if not specialized_models_found:
-            html_report += "<p style='color: #888;'>No se cargaron modelos especializados o fallaron al predecir.</p>"
-
-        # Generales
-        html_report += """
-        <h5 style="color: #6c757d; border-bottom: 1px solid #6c757d; padding-bottom: 5px; margin-top: 20px;">
-            Modelos Generales de Visión
-        </h5>
-        <p style="font-size: 0.85em; color: #777;">
-            Estos modelos son pre-entrenados en grandes datasets de imágenes generales (como ImageNet). Aunque no están optimizados específicamente para lesiones cutáneas, contribuyen al consenso general con su capacidad para reconocer patrones visuales. Sus predicciones son un complemento útil, pero pueden ser menos precisas que las de los modelos especializados.
-        </p>
-        """
-        general_models_found = False
-        for i, pred in enumerate(predictions):
-            if pred['success'] and pred['category'] == 'generales':
-                general_models_found = True
-                model_risk = RISK_LEVELS[pred['predicted_idx']]
-                malignant_status = "🔴 Maligna" if pred['is_malignant'] else "🟢 Benigna"
-
-                html_report += f"""
-                <div style="margin: 15px 0; padding: 15px; background: white; border-radius: 8px; border-left: 5px solid {'#ff6b35' if pred['is_malignant'] else '#44ff44'}; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-                    <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
-                        <h5 style="margin: 0; color: #333;">{pred['model']}</h5>
-                        <span style="background: {model_risk['color']}; color: white; padding: 4px 8px; border-radius: 4px; font-size: 12px;">{model_risk['level']}</span>
-                    </div>
-
-                    <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 10px; font-size: 14px;">
-                        <div><strong>Diagnóstico:</strong><br>{pred['class']}</div>
-                        <div><strong>Confianza:</strong><br>{pred['confidence']:.1%}</div>
-                        <div><strong>Clasificación:</strong><br>{malignant_status}</div>
-                    </div>
-
-                    <div style="margin-top: 10px;">
-                        <strong>Top 3 Probabilidades:</strong><br>
-                        <div style="font-size: 12px; color: #666;">
-                """
-
-                top_indices = np.argsort(pred['probabilities'])[-3:][::-1]
-                for idx in top_indices:
-                    prob = pred['probabilities'][idx]
-                    if prob > 0.01:
-                        html_report += f"• {CLASSES[idx].split('(')[1].rstrip(')')}: {prob:.1%}<br>"
-
-                html_report += f"""
-                        </div>
-                        <div style="margin-top: 8px; font-size: 12px; color: #888;">
-                            <strong>Recomendación:</strong> {model_risk['urgency']}
-                        </div>
-                    </div>
-                </div>
-                """
-        if not general_models_found:
-            html_report += "<p style='color: #888;'>No se cargaron modelos generales o fallaron al predecir.</p>"
-
-        html_report += f"""
-            </div>
-
-            <div style="background: #f8f9fa; padding: 15px; border-radius: 8px; margin: 15px 0;">
-                <h4 style="color: #495057;">📊 Análisis Estadístico</h4>
-                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px;">
-                    <div>
-                        {probability_chart}
-                    </div>
-                    <div>
-                        {heatmap}
-                    </div>
-                </div>
-            </div>
-
-            <div style="background: #fff3cd; color: #856404; padding: 15px; border-radius: 8px; margin: 15px 0; border: 1px solid #ffeeba;">
-                <h4 style="margin-top: 0;">Disclaimer Importante:</h4>
-                <p style="font-size: 0.9em; margin-bottom: 5px;">
-                    Esta herramienta es un <strong>prototipo de investigación</strong> y no debe ser utilizada como un diagnóstico médico definitivo. Los resultados son generados por modelos de inteligencia artificial y pueden contener errores.
-                </p>
-                <p style="font-size: 0.9em; margin-bottom: 5px;">
-                    <strong>Siempre consulte a un profesional médico cualificado</strong> para cualquier inquietud sobre su salud. La automedicación o el autodiagnóstico basado en esta herramienta puede ser perjudicial.
-                </p>
-                <p style="font-size: 0.9em; margin-bottom: 0;">
-                    La precisión de los modelos puede variar. Los modelos especializados en piel tienden a ser más fiables para estas tareas específicas.
-                </p>
-            </div>
-        </div>
-        """
-        return html_report
-
-    except Exception as e:
-        error_message = f"<h3>❌ Error Inesperado en el Análisis:</h3><p>Se produjo un error durante el procesamiento: {str(e)}</p><p>Por favor, intenta con otra imagen o recarga la aplicación.</p>"
-        print(error_message)
-        return error_message
-
-
-# --- INTERFAZ GRADIO ---
-# Componentes de entrada y salida
-image_input = gr.Image(type="pil", label="Sube una imagen de la lesión cutánea")
-output_html = gr.HTML(label="Informe de Análisis")
-
-# Títulos y descripción para la interfaz
-title = "Skin Lesion Analysis AI"
-description = """
-<h1 style="text-align: center; color: #2c3e50;">🩺 Analizador de Lesiones Cutáneas impulsado por IA 🩺</h1>
-<p style="text-align: center; font-size: 1.1em; color: #555;">
-    Esta herramienta utiliza una batería de modelos de Visión por Computadora (tanto especializados en lesiones de piel como generales) para analizar imágenes y ofrecer un consenso sobre el tipo de lesión.
-    Proporciona un informe detallado con diagnósticos individuales de cada modelo y un consenso general, incluyendo un nivel de riesgo.
-</p>
-<p style="text-align: center; font-size: 1.1em; color: #555;">
-    <strong>Instrucciones:</strong> Sube una imagen clara de la lesión cutánea (óptimamente con buena iluminación y sin reflejos).
-</p>
-<p style="text-align: center; font-size: 0.9em; color: #888;">
-    ⚠️ **Importante:** Esta herramienta es solo para **fines de investigación y educativos**. No reemplaza el consejo médico profesional. Siempre consulta a un dermatólogo para un diagnóstico y tratamiento precisos.
-</p>
-"""
-article = """
-<div style="text-align: center; padding: 20px; background-color: #f0f2f5; border-top: 1px solid #e0e2e5;">
-    <h3 style="color: #333;">¿Cómo funciona?</h3>
-    <p style="color: #666;">
-        El sistema carga múltiples modelos de aprendizaje profundo (Convolutional Neural Networks y Vision Transformers) entrenados en diversos datasets, incluyendo conjuntos de datos médicos de lesiones cutáneas (como HAM10000 e ISIC) y datasets generales de imágenes (como ImageNet).
-        Cada modelo procesa la imagen de forma independiente y genera una predicción de probabilidad para cada una de las 7 clases de lesiones de piel más comunes.
-        Posteriormente, se realiza un análisis de consenso para consolidar las predicciones, ponderando la confianza de cada modelo y dando preferencia a los modelos entrenados específicamente para el dominio de la piel.
-        Finalmente, se genera un informe visual con gráficos de barras y mapas de calor para facilitar la interpretación de los resultados.
-    </p>
-    <h4 style="color: #333;">Clases de Lesiones Analizadas:</h4>
-    <ul style="list-style-type: none; padding: 0; color: #666; display: inline-block; text-align: left;">
-        <li><strong>AKIEC:</strong> Queratosis actínica / Carcinoma de Bowen</li>
-        <li><strong>BCC:</strong> Carcinoma de células basales</li>
-        <li><strong>BKL:</strong> Lesión queratósica benigna (verruga seborreica, queratosis actínica, liquen plano)</li>
-        <li><strong>DF:</strong> Dermatofibroma</li>
-        <li><strong>MEL:</strong> Melanoma maligno</li>
-        <li><strong>NV:</strong> Nevus melanocítico (Lunar)</li>
-        <li><strong>VASC:</strong> Lesión vascular (angiomas, telangiectasias)</li>
-    </ul>
-    <p style="font-size: 0.8em; color: #999; margin-top: 20px;">
-        Desarrollado con ❤️ para investigación en IA y salud.
-    </p>
-</div>
-"""
-
-# Lanzar la interfaz Gradio
+        print(f"❌ Error in {config['name']}: {e}")
+        return {'model': config['name'], 'success': False, 'error': str(e)}
+
+# --- CONSENSUS ANALYSIS FUNCTION ---
+def analyze_lesion(img):
+    if img is None:
+        return "<h3>⚠️ Please upload an image</h3>"
+
+    predictions = []
+    for model_name, model_data in loaded_models.items():
+        if model_data.get('category') != 'dummy':
+            pred = predict_with_model(img, model_data)
+            if pred.get('success'):
+                predictions.append(pred)
+
+    if not predictions:
+        return "<h3>❌ No valid predictions</h3>"
+
+    class_votes, confidence_sum = {}, {}
+    for pred in predictions:
+        c = pred['class']
+        conf = pred['confidence']
+        class_votes[c] = class_votes.get(c, 0) + 1
+        confidence_sum[c] = confidence_sum.get(c, 0) + conf
+
+    consensus_class = max(class_votes, key=class_votes.get)
+    avg_conf = confidence_sum[consensus_class] / class_votes[consensus_class]
+    consensus_idx = CLASSES.index(consensus_class)
+    risk_info = RISK_LEVELS[consensus_idx]
+
+    return f"""
+    <h2>🏥 Skin Lesion Analysis Report</h2>
+    <h3>Consensus Diagnosis: {consensus_class}</h3>
+    <p>Average Confidence: <b>{avg_conf:.1%}</b></p>
+    <p>Risk Level: <b style='color:{risk_info['color']}'>{risk_info['level']}</b></p>
+    <p>Recommendation: {risk_info['urgency']}</p>
+    <hr>
+    <h4>Model Details:</h4>
+    {''.join([f"<p>{p['model']}: {p['class']} ({p['confidence']:.1%})</p>" for p in predictions])}
+    <hr>
+    <p style='color:gray;'>⚠️ This AI tool is for educational and research purposes only. Always consult a dermatologist for accurate medical diagnosis.</p>
+    """
+
+# --- GRADIO INTERFACE ---
 gr.Interface(
-    fn=analizar_lesion,
-    inputs=image_input,
-    outputs=output_html,
-    title=title,
-    description=description,
-    article=article,
-    theme="soft",
-    allow_flagging="auto", # Permite que los usuarios marquen resultados para mejorar el modelo
-    flagging_dir="flagged_data" # Directorio para guardar los datos marcados
-).launch(debug=True)
+    fn=analyze_lesion,
+    inputs=gr.Image(type="pil", label="Upload a Skin Lesion Image"),
+    outputs=gr.HTML(label="AI Analysis Report"),
+    title="Skin Lesion Analysis AI",
+    description="""
+    <h2 style="text-align:center;">🩺 AI-Powered Skin Lesion Analyzer 🩺</h2>
+    <p style="text-align:center;">Upload a clear skin lesion image. The system runs several deep learning models (both skin-specialized and general vision models) and provides a consensus diagnosis with confidence and risk level.</p>
+    <p style="text-align:center; color:gray;">⚠️ Research prototype only. Not a substitute for professional medical advice.</p>
+    """,
+    theme="soft"
+).launch(debug=True)