fix: gate transformers judge on real GPU; ZeroGPU-correct loading; deploy to BladeSzaSza ZeroGPU Space

formscout/config.py

@@ -147,14 +147,35 @@ LLAMA_CPP_PORT_EMBED = 8081
 # ─── Judge backend selection ────────────────────────────────────────────────
 # "llama_cpp"   — local llama-server (default for local dev; works perfectly)
 # "transformers"— in-process Qwen3-VL via transformers, GPU on HF Spaces (ZeroGPU)
-# "auto"        — transformers on a Space (SPACE_ID set), llama_cpp locally
+# "auto"        — transformers ONLY on a GPU/ZeroGPU Space, else llama_cpp
 JUDGE_BACKEND = os.environ.get("FORMSCOUT_JUDGE_BACKEND", "auto")
 JUDGE_HF_MODEL = os.environ.get("FORMSCOUT_JUDGE_HF_MODEL", "Qwen/Qwen3-VL-8B-Instruct")
 ON_HF_SPACE = bool(os.environ.get("SPACE_ID"))
 
 
+def has_gpu() -> bool:
+    """True on a ZeroGPU Space (env flag) or when CUDA is actually present.
+
+    ZeroGPU exposes no CUDA outside @spaces.GPU, so it is detected via the
+    SPACES_ZERO_GPU env flag; ordinary GPU Spaces report via torch.cuda.
+    """
+    if os.environ.get("SPACES_ZERO_GPU") or os.environ.get("ZERO_GPU"):
+        return True
+    try:
+        import torch
+        return bool(torch.cuda.is_available())
+    except Exception:
+        return False
+
+
 def resolve_judge_backend() -> str:
-    """Resolve the effective judge backend from JUDGE_BACKEND + environment."""
+    """Resolve the effective judge backend from JUDGE_BACKEND + environment.
+
+    `auto` only engages the heavy in-process transformers model when a GPU is
+    actually available — a CPU-only Space stays on llama_cpp (which is then
+    unreachable, so the Judge falls back to the fast rubric instead of trying to
+    run a 17 GB model on CPU).
+    """
     if JUDGE_BACKEND in ("llama_cpp", "transformers"):
         return JUDGE_BACKEND
-    return "transformers" if ON_HF_SPACE else "llama_cpp"
+    return "transformers" if (ON_HF_SPACE and has_gpu()) else "llama_cpp"

formscout/serving/transformers_vlm.py

@@ -39,19 +39,27 @@ except Exception:  # pragma: no cover
         return fn
 
 
-@_gpu
-def _generate(model_id: str, prompt: str, pil_images: list, max_tokens: int,
-              temperature: float) -> str:  # pragma: no cover - needs GPU + model
-    """Load (cached) and run Qwen3-VL; returns the raw decoded string."""
-    import torch
-    from transformers import AutoModelForImageTextToText, AutoProcessor
-
+def _ensure_loaded(model_id: str):  # pragma: no cover - downloads ~16 GB
+    """Load processor + model to CPU once (cached). Kept OUT of the GPU window so
+    the 17 GB download/load does not eat ZeroGPU time."""
     if "model" not in _CACHE:
+        import torch
+        from transformers import AutoModelForImageTextToText, AutoProcessor
         _CACHE["processor"] = AutoProcessor.from_pretrained(model_id)
         _CACHE["model"] = AutoModelForImageTextToText.from_pretrained(
-            model_id, torch_dtype="auto", device_map="auto",
+            model_id, torch_dtype=torch.bfloat16,
         )
+    return _CACHE["processor"], _CACHE["model"]
+
+
+@_gpu
+def _generate(prompt: str, pil_images: list, max_tokens: int,
+              temperature: float) -> str:  # pragma: no cover - needs GPU + model
+    """Move the cached model to CUDA and run Qwen3-VL (ZeroGPU window)."""
+    import torch
+
     processor, model = _CACHE["processor"], _CACHE["model"]
+    model.to("cuda")
 
     content = [{"type": "image", "image": im} for im in pil_images]
     content.append({"type": "text", "text": prompt})
@@ -60,7 +68,7 @@ def _generate(model_id: str, prompt: str, pil_images: list, max_tokens: int,
     inputs = processor.apply_chat_template(
         messages, tokenize=True, add_generation_prompt=True,
         return_tensors="pt", return_dict=True,
-    ).to(model.device)
+    ).to("cuda")
 
     with torch.no_grad():
         out = model.generate(
@@ -90,7 +98,8 @@ class TransformersVLMClient:
                  stop: list[str] | None = None) -> dict:
         try:
             pil_images = self._decode_images(images)
-            text = _generate(self.model_id, prompt, pil_images, max_tokens, temperature)
+            _ensure_loaded(self.model_id)  # CPU load (no GPU time)
+            text = _generate(prompt, pil_images, max_tokens, temperature)
             return LlamaCppClient._parse_json_reply(text)
         except Exception as e:  # pragma: no cover - needs GPU + model
             logger.warning("transformers VLM failed (%s) — falling back to rubric", e)

scripts/hf_upload.sh

@@ -23,6 +23,7 @@ cd "$(dirname "$0")/.."
 
 MODEL_REPO="silas-therapy/small-functional-movement-screening"
 SPACE_REPO="spaces/silas-therapy/small-functional-movement-screening"
+SPACE_BLADESZASZA_REPO="spaces/bladeszasza/small-functional-movement-screening"
 MSG="${1:-$(git log -1 --pretty=%s)}"
 LARGE_THRESHOLD="${FORMSCOUT_HF_LARGE_THRESHOLD:-500}"
 
@@ -76,22 +77,41 @@ if (( N_FILES == 0 )); then
     exit 1
 fi
 
+# upload_repo <repo> [pr|direct]
+#   pr     — open a PR (shared org repos; review before merge)
+#   direct — commit straight to main (repos you own; deploys immediately)
 upload_repo() {
     local repo="$1"
+    local mode="${2:-pr}"
     if (( N_FILES > LARGE_THRESHOLD )); then
         echo "── $repo: $N_FILES files > $LARGE_THRESHOLD, using upload-large-folder"
         echo "   (resumable; commits directly to main — no PR, no custom message)"
         hf upload-large-folder "$repo" . "${EXCLUDES[@]}"
+    elif [[ "$mode" == "direct" ]]; then
+        echo "── uploading (direct → main) to: $repo"
+        hf upload "$repo" . . "${EXCLUDES[@]}" --commit-message="$MSG"
     else
-        echo "── uploading to: $repo"
-        hf upload "$repo" . . \
-            "${EXCLUDES[@]}" \
-            --create-pr \
-            --commit-message="$MSG"
+        echo "── uploading (PR) to: $repo"
+        hf upload "$repo" . . "${EXCLUDES[@]}" --create-pr --commit-message="$MSG"
     fi
 }
 
-upload_repo "$MODEL_REPO"
-upload_repo "$SPACE_REPO"
+# Ensure the personal ZeroGPU Space exists. Tries zero-a10g (needs Pro/ZeroGPU);
+# falls back to cpu-basic so the upload still has a target (set ZeroGPU in
+# Settings afterward). Idempotent via --exist-ok.
+ensure_blade_space() {
+    local id="bladeszasza/$REPO_NAME"
+    if hf repos create "$id" --type space --space-sdk gradio --flavor zero-a10g --exist-ok 2>/dev/null; then
+        echo "── Space ready (ZeroGPU / zero-a10g): $id"
+    else
+        echo "── zero-a10g unavailable (Pro/ZeroGPU quota?) — creating cpu-basic; switch to ZeroGPU in Settings"
+        hf repos create "$id" --type space --space-sdk gradio --exist-ok || true
+    fi
+}
 
+# Shared org repos → PRs; personal ZeroGPU Space → created + direct deploy.
+upload_repo "$MODEL_REPO" pr
+upload_repo "$SPACE_REPO" pr
+ensure_blade_space
+upload_repo "$SPACE_BLADESZASZA_REPO" direct
 echo "✓ done"

tests/test_judge_backend.py

@@ -21,9 +21,19 @@ def test_resolve_backend_default_local(monkeypatch):
     assert cfg.resolve_judge_backend() == "llama_cpp"
 
 
-def test_resolve_backend_auto_on_space(monkeypatch):
-    cfg = _reload_config(monkeypatch, FORMSCOUT_JUDGE_BACKEND="auto", SPACE_ID="me/space")
+def test_resolve_backend_auto_on_zero_gpu_space(monkeypatch):
+    cfg = _reload_config(monkeypatch, FORMSCOUT_JUDGE_BACKEND="auto",
+                         SPACE_ID="me/space", SPACES_ZERO_GPU="true")
     assert cfg.resolve_judge_backend() == "transformers"
+    importlib.reload(config)
+
+
+def test_resolve_backend_auto_on_cpu_space_stays_llama(monkeypatch):
+    # A CPU-only Space must NOT load the 17 GB transformers model.
+    cfg = _reload_config(monkeypatch, FORMSCOUT_JUDGE_BACKEND="auto",
+                         SPACE_ID="me/space", SPACES_ZERO_GPU=None, ZERO_GPU=None)
+    assert cfg.resolve_judge_backend() == "llama_cpp"
+    importlib.reload(config)
 
 
 def test_resolve_backend_explicit(monkeypatch):