subo server32 completo al Space

Dockerfile

@@ -1,32 +1,33 @@
 FROM python:3.11-slim
-ENV PIP_NO_CACHE_DIR=1 PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
+
+# Configuración básica
+ENV PIP_NO_CACHE_DIR=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential git && rm -rf /var/lib/apt/lists/*
+    build-essential git && \
+    rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
 
-# === caches escribibles dentro de /app ===
-ENV HF_HOME=/app/.cache \
-    HF_HUB_CACHE=/app/.cache \
-    XDG_CACHE_HOME=/app/.cache \
-    OPENCLIP_CACHE_DIR=/app/.cache \
-    TORCH_HOME=/app/.cache/torch
-RUN mkdir -p /app/.cache /app/.cache/torch
-
+# Instalar dependencias
 COPY requirements.txt ./
 RUN pip install --upgrade pip && pip install -r requirements.txt
 
+# (Opcional) descargar un modelo más ligero para que Render free no muera
+RUN python - <<'PY'
+import open_clip
+open_clip.create_model_and_transforms('ViT-B-32', pretrained='openai')
+print("Pesos descargados")
+PY
+
+# Copiar código y pesos
 COPY server1.py .
 COPY text_embeddings_h14.pt .
 COPY text_embeddings_modelos_h14.pt .
 
-# (OPCIONAL) pre-descargar los pesos durante el build para evitar descarga en runtime
-RUN python - <<'PY'
-import open_clip
-open_clip.create_model_and_transforms('ViT-H-14', pretrained='laion2b_s32b_b79k', cache_dir="/app/.cache")
-print("Pesos cacheados en /app/.cache")
-PY
+# Render usa PORT
+ENV PORT=8080
 
-# En Spaces debes escuchar en 7860
-CMD ["python", "-m", "uvicorn", "server1:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]
+CMD ["uvicorn", "server1:app", "--host", "0.0.0.0", "--port", "8080"]

precalcular_modelos.py

@@ -0,0 +1,25 @@
+# precalcular_modelos_b16.py
+import torch
+import open_clip
+import pandas as pd
+
+# Solo marca + modelo
+df = pd.read_excel("modelos.xlsx")
+textos = (df["Marca"] + " " + df["Modelo"]).tolist()
+
+MODEL_NAME = "ViT-B-16"
+PRETRAINED = "openai"
+
+model, _, _ = open_clip.create_model_and_transforms(MODEL_NAME, pretrained=PRETRAINED)
+tokenizer = open_clip.get_tokenizer(MODEL_NAME)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model = model.to(device)
+
+with torch.no_grad():
+    text_inputs = tokenizer(textos).to(device)   # tensor en GPU o CPU
+    text_features = model.encode_text(text_inputs)
+    text_features /= text_features.norm(dim=-1, keepdim=True)
+
+torch.save({"embeddings": text_features.cpu(), "labels": textos}, "text_embeddings_modelos_b16.pt")
+print("Embeddings de modelos guardados en 'text_embeddings_modelos_b16.pt'")

precalcular_text_embeddings_h14_excel.py

@@ -0,0 +1,29 @@
+# precalcular_text_embeddings_b16_excel.py
+import torch
+import open_clip
+import pandas as pd
+
+# Leer el Excel
+df = pd.read_excel("versiones_coche.xlsx")
+
+# Crear los textos combinando marca, modelo y versión
+def combinar_filas(row):
+    if pd.isna(row["Version"]) or not row["Version"]:
+        return f'{row["Marca"]} {row["Modelo"]}'
+    return f'{row["Marca"]} {row["Modelo"]} {row["Version"]}'
+
+textos = df.apply(combinar_filas, axis=1).tolist()
+
+# Cargar modelo
+model, _, _ = open_clip.create_model_and_transforms('ViT-B-16', pretrained='laion2b_s34b_b88k')
+tokenizer = open_clip.get_tokenizer('ViT-B-16')
+
+# Calcular embeddings
+with torch.no_grad():
+    text_inputs = tokenizer(textos)
+    text_features = model.encode_text(text_inputs)
+    text_features /= text_features.norm(dim=-1, keepdim=True)
+
+# Guardar
+torch.save({'embeddings': text_features, 'labels': textos}, 'text_embeddings_b16.pt')
+print("Embeddings de texto guardados en 'text_embeddings_b16.pt'")

requirements.txt

@@ -1,12 +1,7 @@
-# PyTorch CPU wheels (sin CUDA)
-torch==2.3.0+cpu
-torchvision==0.18.0+cpu
---extra-index-url https://download.pytorch.org/whl/cpu
-
-# Resto
-fastapi==0.111.0
-uvicorn[standard]==0.30.1
+fastapi
+uvicorn[standard]
+torch
+torchvision
 pillow
 open_clip_torch
-timm
-huggingface-hub
+timm

server1.py

@@ -9,28 +9,28 @@ from typing import Optional
 
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Cargar modelo CLIP
+# === 1) Cargar modelo CLIP (B/16) ===
 clip_model, _, preprocess = open_clip.create_model_and_transforms(
-    'ViT-H-14', pretrained='laion2b_s32b_b79k'
+    "ViT-B-16", pretrained="openai"
 )
 clip_model = clip_model.to(DEVICE)
 clip_model.eval()
-for param in clip_model.parameters():
-    param.requires_grad = False
+for p in clip_model.parameters():
+    p.requires_grad = False
 
-# Cargar embeddings de modelos (marca + modelo)
-model_ckpt = torch.load("text_embeddings_modelos_h14.pt", map_location=DEVICE)
+# === 2) Cargar embeddings hechos con B/16 ===
+# (Asegúrate de que estos ficheros existen: los generaste como text_embeddings_modelos_b16.pt y text_embeddings_b16.pt)
+model_ckpt = torch.load("text_embeddings_modelos_b16.pt", map_location=DEVICE)
 model_labels = model_ckpt["labels"]
 model_embeddings = model_ckpt["embeddings"].to(DEVICE)
 model_embeddings /= model_embeddings.norm(dim=-1, keepdim=True)
 
-# Cargar embeddings de versiones (marca + modelo + versión)
-version_ckpt = torch.load("text_embeddings_h14.pt", map_location=DEVICE)
+version_ckpt = torch.load("text_embeddings_b16.pt", map_location=DEVICE)
 version_labels = version_ckpt["labels"]
 version_embeddings = version_ckpt["embeddings"].to(DEVICE)
 version_embeddings /= version_embeddings.norm(dim=-1, keepdim=True)
 
-# Transformación de imagen
+# Transformación de imagen (usa la normalize del preprocess de B/16)
 normalize = next(t for t in preprocess.transforms if isinstance(t, transforms.Normalize))
 transform = transforms.Compose([
     transforms.Resize((224, 224)),
@@ -47,10 +47,7 @@ def predict_top(text_feats, text_labels, image_tensor, topk=3):
         similarity = (100.0 * image_features @ text_feats.T).softmax(dim=-1)
         topk_result = torch.topk(similarity[0], k=topk)
     return [
-        {
-            "label": text_labels[idx],
-            "confidence": round(conf.item() * 100, 2)
-        }
+        {"label": text_labels[idx], "confidence": round(conf.item() * 100, 2)}
         for conf, idx in zip(topk_result.values, topk_result.indices)
     ]
 
@@ -63,10 +60,12 @@ def process_image(image_bytes: bytes):
     modelo_predecido = top_model["label"]
     confianza_modelo = top_model["confidence"]
 
-    # Separar marca y modelo
-    marca, modelo = modelo_predecido.split(" ", 1)
+    # Separar marca y modelo con cuidado (por si solo hay una palabra)
+    partes = modelo_predecido.split(" ", 1)
+    marca = partes[0]
+    modelo = partes[1] if len(partes) > 1 else ""
 
-    # Paso 2: buscar versiones que empiecen con ese modelo completo
+    # Paso 2: filtrar versiones que empiecen con el label completo de modelo
     versiones_filtradas = [
         (label, idx) for idx, label in enumerate(version_labels)
         if label.startswith(modelo_predecido)
@@ -80,15 +79,14 @@ def process_image(image_bytes: bytes):
             "version": "No se encontraron versiones para este modelo"
         }
 
-    # Extraer embeddings correspondientes
+    # Paso 3: predecir versión dentro de las versiones del modelo
     indices_versiones = [idx for _, idx in versiones_filtradas]
     versiones_labels = [label for label, _ in versiones_filtradas]
     versiones_embeds = version_embeddings[indices_versiones]
 
-    # Paso 3: predecir versión dentro de las versiones del modelo
     top_version = predict_top(versiones_embeds, versiones_labels, img_tensor, topk=1)[0]
     version_predicha = (
-        top_version["label"].replace(modelo_predecido + " ", "") 
+        top_version["label"].replace(modelo_predecido + " ", "")
         if top_version["confidence"] >= 25
         else "Versión no identificada con suficiente confianza"
     )
@@ -101,13 +99,10 @@ def process_image(image_bytes: bytes):
         "confianza_version": top_version["confidence"]
     }
 
-
 @app.post("/predict/")
 async def predict(front: UploadFile = File(...), back: Optional[UploadFile] = File(None)):
     front_bytes = await front.read()
     if back:
-        _ = await back.read()
+        _ = await back.read()  # de momento no se usa
     result = process_image(front_bytes)
     return JSONResponse(content=result)
-
-

text_embeddings_b16.pt

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

text_embeddings_modelos_b16.pt

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