Upload 4 files

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+.venv/
+*.pyc
+.DS_Store

README.md

@@ -0,0 +1,71 @@
+---
+title: Hyper Reality SAM2 GPU
+emoji: 🏠
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.13.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Hyper Reality — SAM2 Segmentation GPU
+
+
+# Demo de Gradio con SAM
+
+Este proyecto es una app de Gradio que usa SAM para segmentar automáticamente una imagen subida.
+
+## Qué hace
+
+- Permite subir una imagen
+- Ejecuta la segmentación automática con SAM
+- Permite buscar uno o varios objetos por palabra clave (separados por comas) y solo segmentar las máscaras encontradas
+- Muestra la imagen con las máscaras superpuestas
+
+## Ejecutar localmente
+
+1. Crear un entorno virtual:
+
+```powershell
+python -m venv .venv
+```
+
+2. Activar el entorno:
+
+```powershell
+.venv\Scripts\activate
+```
+
+3. Instalar dependencias:
+
+```powershell
+pip install -r requirements.txt
+```
+
+Si ya habías instalado antes y recibiste el error de `torchvision`, ejecuta:
+
+```powershell
+pip install torchvision
+```
+
+4. Ejecutar la app:
+
+```powershell
+python app.py
+```
+
+5. Abrir el enlace local que muestra Gradio, por ejemplo `http://127.0.0.1:7860`.
+
+## Notas
+
+- La primera vez que corras la app, descargará el checkpoint del modelo SAM desde Hugging Face.
+- Si quieres usar otro modelo de SAM, cambia `MODEL_REPO` y `CHECKPOINT_FILENAME` en `app.py`.
+
+## Subir a Hugging Face Spaces
+
+1. Crea una nueva Space en Hugging Face.
+2. Selecciona el tipo `Gradio`.
+3. Sube este repositorio completo o copia `app.py` y `requirements.txt`.
+4. La Space descargará el checkpoint y ejecutará la app.

app.py

@@ -0,0 +1,191 @@
+import os
+import re
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import torch
+from huggingface_hub import hf_hub_download
+from PIL import Image
+from segment_anything import SamAutomaticMaskGenerator, sam_model_registry
+from transformers import CLIPModel, CLIPProcessor
+
+MODEL_REPO = "segments-arnaud/sam_vit_h"
+CHECKPOINT_FILENAME = "sam_vit_h_4b8939.pth"
+CLIP_MODEL_NAME = "openai/clip-vit-base-patch32"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def download_checkpoint() -> str:
+    cache_dir = Path("./models")
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    local_path = cache_dir / CHECKPOINT_FILENAME
+    if not local_path.exists():
+        local_path = Path(
+            hf_hub_download(
+                repo_id=MODEL_REPO,
+                filename=CHECKPOINT_FILENAME,
+                cache_dir=str(cache_dir),
+            )
+        )
+    return str(local_path)
+
+
+def create_mask_overlay(image: Image.Image, masks: list[dict]) -> Image.Image:
+    image = image.convert("RGBA")
+    all_mask = np.zeros((image.height, image.width), dtype=np.uint8)
+
+    for mask in masks:
+        all_mask |= mask["segmentation"].astype(np.uint8)
+
+    mask_image = Image.fromarray(all_mask * 255, mode="L")
+    color_overlay = Image.new("RGBA", image.size, (255, 0, 0, 120))
+    overlay = Image.new("RGBA", image.size, (0, 0, 0, 0))
+    overlay.paste(color_overlay, mask=mask_image)
+    return Image.alpha_composite(image, overlay)
+
+
+def mask_to_bbox(mask: np.ndarray):
+    ys, xs = np.where(mask.astype(np.uint8))
+    if ys.size == 0 or xs.size == 0:
+        return None
+    return int(xs.min()), int(ys.min()), int(xs.max()) + 1, int(ys.max()) + 1
+
+
+def crop_masked_region(image: Image.Image, mask: np.ndarray) -> Image.Image | None:
+    bbox = mask_to_bbox(mask)
+    if bbox is None:
+        return None
+
+    mask_img = Image.fromarray((mask.astype(np.uint8) * 255).astype(np.uint8), mode="L")
+    background = Image.new("RGB", image.size, (127, 127, 127))
+    masked = Image.composite(image, background, mask_img)
+    return masked.crop(bbox)
+
+
+def normalize_features(features: torch.Tensor | object) -> torch.Tensor:
+    if hasattr(features, "pooler_output"):
+        features = features.pooler_output
+    elif hasattr(features, "last_hidden_state"):
+        features = features.last_hidden_state[:, 0, :]
+
+    if not isinstance(features, torch.Tensor):
+        raise RuntimeError("No se pudieron obtener características de CLIP.")
+
+    return features / features.norm(dim=-1, keepdim=True)
+
+
+def compute_clip_features(images: list[Image.Image]):
+    inputs = clip_processor(images=images, return_tensors="pt", padding=True).to(DEVICE)
+    with torch.no_grad():
+        features = clip_model.get_image_features(**inputs)
+    return normalize_features(features)
+
+
+def select_masks_by_text(image: Image.Image, masks: list[dict], prompt: str) -> tuple[list[dict], list[tuple[str, float | None]]]:
+    terms = [t.strip() for t in re.split(r"[,\n]+", prompt) if t.strip()]
+    if len(terms) == 0:
+        return [], []
+
+    crops = []
+    valid_masks = []
+    for mask in masks:
+        crop = crop_masked_region(image, mask["segmentation"])
+        if crop is not None:
+            valid_masks.append(mask)
+            crops.append(crop)
+
+    if len(crops) == 0:
+        return [], [(term, None) for term in terms]
+
+    image_features = compute_clip_features(crops)
+    text_inputs = clip_processor(text=terms, return_tensors="pt", padding=True).to(DEVICE)
+    with torch.no_grad():
+        text_features = clip_model.get_text_features(**text_inputs)
+        text_features = normalize_features(text_features)
+
+    similarities = (image_features @ text_features.T).cpu()
+    selected = []
+    hits = []
+    threshold = 0.15
+
+    for term_idx, term in enumerate(terms):
+        scores = similarities[:, term_idx]
+        best_idx = int(torch.argmax(scores).item())
+        best_score = float(scores[best_idx].item())
+        if best_score >= threshold:
+            mask = valid_masks[best_idx]
+            if mask not in selected:
+                selected.append(mask)
+            hits.append((term, best_score))
+        else:
+            hits.append((term, None))
+
+    return selected, hits
+
+
+@torch.no_grad()
+def segmentar_imagen(imagen: Image.Image, texto: str):
+    if imagen is None:
+        return None, "Subí una imagen para segmentar."
+
+    imagen = imagen.convert("RGB")
+    imagen_np = np.array(imagen)
+    masks = mask_generator.generate(imagen_np)
+
+    if len(masks) == 0:
+        return None, "No se generaron máscaras para esta imagen."
+
+    texto = texto.strip()
+    if texto == "":
+        overlay = create_mask_overlay(imagen, masks)
+        return overlay, f"Generadas {len(masks)} máscaras con SAM."
+
+    selected_masks, hits = select_masks_by_text(imagen, masks, texto)
+    if len(selected_masks) == 0:
+        terms = [t.strip() for t in re.split(r"[,\n]+", texto) if t.strip()]
+        return None, f"No se encontró un objeto que coincida con: {', '.join(terms)}."
+
+    found_terms = [term for term, score in hits if score is not None]
+    missing_terms = [term for term, score in hits if score is None]
+    overlay = create_mask_overlay(imagen, selected_masks)
+
+    message = f"Encontradas {len(selected_masks)} máscara(s) para: {', '.join(found_terms)}."
+    if missing_terms:
+        message += f" No se encontró: {', '.join(missing_terms)}."
+    return overlay, message
+
+
+def crear_app():
+    with gr.Blocks(title="Gradio + SAM 2.1 Demo") as demo:
+        gr.Markdown("# 🎯 Segmentación automática con SAM")
+        gr.Markdown(
+            "Subí una imagen y escribe una palabra para encontrar y segmentar el objeto deseado. Si dejas el texto vacío, se mostrarán todas las máscaras generadas."
+        )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                imagen_entrada = gr.Image(type="pil", label="Subí tu imagen")
+                texto_objeto = gr.Textbox(label="Buscar objeto", placeholder="Ej. perro, coche, persona")
+                boton = gr.Button("Segmentar")
+            with gr.Column(scale=1):
+                imagen_salida = gr.Image(label="Resultado segmentado")
+                estado = gr.Textbox(label="Estado", interactive=False)
+
+        boton.click(
+            fn=segmentar_imagen,
+            inputs=[imagen_entrada, texto_objeto],
+            outputs=[imagen_salida, estado],
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    checkpoint_path = download_checkpoint()
+    sam = sam_model_registry["vit_h"](checkpoint=checkpoint_path)
+    mask_generator = SamAutomaticMaskGenerator(sam)
+    clip_model = CLIPModel.from_pretrained(CLIP_MODEL_NAME).to(DEVICE)
+    clip_processor = CLIPProcessor.from_pretrained(CLIP_MODEL_NAME)
+    demo = crear_app()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False, ssr=False)

requirements.txt

@@ -0,0 +1,8 @@
+gradio==6.13.0
+segment-anything
+torch>=2.0.0
+torchvision
+transformers
+huggingface-hub
+numpy
+pillow