gradio pure

Dockerfile

@@ -1,8 +0,0 @@
-# Contenido de: Dockerfile
-FROM huggingface/transformers-pytorch-gpu
-WORKDIR /code
-COPY ./requirements.txt /code/requirements.txt
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-COPY . /code
-EXPOSE 7860
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,7 +1,6 @@
 ---
-title: Orchid Classifier API
-emoji: 🤖
-sdk: docker
-app_file: app.py
-app_port: 7860
+title: Clasificador de Orquídeas
+emoji: 🌸
+sdk: gradio
+sdk_version: 4.31.0
 ---

app.py

@@ -1,59 +1,117 @@
-# app.py (Versión final - Solo API FastAPI)
+# app.py (Versión final y robusta para el SDK de Gradio)
 
 import torch
+import torch.nn as nn
 import torchvision.transforms as transforms
 from PIL import Image
 import json
 import timm
-from fastapi import FastAPI, UploadFile, File
-from fastapi.responses import JSONResponse
-import io
+import gradio as gr
 
-# --- 1. Importar la definición del modelo ---
-from VisionEnsembleModel import VisionEnsembleModel
+# --- 1. Definición del Modelo (directamente aquí para máxima compatibilidad) ---
+class VisionEnsembleModel(nn.Module):
+    def __init__(self, num_classes, cnn_model_name='efficientnet_b2', vit_model_name='vit_small_patch16_224'):
+        super().__init__()
+        # Se crean con pretrained=False porque cargaremos nuestros propios pesos entrenados.
+        self.cnn = timm.create_model(cnn_model_name, pretrained=False, num_classes=num_classes)
+        cnn_features = self.cnn.get_classifier().in_features
+        self.cnn.reset_classifier(0) # Elimina el clasificador, deja el extractor de características
+
+        self.vit = timm.create_model(vit_model_name, pretrained=False, num_classes=num_classes)
+        vit_features = self.vit.head.in_features
+        self.vit.head = nn.Identity() # Elimina el clasificador, deja el extractor
+
+        # Clasificador final que combina las características de ambos modelos
+        self.classifier = nn.Sequential(
+            nn.BatchNorm1d(cnn_features + vit_features),
+            nn.Linear(cnn_features + vit_features, 512),
+            nn.ReLU(),
+            nn.Dropout(0.5),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, image):
+        cnn_feat = self.cnn(image)
+        vit_feat = self.vit(image)
+        combined = torch.cat([cnn_feat, vit_feat], dim=1)
+        output = self.classifier(combined)
+        return output
 
 # --- 2. Carga del Modelo y Componentes ---
-device = torch.device("cpu")
+device = torch.device("cpu") # Usamos CPU para máxima compatibilidad en el plan gratuito
 MODEL_PATH = "model/best_vision_ensemble_model.pth"
+LABELS_PATH = "model/species_labels_map.json"
 NUM_CLASSES = 156
 
-# El mapa de etiquetas ya no es necesario en el servidor
-# ya que la app móvil se encargará de la traducción.
+try:
+    with open(LABELS_PATH) as f:
+        labels_map = json.load(f)
+    print("Mapa de etiquetas cargado con éxito.")
+except Exception as e:
+    print(f"ERROR AL CARGAR EL MAPA DE ETIQUETAS: {e}")
+    labels_map = {} # Si falla, usamos un mapa vacío para que la app no crashee
 
+# Instanciamos y cargamos el modelo ensamblado
 model = VisionEnsembleModel(num_classes=NUM_CLASSES)
 model.load_state_dict(torch.load(MODEL_PATH, map_location=device))
 model.to(device)
-model.eval()
-print("Modelo Ensamblado Híbrido cargado y listo para servir la API.")
+model.eval() # ¡Crucial poner el modelo en modo de evaluación!
 
+print("Modelo Ensamblado Híbrido (CNN+ViT) cargado y listo.")
+
+# Definir las transformaciones de la imagen (deben ser idénticas a las de validación)
 transforms_val = transforms.Compose([
     transforms.Resize((224, 224)),
     transforms.ToTensor(),
     transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
 ])
 
-# --- 3. Crear la App FastAPI ---
-app = FastAPI(title="API de Clasificación de Orquídeas")
-
-@app.get("/")
-def read_root():
-    return {"status": "ok", "message": "API de Orquídeas funcionando. Usa el endpoint POST en /predict_for_mobile"}
-
-# --- 4. Endpoint de API para la App Móvil (devuelve IDs) ---
-@app.post("/predict_for_mobile")
-async def predict_for_mobile(file: UploadFile = File(...)):
-    image_bytes = await file.read()
-    try:
-        pil_image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-    except Exception:
-        return JSONResponse(status_code=400, content={"error": "Archivo de imagen inválido."})
-
+# --- 3. Función de Predicción para Gradio (devuelve nombres) ---
+def predict(image):
+    """
+    Esta función toma una imagen de la interfaz de Gradio, la procesa
+    con el modelo y devuelve un diccionario de {nombre_especie: confianza}.
+    """
+    # Manejar el caso de que no se suba ninguna imagen
+    if image is None:
+        return None
+        
+    # La imagen de Gradio viene como un array de Numpy, la convertimos a PIL Image
+    pil_image = Image.fromarray(image.astype('uint8'), 'RGB')
+    
+    # Preprocesar la imagen
     input_tensor = transforms_val(pil_image).unsqueeze(0).to(device)
+    
+    # Realizar la predicción
     with torch.no_grad():
         output = model(input_tensor)
         probabilities = torch.nn.functional.softmax(output[0], dim=0)
     
-    top5_prob, top_catid = torch.topk(probabilities, 5)
+    # Obtener las 5 predicciones más probables
+    top5_prob, top5_catid = torch.topk(probabilities, 5)
     
-    results = [{"species_id": cat_id.item(), "confidence": prob.item()} for prob, cat_id in zip(top5_prob, top_catid)]
-    return JSONResponse(content={"predictions": results})
+    # Crear el diccionario de confianzas con los nombres de las especies
+    confidences = {}
+    for i in range(top5_prob.size(0)):
+        species_id = top5_catid[i].item()
+        prob = top5_prob[i].item()
+        
+        # Traducir el ID a un nombre usando el mapa de etiquetas cargado
+        species_name = labels_map.get(str(species_id), f"ID Desconocido: {species_id}")
+        
+        confidences[species_name] = prob
+        
+    return confidences
+
+# --- 4. Crear y Lanzar la Interfaz de Gradio ---
+iface = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="numpy", label="Sube una imagen de tu orquídea"),
+    outputs=gr.Label(num_top_classes=5, label="Predicciones"),
+    title="Clasificador de Orquídeas",
+    description="Sube una foto de una orquídea y la IA (un ensamblado de CNN y Vision Transformer) intentará identificar la especie.",
+    allow_flagging="never"
+)
+
+# Lanzamos la aplicación. Gradio se encargará de crear el servidor web.
+iface.launch()

requirements.txt

@@ -1,8 +1,6 @@
-# requirements.txt (versión final solo para API)
-fastapi
-uvicorn[standard]
-python-multipart
+# requirements.txt
 torch
 torchvision
 timm
-Pillow
+Pillow
+gradio==4.31.0