Fix ZeroGPU SAM3 runtime and request diagnostics

README.md

@@ -1,14 +1,12 @@
 ---
 title: SAM3 Panoptic
-emoji: 🎯
-colorFrom: indigo
-colorTo: blue
 sdk: gradio
 sdk_version: 6.6.0
 app_file: app.py
 pinned: false
-short_description: SAM 3 open-vocabulary panoptic concept segmentation API
+short_description: SAM3 open-vocabulary panoptic concept segmentation API
 ---
 
-`api_panoptic(image, concepts, conf)` -> JSON detections with base64-PNG masks.
-Requires the `HF_TOKEN` Space secret to have access to gated `facebook/sam3`.
+`api_panoptic(image, concepts, confidence, mask_threshold)` returns JSON
+detections with base64-encoded PNG masks. The Space requires an `HF_TOKEN`
+secret with access to `facebook/sam3`.

app.py

@@ -1,7 +1,11 @@
-"""SAM 3 panoptic concept-segmentation API (ZeroGPU). Self-contained."""
+"""SAM3 open-vocabulary panoptic segmentation API for Hugging Face Spaces."""
+
+from __future__ import annotations
+
 import base64
 import io
 import os
+import traceback
 
 import gradio as gr
 import numpy as np
@@ -10,69 +14,138 @@ import torch
 from PIL import Image
 from transformers import Sam3Model, Sam3Processor
 
+
 HF_TOKEN = os.environ.get("HF_TOKEN")
 MODEL_ID = "facebook/sam3"
+DEVICE = "cuda"
 
-# Built at import on CPU; moved to CUDA inside the @spaces.GPU function.
+# ZeroGPU emulates CUDA during startup and swaps in a real GPU for @spaces.GPU.
 processor = Sam3Processor.from_pretrained(MODEL_ID, token=HF_TOKEN)
-model = Sam3Model.from_pretrained(MODEL_ID, token=HF_TOKEN)
+model = Sam3Model.from_pretrained(MODEL_ID, token=HF_TOKEN).to(DEVICE)
 model.eval()
 
 
 def _encode_mask(mask_bool: np.ndarray) -> str:
-    arr = (mask_bool.astype(np.uint8)) * 255
-    buf = io.BytesIO()
-    Image.fromarray(arr, mode="L").save(buf, format="PNG")
-    return base64.b64encode(buf.getvalue()).decode("ascii")
+    buffer = io.BytesIO()
+    Image.fromarray(mask_bool.astype(np.uint8) * 255, mode="L").save(
+        buffer, format="PNG"
+    )
+    return base64.b64encode(buffer.getvalue()).decode("ascii")
+
 
+def _gpu_duration(image, concepts, conf, mask_threshold=0.5) -> int:
+    del image, conf, mask_threshold
+    concept_count = len(
+        [value for value in str(concepts or "").split(",") if value.strip()]
+    )
+    return min(120, max(30, concept_count * 20))
 
-@spaces.GPU(duration=120)
+
+@spaces.GPU(duration=_gpu_duration)
 def api_panoptic(image, concepts, conf, mask_threshold=0.5):
     if image is None:
-        return {"error": "no image provided"}
+        return {"error": "no image provided", "detections": []}
     image = image.convert("RGB")
-    W, H = image.size
-    concept_list = [c.strip() for c in (concepts or "").split(",") if c.strip()]
-    device = "cuda"
-    model.to(device)
+    width, height = image.size
+    concept_list = [
+        value.strip() for value in str(concepts or "").split(",") if value.strip()
+    ]
+    if not concept_list:
+        return {
+            "version": "4",
+            "model": MODEL_ID,
+            "width": width,
+            "height": height,
+            "detections": [],
+        }
+
+    print(
+        f"SAM3 request: size={width}x{height} concepts={len(concept_list)}",
+        flush=True,
+    )
     detections = []
-    for concept in concept_list:
-        inputs = processor(images=image, text=concept, return_tensors="pt").to(device)
-        with torch.no_grad():
-            outputs = model(**inputs)
-        target_sizes = (inputs["original_sizes"].tolist()
-                        if "original_sizes" in inputs else [[H, W]])
-        res = processor.post_process_instance_segmentation(
-            outputs, threshold=float(conf), mask_threshold=float(mask_threshold),
-            target_sizes=target_sizes)[0]
-        # NOTE (verify on live Space): expected keys masks/scores/boxes.
-        masks, scores = res["masks"], res["scores"]
-        boxes = res.get("boxes")
-        for i in range(len(scores)):
-            m = masks[i]
-            m = m.cpu().numpy() if hasattr(m, "cpu") else np.asarray(m)
-            mb = m > 0.5 if m.dtype != bool else m
-            box = (boxes[i].cpu().numpy().tolist()
-                   if boxes is not None else [0, 0, 0, 0])
-            detections.append({
-                "label": concept, "score": float(scores[i]),
-                "box": box, "mask_png_b64": _encode_mask(mb.astype(bool)),
-            })
-    return {"version": "3", "model": MODEL_ID, "width": W, "height": H,
-            "detections": detections}
+    try:
+        for concept in concept_list:
+            inputs = processor(
+                images=image, text=concept, return_tensors="pt"
+            ).to(DEVICE)
+            with torch.inference_mode():
+                outputs = model(**inputs)
+            target_sizes = (
+                inputs["original_sizes"].tolist()
+                if "original_sizes" in inputs
+                else [[height, width]]
+            )
+            result = processor.post_process_instance_segmentation(
+                outputs,
+                threshold=float(conf),
+                mask_threshold=float(mask_threshold),
+                target_sizes=target_sizes,
+            )[0]
+            masks = result["masks"]
+            scores = result["scores"]
+            boxes = result.get("boxes")
+            for index in range(len(scores)):
+                mask = masks[index]
+                mask_array = (
+                    mask.detach().cpu().numpy()
+                    if hasattr(mask, "detach")
+                    else np.asarray(mask)
+                )
+                mask_bool = (
+                    mask_array
+                    if mask_array.dtype == bool
+                    else mask_array > 0.5
+                )
+                box = (
+                    boxes[index].detach().cpu().numpy().tolist()
+                    if boxes is not None
+                    else [0, 0, 0, 0]
+                )
+                detections.append(
+                    {
+                        "label": concept,
+                        "score": float(scores[index]),
+                        "box": box,
+                        "mask_png_b64": _encode_mask(mask_bool),
+                    }
+                )
+    except Exception:
+        traceback.print_exc()
+        raise
+
+    print(f"SAM3 response: detections={len(detections)}", flush=True)
+    return {
+        "version": "4",
+        "model": MODEL_ID,
+        "width": width,
+        "height": height,
+        "detections": detections,
+    }
 
 
 with gr.Blocks(title="SAM3 Panoptic") as demo:
-    gr.Markdown("# SAM 3 Panoptic API\nUpload an image, enter comma-separated concepts.")
+    gr.Markdown("# SAM3 Panoptic API")
     with gr.Row():
-        inp = gr.Image(type="pil", label="Image")
-        out = gr.JSON(label="Detections")
-    txt = gr.Textbox(label="Concepts (comma-separated)",
-                     value="person, car, road, sky, building, tree")
-    conf = gr.Slider(0.0, 1.0, value=0.4, step=0.05, label="Confidence (lower = more detail)")
-    mthr = gr.Slider(0.05, 0.95, value=0.5, step=0.05, label="Mask threshold")
-    gr.Button("Segment").click(api_panoptic, [inp, txt, conf, mthr], out,
-                               api_name="api_panoptic")
+        input_image = gr.Image(type="pil", label="Image")
+        output_json = gr.JSON(label="Detections")
+    concept_text = gr.Textbox(
+        label="Concepts",
+        value="person, car, road, building, tree",
+    )
+    confidence = gr.Slider(
+        0.0, 1.0, value=0.4, step=0.05, label="Confidence"
+    )
+    mask_threshold = gr.Slider(
+        0.05, 0.95, value=0.5, step=0.05, label="Mask threshold"
+    )
+    gr.Button("Segment").click(
+        api_panoptic,
+        [input_image, concept_text, confidence, mask_threshold],
+        output_json,
+        api_name="api_panoptic",
+    )
+
 
 if __name__ == "__main__":
-    demo.queue().launch()
+    demo.queue(default_concurrency_limit=1).launch()