Initial model and API upload

VisionEnsembleModel.py

@@ -0,0 +1,37 @@
+# Contenido de: VisionEnsembleModel.py
+
+import torch
+import torch.nn as nn
+import timm
+
+class VisionEnsembleModel(nn.Module):
+    """
+    La misma clase de modelo que definiste en Colab.
+    """
+    def __init__(self, num_classes, cnn_model_name='efficientnet_b2', vit_model_name='vit_small_patch16_224'):
+        super().__init__()
+        # Usamos pretrained=False aquí porque cargaremos nuestros propios pesos.
+        # Timm cargará los pesos preentrenados si no encuentra un state_dict local,
+        # pero es más limpio ser explícito. Al final, los sobrescribiremos.
+        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)
+
+        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()
+
+        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

app.py

@@ -0,0 +1,89 @@
+# Contenido de: app.py
+
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+import json
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import JSONResponse
+import io
+
+# Importamos la definición de nuestro modelo desde el otro archivo
+from VisionEnsembleModel import VisionEnsembleModel
+
+# --- 1. Carga del Modelo y Componentes ---
+
+# Definimos el dispositivo (en los Spaces de Hugging Face, podemos usar CPU o GPU)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Usando dispositivo: {device}")
+
+# Rutas a los archivos
+MODEL_PATH = "model/best_vision_ensemble_model.pth"
+LABELS_PATH = "model/species_labels_map.json"
+NUM_CLASSES = 156 # El número de clases con el que fue entrenado
+
+# Cargamos el mapa de etiquetas
+with open(LABELS_PATH) as f:
+    labels_map = json.load(f)
+print("Mapa de etiquetas cargado.")
+
+# Instanciamos el modelo y cargamos los pesos
+model = VisionEnsembleModel(num_classes=NUM_CLASSES)
+model.load_state_dict(torch.load(MODEL_PATH, map_location=device))
+model.to(device)
+model.eval() # ¡Muy importante poner el modelo en modo de evaluación!
+print("Modelo cargado y en modo de evaluación.")
+
+# Definimos las transformaciones de la imagen (deben ser las mismas que en la 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])
+])
+
+# --- 2. Creación de la Aplicación FastAPI ---
+
+app = FastAPI(title="API de Clasificación de Orquídeas")
+
+@app.get("/")
+def read_root():
+    return {"message": "Bienvenido a la API de Orquídeas. Envía una imagen al endpoint /predict"}
+
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    """
+    Endpoint que recibe una imagen, la procesa y devuelve la predicción.
+    """
+    # Leer el contenido de la imagen en memoria
+    image_bytes = await file.read()
+    try:
+        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+    except Exception as e:
+        return JSONResponse(status_code=400, content={"error": f"Archivo inválido: {e}"})
+
+    # Preprocesar la imagen
+    input_tensor = transforms_val(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)
+    
+    # Obtener la predicción principal
+    top_prob, top_catid = torch.topk(probabilities, 1)
+    predicted_id = top_catid[0].item()
+    confidence = top_prob[0].item()
+    
+    # Traducir el ID a un nombre de especie
+    predicted_species = labels_map.get(str(predicted_id), "Especie Desconocida")
+
+    # Devolver el resultado en formato JSON
+    return JSONResponse(
+        status_code=200,
+        content={
+            "filename": file.filename,
+            "predicted_species": predicted_species,
+            "confidence": f"{confidence:.4f}",
+            "species_id": predicted_id
+        }
+    )

model/best_vision_ensemble_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b870a8ea5dc05042e236bacba373e75018bbd8b4efd63a56496143b5fe409d13
+size 122014183

model/species_labels_map.json

@@ -0,0 +1,158 @@
+{
+    "0": "1",
+    "1": "2",
+    "2": "3",
+    "3": "4",
+    "4": "5",
+    "5": "6",
+    "6": "7",
+    "7": "8",
+    "8": "9",
+    "9": "10",
+    "10": "11",
+    "11": "12",
+    "12": "13",
+    "13": "14",
+    "14": "15",
+    "15": "16",
+    "16": "17",
+    "17": "18",
+    "18": "19",
+    "19": "20",
+    "20": "21",
+    "21": "22",
+    "22": "23",
+    "23": "24",
+    "24": "25",
+    "25": "26",
+    "26": "27",
+    "27": "28",
+    "28": "29",
+    "29": "30",
+    "30": "31",
+    "31": "32",
+    "32": "33",
+    "33": "34",
+    "34": "35",
+    "35": "36",
+    "36": "37",
+    "37": "38",
+    "38": "39",
+    "39": "40",
+    "40": "41",
+    "41": "42",
+    "42": "43",
+    "43": "44",
+    "44": "45",
+    "45": "46",
+    "46": "47",
+    "47": "48",
+    "48": "49",
+    "49": "50",
+    "50": "51",
+    "51": "52",
+    "52": "53",
+    "53": "54",
+    "54": "55",
+    "55": "56",
+    "56": "57",
+    "57": "58",
+    "58": "59",
+    "59": "60",
+    "60": "61",
+    "61": "62",
+    "62": "63",
+    "63": "64",
+    "64": "65",
+    "65": "66",
+    "66": "67",
+    "67": "68",
+    "68": "69",
+    "69": "70",
+    "70": "71",
+    "71": "72",
+    "72": "73",
+    "73": "74",
+    "74": "75",
+    "75": "76",
+    "76": "77",
+    "77": "78",
+    "78": "79",
+    "79": "80",
+    "80": "81",
+    "81": "82",
+    "82": "83",
+    "83": "84",
+    "84": "85",
+    "85": "86",
+    "86": "87",
+    "87": "88",
+    "88": "89",
+    "89": "90",
+    "90": "91",
+    "91": "92",
+    "92": "93",
+    "93": "94",
+    "94": "95",
+    "95": "96",
+    "96": "97",
+    "97": "98",
+    "98": "99",
+    "99": "100",
+    "100": "101",
+    "101": "102",
+    "102": "103",
+    "103": "104",
+    "104": "105",
+    "105": "106",
+    "106": "107",
+    "107": "108",
+    "108": "109",
+    "109": "110",
+    "110": "111",
+    "111": "112",
+    "112": "113",
+    "113": "114",
+    "114": "115",
+    "115": "116",
+    "116": "117",
+    "117": "118",
+    "118": "119",
+    "119": "120",
+    "120": "121",
+    "121": "122",
+    "122": "123",
+    "123": "124",
+    "124": "125",
+    "125": "126",
+    "126": "127",
+    "127": "128",
+    "128": "129",
+    "129": "130",
+    "130": "131",
+    "131": "132",
+    "132": "133",
+    "133": "134",
+    "134": "135",
+    "135": "136",
+    "136": "137",
+    "137": "138",
+    "138": "139",
+    "139": "140",
+    "140": "141",
+    "141": "142",
+    "142": "143",
+    "143": "144",
+    "144": "145",
+    "145": "146",
+    "146": "147",
+    "147": "148",
+    "148": "149",
+    "149": "150",
+    "150": "151",
+    "151": "152",
+    "152": "153",
+    "153": "154",
+    "154": "155",
+    "155": "156"
+}

requirements.txt

@@ -0,0 +1,10 @@
+# Contenido de: requirements.txt
+
+fastapi
+uvicorn
+python-multipart
+torch
+torchvision
+timm
+Pillow
+scikit-learn