feat (interfaz): Actualizar interfaz gradio

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 7860
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,274 @@
----
-title: App
-emoji: 🐠
-colorFrom: indigo
-colorTo: gray
-sdk: gradio
-sdk_version: 6.5.1
-app_file: app.py
-pinned: false
+# 🥔 Clasificador de Calidad de Papas - Gradio
+
+Aplicación de clasificación de calidad de tubérculos de papa (Chaucha y Chola) usando Vision Transformer (ViT-Base/16) con interfaz mejorada en Gradio.
+
+## 🌟 Características
+
+- **Modelo de última generación**: Vision Transformer (ViT-Base/16) afinado para clasificación de papa chaucha y chola.
+- **Interfaz moderna**: Gradio con diseño responsive y visualizaciones interactivas
+- **Visualización explicable**: Mapas de atención Grad-CAM para interpretar las decisiones del modelo
+- **Alto rendimiento**: Optimizado para CPU y GPU
+- **Métricas en tiempo real**: Tiempo de inferencia y confianza por clase
+- **Validación robusta**: Manejo de errores y validación de entrada
+
+## 📋 Requisitos
+
+- Python 3.8 o superior
+- CUDA (opcional, para aceleración GPU)
+- 4GB RAM mínimo (8GB recomendado)
+
+## 🚀 Instalación
+
+### 1. Clonar o descargar el repositorio
+
+```bash
+cd streamlit/demo
+```
+
+### 2. Crear entorno virtual (recomendado)
+
+**Windows:**
+
+```bash
+python -m venv venv
+.\venv\Scripts\activate
+```
+
+**Linux/Mac:**
+
+```bash
+python3 -m venv venv
+source venv/bin/activate
+```
+
+### 3. Instalar dependencias
+
+```bash
+pip install -r requirements_gradio.txt
+```
+
+### 4. Configurar token de Hugging Face (opcional)
+
+Si el modelo no se descarga automáticamente, crea un archivo `.env` o configura la variable de entorno:
+
+**Windows:**
+
+```bash
+set HF_TOKEN=tu_token_aqui
+```
+
+**Linux/Mac:**
+
+```bash
+export HF_TOKEN=tu_token_aqui
+```
+
+Obtén tu token en: https://huggingface.co/settings/tokens
+
+## 🎯 Uso
+
+### Ejecución local
+
+```bash
+python app.py
+```
+
+La aplicación se abrirá automáticamente en tu navegador en:
+
+```
+http://localhost:7860
+```
+
+### Ejecución con compartir (público temporalmente)
+
+Modifica `demo.launch()` en `app.py`:
+
+```python
+demo.launch(share=True)  # Genera una URL pública temporal
+```
+
+## 📊 Clases de Clasificación
+
+| Clase           | Descripción                                            |
+| --------------- | ------------------------------------------------------ |
+| **Buen estado** | Papa sin defectos visibles, apta para comercialización |
+| **Defectuoso**  | Papa con daños, manchas o deformaciones                |
+
+## 🎨 Características de la Interfaz
+
+### Panel de Entrada
+
+- Arrastrar y soltar imágenes
+- Formatos soportados: PNG, JPG, JPEG
+- Tamaño máximo: 20 MB
+- Vista previa en tiempo real
+
+### Panel de Resultados
+
+- **Predicción principal**: Clase y confianza
+- **Gráficos de confianza**: Barras de progreso por cada clase
+- **Mapa de atención**: Visualización Grad-CAM de regiones importantes
+- **Métricas de rendimiento**: Tiempo de procesamiento y dispositivo usado
+
+## 🧠 Arquitectura del Modelo
+
+```
+Input Image (224×224×3)
+    ↓
+Vision Transformer Base
+    ├─ Patch Embedding (16×16)
+    ├─ 12 Transformer Blocks
+    └─ Classification Head
+    ↓
+Output (2 clases)
+```
+
+### Especificaciones Técnicas
+
+- **Arquitectura**: ViT-Base/16
+- **Parámetros**: ~86M
+- **Input**: 224×224 RGB
+- **Normalización**: ImageNet stats
+- **Framework**: PyTorch + timm
+
+## 📈 Interpretación del Mapa de Atención
+
+El mapa Grad-CAM muestra en **rojo intenso** las áreas que más influyeron en la decisión:
+
+- 🔴 **Rojo**: Alta importancia (defectos detectados)
+- 🟡 **Amarillo**: Importancia media
+- 🔵 **Azul**: Baja importancia
+
+## 🔧 Configuración Avanzada
+
+### Cambiar puerto
+
+En `app.py`:
+
+```python
+demo.launch(server_port=8080)  # Cambiar puerto
+```
+
+### Modo desarrollo
+
+```python
+demo.launch(debug=True)  # Habilitar modo debug
+```
+
+### Recursos compartidos
+
+```python
+demo.launch(
+    server_name="0.0.0.0",  # Accesible desde la red local
+    share=True,              # Generar link público
+    auth=("usuario", "contraseña")  # Agregar autenticación
+)
+```
+
+## 🐛 Solución de Problemas
+
+### Error: "No module named 'gradio'"
+
+```bash
+pip install gradio --upgrade
+```
+
+### Error: Modelo no descarga
+
+1. Verifica conexión a internet
+2. Configura `HF_TOKEN` en variables de entorno
+3. Intenta descargar manualmente:
+
+```python
+from huggingface_hub import hf_hub_download
+hf_hub_download("Carlos012/vit_papas", "vit_papas_ft.pt")
+```
+
+### Error: CUDA out of memory
+
+- Usa CPU en lugar de GPU
+- Reduce el tamaño de las imágenes antes de subirlas
+
+### La interfaz no carga
+
+```bash
+# Verificar puerto en uso
+netstat -an | findstr :7860
+
+# Cambiar puerto en app_gradio.py
+demo.launch(server_port=7861)
+```
+
+## 📦 Estructura del Proyecto
+
+```
+streamlit/demo/
+├── app.py              # Aplicación principal Gradio
+├── requirements.txt    # Dependencias Gradio
+└── README.md          # Este archivo
+```
+
+## 🚀 Despliegue en Producción
+
+### Hugging Face Spaces (Recomendado)
+
+1. Crear un nuevo Space en https://huggingface.co/spaces
+2. Seleccionar "Gradio" como SDK
+3. Subir `app.py` y `requirements.txt`
+4. El Space se desplegará automáticamente
+
+### Docker
+
+```dockerfile
+FROM python:3.9-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 7860
+CMD ["python", "app.py"]
+```
+
+```bash
+docker build -t clasificador-papas .
+docker run -p 7860:7860 clasificador-papas
+```
+
+## 🎓 Mejoras Implementadas
+
+### Respecto a la versión Streamlit:
+
+1. **✅ Interfaz más limpia**: Diseño moderno con Gradio Blocks
+2. **✅ Mejor rendimiento**: Carga más rápida y menos overhead
+3. **✅ Visualizaciones mejoradas**: HTML/CSS personalizado
+4. **✅ Arquitectura modular**: Clases para gestor y procesador
+5. **✅ Validación robusta**: Manejo de errores completo
+6. **✅ Métricas expandidas**: Más información técnica
+7. **✅ Documentación inline**: Docstrings y comentarios
+8. **✅ Configuración flexible**: Dataclasses para config
+
+## 📝 Licencia
+
+Este proyecto es parte de un trabajo de investigación académica.
+
+## 👨‍💻 Autor
+
+Desarrollado para clasificación de tubérculos de papa usando técnicas de Deep Learning.
+
+## 🙏 Agradecimientos
+
+- **timm** (PyTorch Image Models): Implementación de ViT
+- **Gradio**: Framework de interfaz
+- **Hugging Face Hub**: Almacenamiento del modelo
+- **pytorch-grad-cam**: Visualización explicable
+
+## 📧 Contacto
+
+Para preguntas, sugerencias o reportar problemas, abre un issue en el repositorio.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**⚠️ Nota Importante**: Este sistema es una herramienta de apoyo para la clasificación de papas. Para decisiones críticas de calidad en contextos comerciales, se recomienda consultar con especialistas en agronomía e inspección de calidad.

app.py

@@ -0,0 +1,533 @@
+import os
+import time
+import warnings
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+import gradio as gr
+import numpy as np
+import timm
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from huggingface_hub import hf_hub_download
+from PIL import Image
+from pytorch_grad_cam import EigenCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+
+# Configuración
+warnings.filterwarnings("ignore", message=".*HF Hub.*")
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+# Constantes globales
+CLASES = {0: "Buen estado", 1: "Defectuoso"}
+COLORES_CLASES = {0: "#28a745", 1: "#dc3545"}
+EXTENSIONES_VALIDAS = [".png", ".jpg", ".jpeg"]
+TAMANIO_MAXIMO_MB = 20
+RESOLUCION = (224, 224)
+DISPOSITIVO = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Transformaciones de imagen
+TRANSFORMACION = transforms.Compose(
+    [
+        transforms.Resize(RESOLUCION),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ]
+)
+
+
+@dataclass
+class ConfigModelo:
+    repo_id: str = "Carlos012/vit_papas"
+    nombre_archivo: str = "vit_papas_ft.pt"
+    num_clases: int = 2
+    modelo_base: str = "vit_base_patch16_224"
+
+
+class ClasificadorPapasViT(nn.Module):
+    def __init__(self, num_clases: int = 2, modelo_base: str = "vit_base_patch16_224"):
+        super().__init__()
+        self.backbone = timm.create_model(
+            modelo_base, pretrained=False, num_classes=num_clases
+        )
+        # Inicialización Xavier para mejor convergencia
+        nn.init.xavier_uniform_(self.backbone.head.weight)
+        nn.init.zeros_(self.backbone.head.bias)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.backbone(x)
+
+
+class GestorModelo:
+    def __init__(self, config: ConfigModelo):
+        self.config = config
+        self.modelo: Optional[ClasificadorPapasViT] = None
+        self.cam: Optional[EigenCAM] = None
+
+    def descargar_pesos(self) -> Optional[str]:
+        try:
+            # Intentar usar token de variable de entorno
+            token = os.getenv("HF_TOKEN")
+
+            ruta_modelo = hf_hub_download(
+                repo_id=self.config.repo_id,
+                filename=self.config.nombre_archivo,
+                token=token,
+                repo_type="model",
+            )
+            return ruta_modelo
+        except Exception as e:
+            print(f"Error al descargar modelo: {e}")
+            return None
+
+    def cargar_modelo(self) -> bool:
+        if self.modelo is not None:
+            return True
+
+        ruta_pesos = self.descargar_pesos()
+        if ruta_pesos is None:
+            return False
+
+        try:
+            # Inicializar modelo
+            self.modelo = ClasificadorPapasViT(
+                num_clases=self.config.num_clases, modelo_base=self.config.modelo_base
+            )
+
+            # Cargar pesos
+            checkpoint = torch.load(
+                ruta_pesos, map_location=DISPOSITIVO, weights_only=False
+            )
+
+            state_dict = checkpoint.get("modelo_state_dict", checkpoint)
+
+            # Limpiar prefijos si existen
+            if any(k.startswith("_orig_mod.") for k in state_dict.keys()):
+                state_dict = {
+                    k.replace("_orig_mod.", ""): v for k, v in state_dict.items()
+                }
+
+            self.modelo.load_state_dict(state_dict, strict=False)
+            self.modelo.to(DISPOSITIVO)
+            self.modelo.eval()
+
+            # Configurar Grad-CAM
+            capas_objetivo = [self.modelo.backbone.blocks[-1].norm1]
+            self.cam = EigenCAM(
+                model=self.modelo.backbone,
+                target_layers=capas_objetivo,
+                reshape_transform=self._reshape_transform,
+            )
+
+            print(f"Modelo cargado exitosamente en {DISPOSITIVO}")
+            return True
+
+        except Exception as e:
+            print(f"Error al cargar modelo: {e}")
+            return False
+
+    @staticmethod
+    def _reshape_transform(tensor: torch.Tensor) -> torch.Tensor:
+        # Eliminar token CLS
+        resultado = tensor[:, 1:, :]
+
+        # Calcular tamaño de malla
+        tamanio_malla = int(np.sqrt(resultado.size(1)))
+
+        # Reorganizar: [Batch, Grid, Grid, Canales]
+        resultado = resultado.reshape(
+            tensor.size(0), tamanio_malla, tamanio_malla, tensor.size(2)
+        )
+
+        # Transponer para formato imagen: [Batch, Canales, Altura, Anchura]
+        resultado = resultado.transpose(2, 3).transpose(1, 2)
+        return resultado
+
+
+class ProcesadorImagen:
+    def __init__(self, gestor: GestorModelo):
+        self.gestor = gestor
+
+    def validar_imagen(self, imagen_path: str) -> Tuple[bool, str]:
+        if imagen_path is None:
+            return False, "No se ha subido ninguna imagen"
+
+        # Validar extensión
+        extension = Path(imagen_path).suffix.lower()
+        if extension not in EXTENSIONES_VALIDAS:
+            return False, f"Formato no válido. Use: {', '.join(EXTENSIONES_VALIDAS)}"
+
+        # Validar tamaño
+        tamanio_mb = Path(imagen_path).stat().st_size / (1024 * 1024)
+        if tamanio_mb > TAMANIO_MAXIMO_MB:
+            return (
+                False,
+                f"Imagen muy grande ({tamanio_mb:.2f}MB). Máximo: {TAMANIO_MAXIMO_MB}MB",
+            )
+
+        return True, "OK"
+
+    def procesar(self, imagen_path: str) -> Dict:
+        tiempo_inicio = time.time()
+
+        # Validar imagen
+        valido, mensaje = self.validar_imagen(imagen_path)
+        if not valido:
+            return {"error": mensaje}
+
+        # Cargar modelo si es necesario
+        if self.gestor.modelo is None:
+            if not self.gestor.cargar_modelo():
+                return {"error": "No se pudo cargar el modelo"}
+
+        try:
+            # Cargar y preparar imagen
+            imagen = Image.open(imagen_path).convert("RGB")
+            imagen_redimensionada = imagen.resize(RESOLUCION)
+            tensor_imagen = TRANSFORMACION(imagen).unsqueeze(0).to(DISPOSITIVO)
+
+            # Predicción
+            with torch.no_grad():
+                salida = self.gestor.modelo(tensor_imagen)
+                probabilidades = torch.softmax(salida, dim=1)[0].cpu().numpy()
+
+            id_prediccion = int(np.argmax(probabilidades))
+            confianza = float(probabilidades[id_prediccion])
+
+            # Generar Grad-CAM
+            mapa_atencion = self.gestor.cam(input_tensor=tensor_imagen, targets=None)[
+                0, :
+            ]
+
+            # Crear visualización
+            imagen_normalizada = np.float32(imagen_redimensionada) / 255.0
+            visualizacion_cam = show_cam_on_image(
+                imagen_normalizada, mapa_atencion, use_rgb=True
+            )
+
+            tiempo_total = time.time() - tiempo_inicio
+
+            return {
+                "clase_id": id_prediccion,
+                "clase_nombre": CLASES[id_prediccion],
+                "confianza": confianza,
+                "probabilidades": probabilidades,
+                "imagen_original": imagen_redimensionada,
+                "mapa_atencion": mapa_atencion,
+                "visualizacion_cam": visualizacion_cam,
+                "tiempo_procesamiento": tiempo_total,
+            }
+
+        except Exception as e:
+            return {"error": f"Error al procesar imagen: {str(e)}"}
+
+
+# Instancia global del gestor
+config = ConfigModelo()
+gestor_modelo = GestorModelo(config)
+procesador = ProcesadorImagen(gestor_modelo)
+
+
+def predecir(imagen) -> Tuple:
+    if imagen is None:
+        return (
+            "⚠️ Por favor, sube una imagen",
+            None,
+            crear_html_error("No hay imagen para procesar"),
+            "",
+        )
+
+    # Procesar imagen
+    resultado = procesador.procesar(imagen)
+
+    # Manejar errores
+    if "error" in resultado:
+        return (
+            f"❌ Error: {resultado['error']}",
+            None,
+            crear_html_error(resultado["error"]),
+            "",
+        )
+
+    # Preparar resultados
+    clase_id = resultado["clase_id"]
+    clase_nombre = resultado["clase_nombre"]
+    confianza = resultado["confianza"]
+    probabilidades = resultado["probabilidades"]
+    vis_cam = resultado["visualizacion_cam"]
+    tiempo = resultado["tiempo_procesamiento"]
+
+    # Texto de predicción
+    emoji = "✅" if clase_id == 0 else "⚠️"
+    prediccion_texto = f"{emoji} **{clase_nombre}** (Confianza: {confianza*100:.2f}%)"
+
+    # HTML de confianzas por clase
+    html_confianzas = crear_html_confianzas(probabilidades)
+
+    # HTML de métricas
+    html_metricas = crear_html_metricas(tiempo, DISPOSITIVO)
+
+    return (prediccion_texto, vis_cam, html_confianzas, html_metricas)
+
+
+def crear_html_confianzas(probabilidades: np.ndarray) -> str:
+    """Crea HTML para mostrar confianzas por clase"""
+    prob_buen_estado = probabilidades[0] * 100
+    prob_defectuoso = probabilidades[1] * 100
+
+    html = f"""
+    <div style="display: flex; gap: 20px; margin-top: 20px;">
+        <div style="flex: 1; background: linear-gradient(135deg, #d4edda 0%, #c3e6cb 100%); 
+                    padding: 24px; border-radius: 12px; border-left: 5px solid #28a745; 
+                    box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
+            <div style="color: #155724; font-size: 14px; font-weight: 600; 
+                        text-transform: uppercase; letter-spacing: 1px; margin-bottom: 8px;">
+                Buen Estado
+            </div>
+            <div style="color: #28a745; font-size: 42px; font-weight: bold; 
+                        font-family: 'Segoe UI', sans-serif;">
+                {prob_buen_estado:.1f}%
+            </div>
+            <div style="background-color: rgba(40, 167, 69, 0.2); height: 8px; 
+                        border-radius: 4px; margin-top: 12px; overflow: hidden;">
+                <div style="background-color: #28a745; height: 100%; 
+                            width: {prob_buen_estado}%; transition: width 0.3s ease;"></div>
+            </div>
+        </div>
+        
+        <div style="flex: 1; background: linear-gradient(135deg, #f8d7da 0%, #f5c6cb 100%); 
+                    padding: 24px; border-radius: 12px; border-left: 5px solid #dc3545; 
+                    box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
+            <div style="color: #721c24; font-size: 14px; font-weight: 600; 
+                        text-transform: uppercase; letter-spacing: 1px; margin-bottom: 8px;">
+                Defectuoso
+            </div>
+            <div style="color: #dc3545; font-size: 42px; font-weight: bold; 
+                        font-family: 'Segoe UI', sans-serif;">
+                {prob_defectuoso:.1f}%
+            </div>
+            <div style="background-color: rgba(220, 53, 69, 0.2); height: 8px; 
+                        border-radius: 4px; margin-top: 12px; overflow: hidden;">
+                <div style="background-color: #dc3545; height: 100%; 
+                            width: {prob_defectuoso}%; transition: width 0.3s ease;"></div>
+            </div>
+        </div>
+    </div>
+    """
+    return html
+
+
+def crear_html_metricas(tiempo: float, dispositivo: str) -> str:
+    icono_dispositivo = "🖥️" if dispositivo == "cpu" else "⚡"
+
+    html = f"""
+    <div style="display: flex; gap: 15px; margin-top: 15px; flex-wrap: wrap;">
+        <div style="background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%); 
+                    padding: 15px 20px; border-radius: 10px; flex: 1; min-width: 150px;
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+            <div style="color: #1565c0; font-size: 12px; font-weight: 600; 
+                        margin-bottom: 5px;">⏱️ TIEMPO</div>
+            <div style="color: #0d47a1; font-size: 24px; font-weight: bold;">
+                {tiempo:.3f}s
+            </div>
+        </div>
+        
+        <div style="background: linear-gradient(135deg, #f3e5f5 0%, #e1bee7 100%); 
+                    padding: 15px 20px; border-radius: 10px; flex: 1; min-width: 150px;
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+            <div style="color: #6a1b9a; font-size: 12px; font-weight: 600; 
+                        margin-bottom: 5px;">{icono_dispositivo} DISPOSITIVO</div>
+            <div style="color: #4a148c; font-size: 24px; font-weight: bold; 
+                        text-transform: uppercase;">
+                {dispositivo}
+            </div>
+        </div>
+        
+        <div style="background: linear-gradient(135deg, #fff3e0 0%, #ffe0b2 100%); 
+                    padding: 15px 20px; border-radius: 10px; flex: 1; min-width: 150px;
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+            <div style="color: #e65100; font-size: 12px; font-weight: 600; 
+                        margin-bottom: 5px;">🧠 MODELO</div>
+            <div style="color: #bf360c; font-size: 20px; font-weight: bold;">
+                ViT-Base/16
+            </div>
+        </div>
+    </div>
+    """
+    return html
+
+
+def crear_html_error(mensaje: str) -> str:
+    """Crea HTML para mostrar errores"""
+    html = f"""
+    <div style="background-color: #fff3cd; border: 2px solid #ffc107; 
+                border-radius: 10px; padding: 20px; margin-top: 20px;">
+        <div style="color: #856404; font-size: 16px; font-weight: 600; margin-bottom: 10px;">
+            ⚠️ Advertencia
+        </div>
+        <div style="color: #856404; font-size: 14px;">
+            {mensaje}
+        </div>
+    </div>
+    """
+    return html
+
+
+def crear_interfaz() -> gr.Blocks:
+    # CSS personalizado
+    css_personalizado = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif !important;
+    }
+    .resultado-principal {
+        font-size: 24px !important;
+        font-weight: bold !important;
+        padding: 20px !important;
+        border-radius: 10px !important;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+        color: white !important;
+        text-align: center !important;
+    }
+    footer {
+        display: none !important;
+    }
+    """
+
+    with gr.Blocks(
+        title="Clasificador de Papas (Chaucha y Chola) - ViT",
+        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"),
+        css=css_personalizado,
+    ) as demo:
+
+        # Encabezado
+        gr.Markdown(
+            """
+        # 🥔 Clasificador de Calidad de Papas
+        ### Powered by Vision Transformer (ViT-Base/16)
+        
+        Sube una imagen de papa (Chaucha o Chola) para clasificar su calidad en tiempo real.
+        El sistema utiliza un modelo de inteligencia artificial entrenado específicamente 
+        para detectar defectos en tubérculos de papa.
+        """
+        )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 Imagen de Entrada")
+                imagen_entrada = gr.Image(
+                    label="Subir imagen de papa", type="filepath", height=400
+                )
+
+                gr.Markdown(
+                    f"""
+                **Especificaciones:**
+                - Formatos: PNG, JPG, JPEG
+                - Tamaño máximo: {TAMANIO_MAXIMO_MB} MB
+                - Resolución: Se redimensiona a {RESOLUCION[0]}×{RESOLUCION[1]}
+                """
+                )
+
+                boton_predecir = gr.Button(
+                    "🔍 Analizar Calidad", variant="primary", size="lg"
+                )
+                boton_limpiar = gr.ClearButton(
+                    components=[imagen_entrada], value="🗑️ Limpiar", size="sm"
+                )
+
+            with gr.Column(scale=1):
+                gr.Markdown("### 📊 Resultados del Análisis")
+
+                resultado_texto = gr.Markdown(
+                    value="Esperando imagen...", elem_classes=["resultado-principal"]
+                )
+
+                html_confianzas = gr.HTML(label="Probabilidades por Clase")
+
+                gr.Markdown("### 🔥 Mapa de Atención (Grad-CAM)")
+                imagen_gradcam = gr.Image(
+                    label="Visualización de áreas de interés del modelo", height=400
+                )
+
+                html_metricas = gr.HTML(label="Métricas de Rendimiento")
+
+        # Info adicional
+        with gr.Accordion("ℹ️ Información del Sistema", open=False):
+            gr.Markdown(
+                f"""
+            ### Detalles Técnicos
+            
+            - **Modelo**: Vision Transformer Base (ViT-Base/16)
+            - **Framework**: PyTorch + timm
+            - **Dispositivo**: {DISPOSITIVO.upper()}
+            - **Visualización**: EigenCAM (Grad-CAM para Transformers)
+            - **Clases**: Buen estado / Defectuoso
+            
+            ### Interpretación del Mapa de Atención
+            
+            El mapa de atención (Grad-CAM) muestra en **rojo** las regiones de la imagen 
+            que más influyeron en la decisión del modelo. Esto ayuda a entender qué partes 
+            del tubérculo está evaluando la red neuronal.
+            
+            ### Sobre el Modelo
+            
+            El clasificador ha sido entrenado con un dataset especializado de papas 
+            Chaucha y Chola, capturando diversos tipos de defectos y condiciones de iluminación.
+            """
+            )
+
+        # Conectar eventos
+        boton_predecir.click(
+            fn=predecir,
+            inputs=[imagen_entrada],
+            outputs=[resultado_texto, imagen_gradcam, html_confianzas, html_metricas],
+        )
+
+        # También predecir al subir imagen
+        imagen_entrada.change(
+            fn=predecir,
+            inputs=[imagen_entrada],
+            outputs=[resultado_texto, imagen_gradcam, html_confianzas, html_metricas],
+        )
+
+        # Footer
+        gr.Markdown(
+            """
+        ---
+        **Nota**: Este sistema es una herramienta de apoyo. Para decisiones críticas 
+        de calidad, consulte con un especialista en agronomía.
+        """
+        )
+
+    return demo
+
+
+def main():
+    print("=" * 60)
+    print("🥔 Clasificador de Papas con Transformadores de Visión (ViT)")
+    print("=" * 60)
+    print(f"Dispositivo: {DISPOSITIVO.upper()}")
+    print(f"Resolución: {RESOLUCION}")
+    print("=" * 60)
+
+    # Pre-cargar modelo
+    print("\n📦 Cargando modelo...")
+    if gestor_modelo.cargar_modelo():
+        print("✅ Modelo cargado exitosamente\n")
+    else:
+        print("⚠️ El modelo se cargará cuando sea necesario\n")
+
+    # Crear y lanzar interfaz
+    demo = crear_interfaz()
+
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        quiet=False,
+    )
+
+
+if __name__ == "__main__":
+    main()

configuracion.py

@@ -0,0 +1,173 @@
+# ===========================
+# CONFIGURACIÓN DEL MODELO
+# ===========================
+
+HF_REPO_ID = "Carlos012/vit_papas"
+HF_ARCHIVO_MODELO = "vit_papas_ft.pt"
+
+# Arquitectura del modelo
+ARQUITECTURA_MODELO = "vit_base_patch16_224"
+NUM_CLASES = 2
+
+# Etiquetas de las clases
+ETIQUETAS_CLASE = {0: "Buen estado", 1: "Defectuoso"}
+
+# Colores para visualización (formato hexadecimal)
+COLORES_CLASES = {
+    0: "#28a745",  # Verde para buen estado
+    1: "#dc3545",  # Rojo para defectuoso
+}
+
+# ===========================
+# CONFIGURACIÓN DE IMAGEN
+# ===========================
+
+# Resolución de entrada del modelo
+RESOLUCION_IMAGEN = (224, 224)
+
+# Tamaño máximo de archivo (en MB)
+TAMANIO_MAXIMO_MB = 20
+
+# Extensiones permitidas
+EXTENSIONES_PERMITIDAS = [".png", ".jpg", ".jpeg"]
+
+# Normalización (estadísticas de ImageNet)
+MEDIA = [0.485, 0.456, 0.406]
+DESVIACION_ESTANDAR = [0.229, 0.224, 0.225]
+
+# ===========================
+# CONFIGURACIÓN DE GRADIO
+# ===========================
+
+# Configuración del servidor
+CONFIGURACION_SERVIDOR = {
+    "server_name": "0.0.0.0",  # "0.0.0.0" para acceso en red, "127.0.0.1" solo local
+    "server_port": 7860,  # Puerto del servidor
+    "share": False,  # True para generar link público temporal
+    "debug": False,  # True para modo debug
+    "show_error": True,  # Mostrar errores detallados
+    "quiet": False,  # True para menos logs
+}
+
+# Autenticación (opcional)
+# Descomenta y configura para habilitar
+# AUTH_CREDENTIALS = [
+#     ("usuario1", "contraseña1"),
+#     ("usuario2", "contraseña2")
+# ]
+CREDENCIALES_AUTENTICACION = None
+
+# ===========================
+# CONFIGURACIÓN DE RENDIMIENTO
+# ===========================
+
+# Dispositivo preferido ("cuda", "cpu", o "auto")
+DISPOSITIVO_PREFERIDO = "auto"
+
+# Usar modelo compilado (PyTorch 2.0+)
+MODELO_COMPILADO = False
+
+# Pre-cargar modelo al inicio
+PRECARGAR_MODELO = True
+
+# Número de threads para CPU
+# None = detección automática
+HILOS_CPU = None
+
+# ===========================
+# CONFIGURACIÓN DE GRAD-CAM
+# ===========================
+
+# Capa objetivo para Grad-CAM (None = última capa)
+ETIQUETA_GRADCAM = None  # Se usa automáticamente la última
+
+# Transparencia de la superposición (0.0 a 1.0)
+GRADCAM_ALPHA = 0.5
+
+# Mapa de colores para Grad-CAM
+# Opciones: COLORMAP_JET, COLORMAP_HOT, COLORMAP_VIRIDIS, etc.
+COLORMAP_GRADCAM = "COLORMAP_JET"
+
+# ===========================
+# CONFIGURACIÓN DE UI
+# ===========================
+
+# Título de la aplicación
+TITULO_APP = "🥔 Clasificador de Calidad de Papas"
+
+# Descripción
+DESCRIPCION_APP = """
+### Powered by Vision Transformer (ViT-Base/16)
+
+Sube una imagen de papa (Chaucha o Chola) para clasificar su calidad en tiempo real.
+El sistema utiliza un modelo de inteligencia artificial entrenado específicamente 
+para detectar defectos en tubérculos de papa.
+"""
+
+# Tema de Gradio
+# Opciones: "default", "soft", "monochrome", "glass"
+TEMA_GRADIO = "soft"
+
+# Color principal del tema (hue)
+# Opciones: "red", "orange", "amber", "yellow", "lime", "green",
+#           "emerald", "teal", "cyan", "sky", "blue", "indigo",
+#           "violet", "purple", "fuchsia", "pink", "rose"
+PRIMARIO_HUE = "blue"
+SECUNDARIO_HUE = "green"
+
+# Altura de las imágenes en la interfaz
+ALTURA_IMAGEN = 400
+
+# ===========================
+# CONFIGURACIÓN DE LOGGING
+# ===========================
+
+# Nivel de logging
+# Opciones: "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
+NIVEL_REGISTRO = "INFO"
+
+# Guardar logs en archivo
+GUARDAR_REGISTROS = False
+ARCHIVO_REGISTRO = "app_gradio.log"
+
+# ===========================
+# CONFIGURACIÓN AVANZADA
+# ===========================
+
+# Caché de resultados
+ACTIVAR_CACHE = True
+
+# Timeout para carga del modelo (segundos)
+TIEMPO_CARGA_MODELO = 300
+
+# Mostrar información técnica expandida
+INFO_EXTENDIDA = True
+
+# Habilitar ejemplos pre-cargados
+# Proporciona una lista de rutas a imágenes de ejemplo
+IMAGENES_EJEMPLO = []
+# EXAMPLE_IMAGES = [
+#     "ejemplos/papa_buena_1.jpg",
+#     "ejemplos/papa_defectuosa_1.jpg",
+# ]
+
+# ===========================
+# MENSAJES PERSONALIZADOS
+# ===========================
+
+MENSAJES = {
+    "esperando": "⏳ Esperando imagen...",
+    "procesando": "🔄 Procesando imagen...",
+    "error_en_imagen": "⚠️ Por favor, sube una imagen",
+    "error_cargar_modelo": "❌ Error al cargar el modelo",
+    "buen_estado": "✅ Tubérculo en buen estado",
+    "defectuoso": "⚠️ Tubérculo defectuoso",
+}
+
+# ===========================
+# METADATOS
+# ===========================
+
+VERSION = "1.0.0"
+AUTOR = "CEAS - Clasificador de Papas"
+LISCNCIA = "MIT"

requirements.txt

@@ -0,0 +1,22 @@
+# Framework de interfaz
+gradio>=4.19.0
+
+# Deep Learning
+torch>=2.0.0
+torchvision>=0.15.0
+timm>=0.9.12
+
+# Procesamiento de imágenes
+opencv-python>=4.8.0
+Pillow>=10.0.0
+numpy>=1.24.0
+
+# Grad-CAM para visualización
+pytorch-grad-cam>=1.4.8
+
+# Hugging Face Hub
+huggingface-hub>=0.20.0
+
+# Utilidades
+typing-extensions>=4.8.0
+dataclasses>=0.6