Initial FastAPI Docker Space

.dockerignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+.env
+.venv/
+venv/
+.git/
+.gitignore
+.DS_Store
+node_modules/

.gitignore

@@ -0,0 +1,8 @@
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+.venv/
+venv/

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# System deps: pillow image codecs + git (some HF model downloads may require git-lfs at runtime, but not for standard hub downloads)
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+      build-essential \
+      libjpeg62-turbo-dev \
+      zlib1g-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY app /app/app
+
+ENV PORT=7860
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -8,4 +8,38 @@ pinned: false
 short_description: Bench detector
 ---
 
+# bench-detector (FastAPI)
+
+## Local Docker
+
+Build:
+
+```bash
+docker build -t bench-detector:local .
+```
+
+Run:
+
+```bash
+docker run --rm -p 7860:7860 bench-detector:local
+```
+
+Health check:
+
+```bash
+curl -s http://localhost:7860/health
+```
+
+Score an image:
+
+```bash
+curl -s -X POST http://localhost:7860/score \
+  -F "image=@/path/to/image.jpg" | jq
+```
+
+## Environment variables
+
+- `MODEL_ID` (default: `openai/clip-vit-base-patch32`)
+- `DEVICE` (default: auto; set to `cpu` or `cuda` if desired)
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/__init__.py

@@ -0,0 +1 @@
+

app/detector.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+import torch
+from PIL import Image
+from transformers import CLIPModel, CLIPProcessor
+
+
+@dataclass(frozen=True)
+class BenchDetectionResult:
+    probability: float
+
+
+_BENCH_PROMPTS: tuple[str, ...] = (
+    "a park bench",
+    "a wooden bench outdoors",
+    "a metal bench in a park",
+    "a sitting bench",
+)
+
+_NON_BENCH_PROMPTS: tuple[str, ...] = (
+    "a chair",
+    "a sofa",
+    "a table",
+    "a street",
+    "a tree",
+    "no bench",
+)
+
+
+class BenchDetector:
+    def __init__(
+        self,
+        model_id: str = "openai/clip-vit-base-patch32",
+        device: str | None = None,
+    ) -> None:
+        self.model_id = model_id
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+
+        self._processor = CLIPProcessor.from_pretrained(model_id)
+        self._model = CLIPModel.from_pretrained(model_id)
+        self._model.to(self.device)
+        self._model.eval()
+
+    def predict_probability(
+        self,
+        image: Image.Image,
+        bench_prompts: Iterable[str] = _BENCH_PROMPTS,
+        non_bench_prompts: Iterable[str] = _NON_BENCH_PROMPTS,
+    ) -> BenchDetectionResult:
+        bench_prompts = tuple(bench_prompts)
+        non_bench_prompts = tuple(non_bench_prompts)
+        texts = bench_prompts + non_bench_prompts
+
+        inputs = self._processor(text=list(texts), images=image, return_tensors="pt", padding=True)
+        inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+        with torch.no_grad():
+            outputs = self._model(**inputs)
+            logits_per_image = outputs.logits_per_image
+            probs = logits_per_image.softmax(dim=1)[0]
+
+        bench_prob = float(probs[: len(bench_prompts)].sum().item())
+        bench_prob = max(0.0, min(1.0, bench_prob))
+        return BenchDetectionResult(probability=bench_prob)

app/main.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import io
+import os
+import time
+from typing import Any
+
+from fastapi import FastAPI, File, HTTPException, UploadFile
+from fastapi.responses import JSONResponse
+from PIL import Image
+
+from app.detector import BenchDetector
+
+
+app = FastAPI(title="bench-detector", version="0.1.0")
+
+_detector: BenchDetector | None = None
+
+
+def _get_detector() -> BenchDetector:
+    global _detector
+    if _detector is None:
+        model_id = os.environ.get("MODEL_ID", "openai/clip-vit-base-patch32")
+        device = os.environ.get("DEVICE")
+        _detector = BenchDetector(model_id=model_id, device=device)
+    return _detector
+
+
+@app.get("/health")
+def health() -> dict[str, Any]:
+    return {"ok": True}
+
+
+@app.post("/score")
+async def score(image: UploadFile = File(...)) -> JSONResponse:
+    raw = await image.read()
+    if not raw:
+        raise HTTPException(status_code=400, detail="Empty file")
+
+    try:
+        pil = Image.open(io.BytesIO(raw))
+        if pil.mode != "RGB":
+            pil = pil.convert("RGB")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Invalid image: {e}")
+
+    detector = _get_detector()
+
+    t0 = time.perf_counter()
+    result = detector.predict_probability(pil)
+    elapsed_ms = (time.perf_counter() - t0) * 1000.0
+
+    return JSONResponse(
+        {
+            "probability": result.probability,
+            "model_id": detector.model_id,
+            "device": detector.device,
+            "elapsed_ms": elapsed_ms,
+        }
+    )

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.115.6
+python-multipart==0.0.20
+uvicorn[standard]==0.34.0
+pillow==11.0.0
+transformers==4.47.1
+# CPU-only PyTorch
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.5.1