Fix ZeroGPU startup: disable Xet, run inference behind @spaces.GPU

The Space moved to ZeroGPU (zero-a10g), which broke startup in three ways:

- The HF Xet downloader can't write its cache inside the ZeroGPU sandbox
("Permission denied (os error 13)"), crashing when open_clip pulled the
CLIP classifier weights at runtime. Force the classic HTTP downloader
(HF_HUB_DISABLE_XET=1, set before huggingface_hub is imported) and also
preload the CLIP repo at build time.
- GPU work must run inside a @spaces.GPU window. Wrap _run_inference in
@spaces.GPU(duration=120), import the spaces scheduler (no-op fallback for
local/non-ZeroGPU dev), and guard the CUDA cleanup for when no device is
attached.
- The CLIP classifier ran a text-encoder forward pass in its constructor; on
ZeroGPU a forward at import time has no GPU. Defer the centroid computation
to first use (inside the GPU window) and keep only the weight load eager.

Also align suggested_hardware with the deployed zero-a10g.

README.md

@@ -23,7 +23,8 @@ tags:
     - arxiv:2605.26368
 preload_from_hub:
     - prs-eth/PaGeR
-suggested_hardware: a10g-large
+    - timm/vit_base_patch32_clip_224.openai
+suggested_hardware: zero-a10g
 short_description: Panorama Geometry Reconstruction
 ---
 

app.py

@@ -18,11 +18,36 @@ from __future__ import annotations
 
 import argparse
 import gc
+import os
 import sys
 from io import BytesIO
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 
+# HuggingFace's Xet download backend can't write its chunk cache inside the
+# ZeroGPU sandbox (``Permission denied (os error 13)``), which crashed startup
+# when open_clip pulled the CLIP weights at runtime. Force the classic HTTP
+# downloader, which writes to the normal (writable) hub cache. Must be set
+# before ``huggingface_hub`` is first imported, hence up here.
+os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
+
+# ``spaces`` provides the ZeroGPU scheduler: GPU work must run inside a
+# ``@spaces.GPU`` function so the runtime attaches a GPU for its duration.
+# Import it before torch. Off ZeroGPU (local dev) the package is absent, so
+# fall back to a no-op decorator that supports both ``@spaces.GPU`` and
+# ``@spaces.GPU(...)``.
+try:
+    import spaces
+except ImportError:
+    class _SpacesStub:
+        @staticmethod
+        def GPU(*args, **kwargs):
+            if len(args) == 1 and callable(args[0]) and not kwargs:
+                return args[0]
+            return lambda fn: fn
+
+    spaces = _SpacesStub()
+
 # Expose the vendored ``depth_anything_3`` package at top-level so its internal
 # absolute imports resolve even when this script is run without an editable
 # install (e.g. on HuggingFace Spaces, where ``pip install -e .`` is not run).
@@ -78,9 +103,14 @@ def parse_args() -> argparse.Namespace:
 
 
 def _release_cuda_memory() -> None:
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-        torch.cuda.ipc_collect()
+    # On ZeroGPU this can run outside a GPU window (no device attached), where
+    # the cache calls aren't usable — swallow that and just collect on the host.
+    try:
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+    except Exception:
+        pass
     gc.collect()
 
 
@@ -103,6 +133,7 @@ def _resolve_scene(mode: str, rgb_cubemap_centred: torch.Tensor) -> tuple[str, s
     return scene, f"**Scale head:** Auto → {scene}"
 
 
+@spaces.GPU(duration=120)
 def _run_inference(input_rgb: np.ndarray, mode: str):
     img = torch.from_numpy(input_rgb).permute(2, 0, 1).to(torch.float32) / 255.0
     img = img * 2.0 - 1.0  # ImageNet-style centred input for the backbone.

requirements.txt

@@ -19,3 +19,6 @@ pytorch360convert
 matplotlib
 trimesh
 gradio>=5
+
+# ZeroGPU scheduler (@spaces.GPU); pre-installed on ZeroGPU hardware.
+spaces

src/utils/scene_classifier.py

@@ -90,20 +90,40 @@ class IndoorOutdoorClassifier:
             force_quick_gelu=(pretrained == "openai"),
         )
         self.model = model.eval()
-        tokenizer = open_clip.get_tokenizer(model_name)
-
-        with torch.inference_mode():
-            centroids = {}
-            for key, prompts in (("indoor", indoor_prompts), ("outdoor", outdoor_prompts)):
-                toks = tokenizer(list(prompts)).to(self.device)
-                feats = F.normalize(self.model.encode_text(toks), dim=-1)
-                centroids[key] = F.normalize(feats.mean(dim=0, keepdim=True), dim=-1)
-        self.text_indoor = centroids["indoor"]    # (1, D)
-        self.text_outdoor = centroids["outdoor"]  # (1, D)
+        self.tokenizer = open_clip.get_tokenizer(model_name)
+
+        # The text centroids are built lazily on first ``classify`` call -- see
+        # ``_ensure_centroids``. Building them here would run a CLIP text-encoder
+        # forward pass at construction time, which breaks on HF ZeroGPU: a GPU
+        # is only attached inside a ``@spaces.GPU`` window, so a forward run at
+        # import/startup has no device. Loading the weights (above) is fine;
+        # only the forward must wait for a GPU window.
+        self._indoor_prompts = tuple(indoor_prompts)
+        self._outdoor_prompts = tuple(outdoor_prompts)
+        self.text_indoor = None    # (1, D), filled lazily
+        self.text_outdoor = None   # (1, D), filled lazily
 
         # Image-side normalisation buffers (kept on device for fast inference).
         self.register_clip_norm(self.device)
 
+    @torch.inference_mode()
+    def _ensure_centroids(self) -> None:
+        """Build the indoor/outdoor text centroids on first use (idempotent).
+
+        Each centroid is the L2-normalised mean of its prompts' L2-normalised
+        CLIP text embeddings. Deferred out of ``__init__`` so the forward pass
+        runs inside the caller's GPU window (see the note there)."""
+        if self.text_indoor is not None:
+            return
+        centroids = {}
+        for key, prompts in (("indoor", self._indoor_prompts),
+                             ("outdoor", self._outdoor_prompts)):
+            toks = self.tokenizer(list(prompts)).to(self.device)
+            feats = F.normalize(self.model.encode_text(toks), dim=-1)
+            centroids[key] = F.normalize(feats.mean(dim=0, keepdim=True), dim=-1)
+        self.text_indoor = centroids["indoor"]    # (1, D)
+        self.text_outdoor = centroids["outdoor"]  # (1, D)
+
     def register_clip_norm(self, device: torch.device) -> None:
         self._clip_mean = torch.tensor(_CLIP_MEAN, device=device).view(1, 3, 1, 1)
         self._clip_std = torch.tensor(_CLIP_STD, device=device).view(1, 3, 1, 1)
@@ -126,6 +146,7 @@ class IndoorOutdoorClassifier:
             raise ValueError(
                 f"Expected cubemap of shape (6, 3, F, F); got {tuple(cubemap_01.shape)}"
             )
+        self._ensure_centroids()
         eq = cubemap_01[:4].to(self.device).clamp(0, 1)
         eq = F.interpolate(eq, size=(224, 224), mode="bilinear",
                            align_corners=False, antialias=True)