refactor: minimal hacks — own inference wrapper, trimmed stubs and deps, gradio 6.20

- sam3d_inference.py replaces notebook/inference.py: imports only the
pipeline, dropping the kaolin.visualize/SceneVisualizer/plotly chain
- attention backend pinned to sdpa via import order (upstream env mechanism)
instead of source patching; flash_attn stub removed
- kaolin stub reduced to utils.testing.check_tensor (flexicubes); pytorch3d
stub reduced to transforms/structures/renderer
- requirements: drop ~25 training-only packages (verified unreferenced in the
inference import graph); move spconv/open3d/iopath from runtime pip into
requirements; pin hydra-core 1.3.2
- drop hydra patch script call: it was invoked with bash against a python
script and never ran — the successful e2e run proves it is not needed
- drop utils3d monkey-patches: the pinned commit ships those functions
- gradio 6.20.0

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

README.md

@@ -4,7 +4,7 @@ emoji: 📦
 colorFrom: purple
 colorTo: blue
 sdk: gradio
-sdk_version: 6.13.0
+sdk_version: 6.20.0
 python_version: "3.12"
 app_file: app.py
 pinned: false

app.py

@@ -3,13 +3,17 @@ SAM 3D Objects MCP Server
 Image → 3D Object (GLB)
 
 SAM2 auto-detection + SAM 3D Objects reconstruction on ZeroGPU.
-kaolin/pytorch3d/flash_attn are stubbed (only their pure-python surface is
-used since texture baking and mesh postprocessing are disabled); spconv and
-gsplat are installed at runtime against the ZeroGPU-provided torch.
+
+torch is provided by ZeroGPU. kaolin and pytorch3d are replaced by pure-python
+stubs covering exactly the surface the pipeline touches — texture baking, mesh
+postprocessing and layout postprocessing are disabled, so their compiled ops
+are never called. Packages that need torch at install time are installed at
+startup. The attention backend is pinned to sdpa via import order in
+sam3d_inference.py (flash_attn is not available on ZeroGPU).
 """
 import os
-import sys
 import subprocess
+import sys
 import tempfile
 from pathlib import Path
 
@@ -29,106 +33,39 @@ from huggingface_hub import snapshot_download, login
 if os.environ.get("HF_TOKEN"):
     login(token=os.environ["HF_TOKEN"])
 
-# --- Stubs (must be on sys.path before sam3d imports) ---
 APP_ROOT = Path(__file__).parent
-for stub in ["kaolin_stub", "pytorch3d_stub", "flash_attn_stub"]:
-    stub_path = APP_ROOT / stub
-    if stub_path.exists():
-        sys.path.insert(0, str(stub_path))
-        print(f"Stub added: {stub}")
+for stub in ["kaolin_stub", "pytorch3d_stub"]:
+    sys.path.insert(0, str(APP_ROOT / stub))
 
 
-# --- Runtime pip installs (need torch present, so not in requirements.txt) ---
-def _pip(*a):
+def _pip(*args):
     r = subprocess.run(
-        [sys.executable, "-m", "pip", "install", "--no-cache-dir"] + list(a),
+        [sys.executable, "-m", "pip", "install", "--no-cache-dir", *args],
         capture_output=True, text=True, timeout=1200,
     )
-    tag = a[-1][:60]
-    print(f"  pip {'OK' if r.returncode == 0 else 'FAIL'}: {tag}")
+    print(f"  pip {'OK' if r.returncode == 0 else 'FAIL'}: {args[-1][:70]}")
     if r.returncode != 0:
-        print(f"    {r.stderr[-300:]}")
+        print(f"    {r.stderr[-500:]}")
     return r.returncode == 0
 
 
-print("=== Runtime installs ===")
-_pip("open3d>=0.18.0")
-# utils3d pinned to the commit MoGe expects — git HEAD removed points_to_normals
+print("=== Runtime installs (need torch present) ===")
+# utils3d pinned to the commit MoGe expects — newer commits dropped points_to_normals
 _pip("--no-deps", "git+https://github.com/EasternJournalist/utils3d.git@3913c65d81e05e47b9f367250cf8c0f7462a0900")
-_pip("iopath")
 _pip("--no-deps", "sam2>=1.1.0")
 _pip("--no-deps", "git+https://github.com/microsoft/MoGe.git@a8c37341bc0325ca99b9d57981cc3bb2bd3e255b")
-# gsplat: no prebuilt wheels beyond pt24 — PyPI sdist installs in JIT mode;
-# kernels never compile here because rendering paths are disabled.
+# no prebuilt gsplat wheels beyond torch 2.4 — the PyPI sdist installs in JIT
+# mode; kernels never compile here because rendering paths are disabled
 _pip("--no-deps", "gsplat")
-# spconv cu124 wheel is forward-compatible with the cu128 runtime
-_pip("spconv-cu124==2.3.8")
 
-# --- Clone sam-3d-objects ---
 SAM3D_PATH = APP_ROOT / "sam-3d-objects"
 if not SAM3D_PATH.exists():
     print("Cloning sam-3d-objects...")
     subprocess.run(["git", "clone", "--depth", "1",
                     "https://github.com/facebookresearch/sam-3d-objects.git",
                     str(SAM3D_PATH)], check=True)
-
-subprocess.run([sys.executable, "-m", "pip", "install", "-e", str(SAM3D_PATH), "--no-deps"],
-               capture_output=True, text=True)
-
-hydra_patch = SAM3D_PATH / "patching" / "hydra"
-if hydra_patch.exists():
-    subprocess.run(["bash", str(hydra_patch)], capture_output=True, cwd=str(SAM3D_PATH))
-
-# Patch: inference_pipeline.py forces flash_attn on A100/H100/H200,
-# but only the stub is installed — keep sdpa.
-ip_file = SAM3D_PATH / "sam3d_objects" / "pipeline" / "inference_pipeline.py"
-if ip_file.exists():
-    src = ip_file.read_text()
-    old = ('if "A100" in gpu_name or "H100" in gpu_name or "H200" in gpu_name:\n'
-           '        # logger.info("Use flash_attn")\n'
-           '        os.environ["ATTN_BACKEND"] = "flash_attn"\n'
-           '        os.environ["SPARSE_ATTN_BACKEND"] = "flash_attn"')
-    if old in src:
-        ip_file.write_text(src.replace(
-            old,
-            '# PATCHED: flash_attn not available on ZeroGPU, keep sdpa\n'
-            '    os.environ.setdefault("ATTN_BACKEND", "sdpa")\n'
-            '    os.environ.setdefault("SPARSE_ATTN_BACKEND", "sdpa")'
-        ))
-        print("PATCHED: inference_pipeline.py — forced sdpa backend")
-    else:
-        print("INFO: inference_pipeline.py patch marker not found (upstream changed?)")
-
 sys.path.insert(0, str(SAM3D_PATH))
-sys.path.insert(0, str(SAM3D_PATH / "notebook"))
-
-# --- Patch: utils3d from git lacks depth_edge/normals_edge (needed by layout code) ---
-try:
-    import utils3d.numpy as _u3d_np
-    if not hasattr(_u3d_np, "depth_edge"):
-        def _depth_edge(depth, rtol=0.03, mask=None):
-            from scipy.ndimage import sobel
-            d = np.where(mask, depth, 0.0) if mask is not None else depth.copy()
-            grad = np.sqrt(sobel(d, axis=1) ** 2 + sobel(d, axis=0) ** 2)
-            denom = np.abs(d)
-            denom[denom < 1e-6] = 1e-6
-            edge = (grad / denom) > rtol
-            return edge & mask if mask is not None else edge
-        _u3d_np.depth_edge = _depth_edge
-
-        def _normals_edge(normals, tol=0.1, mask=None):
-            from scipy.ndimage import sobel
-            edges = np.zeros(normals.shape[:2], dtype=bool)
-            for c in range(normals.shape[-1]):
-                ch = np.where(mask, normals[..., c], 0.0) if mask is not None else normals[..., c]
-                edges |= np.sqrt(sobel(ch, axis=1) ** 2 + sobel(ch, axis=0) ** 2) > tol
-            return edges & mask if mask is not None else edges
-        _u3d_np.normals_edge = _normals_edge
-        print("Injected depth_edge + normals_edge into utils3d.numpy")
-except Exception as e:
-    print(f"utils3d patch skipped: {e}")
-
-# --- Pre-download checkpoints ---
+
 print("Downloading SAM3D checkpoints...")
 CKPT_DIR = snapshot_download(repo_id="facebook/sam-3d-objects",
                              token=os.environ.get("HF_TOKEN"))
@@ -143,8 +80,7 @@ print("=== Startup complete ===")
 
 
 def _gaussians_to_glb(result, out_dir):
-    """Extract gaussians from pipeline result and Poisson-mesh them to GLB."""
-    import torch
+    """Extract gaussians from the pipeline result and Poisson-mesh them to GLB."""
     gs = None
     if hasattr(result, "save_ply"):
         gs = result
@@ -184,7 +120,11 @@ def diagnose():
     for mod in ["kaolin", "pytorch3d", "spconv", "gsplat", "utils3d", "open3d", "moge"]:
         try:
             m = __import__(mod)
-            lines.append(f"{mod}: OK ({getattr(m, '__version__', '-')})")
+            try:
+                ver = getattr(m, "__version__", "-")
+            except Exception:
+                ver = "-"
+            lines.append(f"{mod}: OK ({ver})")
         except Exception as e:
             lines.append(f"{mod}: FAIL - {e}")
     try:
@@ -193,10 +133,10 @@ def diagnose():
     except Exception as e:
         lines.append(f"sam2: FAIL - {e}")
     try:
-        from inference import Inference  # noqa: F401
-        lines.append("SAM3D Inference: importable")
+        from sam3d_inference import SAM3DInference  # noqa: F401
+        lines.append("SAM3DInference: importable")
     except Exception as e:
-        lines.append(f"SAM3D Inference: FAIL - {e}")
+        lines.append(f"SAM3DInference: FAIL - {e}")
     lines.append(f"config: {Path(CONFIG_PATH).exists()}")
     return "\n".join(lines)
 
@@ -216,8 +156,8 @@ def reconstruct_objects(image: np.ndarray):
     if image is None:
         return None, None, "❌ No image provided"
     try:
-        import torch
         import time
+        import torch
         t0 = time.time()
         print(f"GPU: {torch.cuda.get_device_name()}")
 
@@ -225,7 +165,7 @@ def reconstruct_objects(image: np.ndarray):
         sam2_gen = SAM2AutomaticMaskGenerator.from_pretrained("facebook/sam2-hiera-small")
         print(f"  SAM2 loaded ({time.time()-t0:.0f}s)")
 
-        image_np = np.array(image) if not isinstance(image, np.ndarray) else image
+        image_np = np.asarray(image)
         masks = sam2_gen.generate(image_np)
         if not masks:
             return None, image_np, "⚠️ No objects detected"
@@ -240,8 +180,8 @@ def reconstruct_objects(image: np.ndarray):
         del sam2_gen
         torch.cuda.empty_cache()
 
-        from inference import Inference
-        sam3d = Inference(CONFIG_PATH, compile=False)
+        from sam3d_inference import SAM3DInference
+        sam3d = SAM3DInference(CONFIG_PATH)
         print(f"  SAM3D loaded ({time.time()-t0:.0f}s)")
 
         result = sam3d(image=image_np, mask=best_mask, seed=42)
@@ -260,14 +200,13 @@ def reconstruct_objects(image: np.ndarray):
         except Exception:
             n_faces = 0
         return glb, preview, f"✓ {len(masks)} objects detected, {n_faces:,} faces ({int(time.time()-t0)}s)"
-    except Exception as e:
+    except Exception:
         import traceback
         tb = traceback.format_exc()
         print(tb)
         return None, None, f"❌ Error:\n{tb[-1500:]}"
 
 
-# Gradio Interface
 with gr.Blocks(title="SAM 3D Objects MCP") as demo:
     gr.Markdown("""
     # 📦 SAM 3D Objects MCP Server

flash_attn_stub/flash_attn/__init__.py

@@ -1,191 +0,0 @@
-"""flash_attn stub – implements flash attention API using torch SDPA.
-
-This replaces the real flash_attn package on systems where it cannot be compiled
-(e.g. ZeroGPU with PyTorch 2.10+cu128 and no matching wheel).
-All functions accept the same signatures as flash_attn 2.x and delegate to
-torch.nn.functional.scaled_dot_product_attention.
-"""
-import torch
-import torch.nn.functional as F
-
-
-def _sdpa(q, k, v, causal=False, softmax_scale=None):
-    """Apply SDPA. q/k/v are (B, H, L, D)."""
-    return F.scaled_dot_product_attention(
-        q, k, v,
-        is_causal=causal,
-        scale=softmax_scale,
-    )
-
-
-# ---------- non-varlen ----------
-
-def flash_attn_func(q, k, v, dropout_p=0.0, softmax_scale=None, causal=False,
-                    window_size=(-1, -1), softcap=0.0, alibi_slopes=None,
-                    deterministic=False, return_attn_probs=False):
-    """q/k/v: (B, L, H, D) -> out: (B, L, H, D)"""
-    # Permute to (B, H, L, D) for SDPA
-    q2 = q.transpose(1, 2)
-    k2 = k.transpose(1, 2)
-    v2 = v.transpose(1, 2)
-    out = _sdpa(q2, k2, v2, causal=causal, softmax_scale=softmax_scale)
-    out = out.transpose(1, 2)  # back to (B, L, H, D)
-    return out
-
-
-def flash_attn_qkvpacked_func(qkv, dropout_p=0.0, softmax_scale=None, causal=False,
-                               window_size=(-1, -1), softcap=0.0, alibi_slopes=None,
-                               deterministic=False, return_attn_probs=False):
-    """qkv: (B, L, 3, H, D) -> out: (B, L, H, D)"""
-    q, k, v = qkv.unbind(dim=2)
-    return flash_attn_func(q, k, v, dropout_p=dropout_p, softmax_scale=softmax_scale,
-                           causal=causal)
-
-
-def flash_attn_kvpacked_func(q, kv, dropout_p=0.0, softmax_scale=None, causal=False,
-                              window_size=(-1, -1), softcap=0.0, alibi_slopes=None,
-                              deterministic=False, return_attn_probs=False):
-    """q: (B, Lq, H, D), kv: (B, Lk, 2, H, D) -> out: (B, Lq, H, D)"""
-    k, v = kv.unbind(dim=2)
-    return flash_attn_func(q, k, v, dropout_p=dropout_p, softmax_scale=softmax_scale,
-                           causal=causal)
-
-
-# ---------- varlen ----------
-
-def _varlen_sdpa(q, k, v, cu_seqlens_q, cu_seqlens_k, max_seqlen_q, max_seqlen_k,
-                 causal=False, softmax_scale=None):
-    """
-    q: (total_q, H, D), k: (total_k, H, D), v: (total_k, H, D)
-    cu_seqlens_q/k: (batch+1,) int32
-    Returns: (total_q, H, D)
-    """
-    batch = cu_seqlens_q.shape[0] - 1
-    H = q.shape[1]
-    D = q.shape[2]
-
-    # Fast path: all seqlens are equal (common case)
-    cu_q = cu_seqlens_q.tolist()
-    cu_k = cu_seqlens_k.tolist()
-
-    all_equal = True
-    sq0 = cu_q[1] - cu_q[0]
-    sk0 = cu_k[1] - cu_k[0]
-    for i in range(1, batch):
-        if cu_q[i + 1] - cu_q[i] != sq0 or cu_k[i + 1] - cu_k[i] != sk0:
-            all_equal = False
-            break
-
-    if all_equal and sq0 == max_seqlen_q and sk0 == max_seqlen_k:
-        # Reshape directly – no padding needed
-        q2 = q.reshape(batch, sq0, H, D).transpose(1, 2)   # (B, H, Lq, D)
-        k2 = k.reshape(batch, sk0, H, D).transpose(1, 2)
-        v2 = v.reshape(batch, sk0, H, D).transpose(1, 2)
-        out = _sdpa(q2, k2, v2, causal=causal, softmax_scale=softmax_scale)
-        return out.transpose(1, 2).reshape(-1, H, D)
-
-    # Slow path: unequal lengths – pad, compute, then gather
-    q_padded = q.new_zeros(batch, max_seqlen_q, H, D)
-    k_padded = k.new_zeros(batch, max_seqlen_k, H, D)
-    v_padded = v.new_zeros(batch, max_seqlen_k, H, D)
-
-    for i in range(batch):
-        sq = cu_q[i + 1] - cu_q[i]
-        sk = cu_k[i + 1] - cu_k[i]
-        q_padded[i, :sq] = q[cu_q[i]:cu_q[i + 1]]
-        k_padded[i, :sk] = k[cu_k[i]:cu_k[i + 1]]
-        v_padded[i, :sk] = v[cu_k[i]:cu_k[i + 1]]
-
-    # Create attention mask for padding
-    q_mask = torch.arange(max_seqlen_q, device=q.device).unsqueeze(0)  # (1, Lq)
-    k_mask = torch.arange(max_seqlen_k, device=k.device).unsqueeze(0)  # (1, Lk)
-    q_lens = torch.tensor([cu_q[i + 1] - cu_q[i] for i in range(batch)],
-                          device=q.device).unsqueeze(1)  # (B, 1)
-    k_lens = torch.tensor([cu_k[i + 1] - cu_k[i] for i in range(batch)],
-                          device=k.device).unsqueeze(1)  # (B, 1)
-    # (B, 1, 1, Lk) – True where valid
-    attn_mask = (k_mask < k_lens).unsqueeze(1).unsqueeze(2)
-    # Also mask out query positions that are padding (their output is ignored anyway)
-    # Use float mask: -inf for invalid positions
-    attn_bias = torch.zeros(batch, 1, max_seqlen_q, max_seqlen_k,
-                            device=q.device, dtype=q.dtype)
-    attn_bias.masked_fill_(~attn_mask, float('-inf'))
-
-    if causal:
-        causal_mask = torch.triu(
-            torch.ones(max_seqlen_q, max_seqlen_k, device=q.device, dtype=torch.bool),
-            diagonal=1
-        )
-        attn_bias.masked_fill_(causal_mask.unsqueeze(0).unsqueeze(0), float('-inf'))
-
-    q2 = q_padded.transpose(1, 2)  # (B, H, Lq, D)
-    k2 = k_padded.transpose(1, 2)
-    v2 = v_padded.transpose(1, 2)
-
-    out = F.scaled_dot_product_attention(q2, k2, v2, attn_mask=attn_bias,
-                                         scale=softmax_scale)
-    out = out.transpose(1, 2)  # (B, Lq, H, D)
-
-    # Gather results back to packed format
-    parts = []
-    for i in range(batch):
-        sq = cu_q[i + 1] - cu_q[i]
-        parts.append(out[i, :sq])  # (sq, H, D)
-    return torch.cat(parts, dim=0)
-
-
-def flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_k,
-                           max_seqlen_q, max_seqlen_k,
-                           dropout_p=0.0, softmax_scale=None, causal=False,
-                           window_size=(-1, -1), softcap=0.0, alibi_slopes=None,
-                           deterministic=False, return_attn_probs=False,
-                           block_table=None):
-    """q/k/v: (total, H, D) -> out: (total_q, H, D)"""
-    return _varlen_sdpa(q, k, v, cu_seqlens_q, cu_seqlens_k,
-                        max_seqlen_q, max_seqlen_k,
-                        causal=causal, softmax_scale=softmax_scale)
-
-
-def flash_attn_varlen_qkvpacked_func(qkv, cu_seqlens, max_seqlen,
-                                      dropout_p=0.0, softmax_scale=None, causal=False,
-                                      window_size=(-1, -1), softcap=0.0,
-                                      alibi_slopes=None, deterministic=False,
-                                      return_attn_probs=False):
-    """qkv: (total, 3, H, D) -> out: (total, H, D)"""
-    q, k, v = qkv.unbind(dim=1)
-    return _varlen_sdpa(q, k, v, cu_seqlens, cu_seqlens,
-                        max_seqlen, max_seqlen,
-                        causal=causal, softmax_scale=softmax_scale)
-
-
-def flash_attn_varlen_kvpacked_func(q, kv, cu_seqlens_q, cu_seqlens_k,
-                                     max_seqlen_q, max_seqlen_k,
-                                     dropout_p=0.0, softmax_scale=None, causal=False,
-                                     window_size=(-1, -1), softcap=0.0,
-                                     alibi_slopes=None, deterministic=False,
-                                     return_attn_probs=False):
-    """q: (total_q, H, D), kv: (total_k, 2, H, D) -> out: (total_q, H, D)"""
-    k, v = kv.unbind(dim=1)
-    return _varlen_sdpa(q, k, v, cu_seqlens_q, cu_seqlens_k,
-                        max_seqlen_q, max_seqlen_k,
-                        causal=causal, softmax_scale=softmax_scale)
-
-
-# ---------- with_kvcache (used by some SAM2 code paths) ----------
-
-def flash_attn_with_kvcache(q, k_cache, v_cache, k=None, v=None,
-                            rotary_cos=None, rotary_sin=None,
-                            cache_seqlens=None, cache_batch_idx=None,
-                            block_table=None, softmax_scale=None, causal=False,
-                            window_size=(-1, -1), softcap=0.0,
-                            rotary_interleaved=True, alibi_slopes=None,
-                            num_splits=0, return_softmax_lse=False):
-    """Simplified kv-cache attention fallback."""
-    # Combine current k/v with cache if provided
-    if k is not None:
-        k_full = torch.cat([k_cache, k], dim=1)
-        v_full = torch.cat([v_cache, v], dim=1)
-    else:
-        k_full = k_cache
-        v_full = v_cache
-    return flash_attn_func(q, k_full, v_full, softmax_scale=softmax_scale, causal=causal)

kaolin_stub/kaolin/__init__.py

@@ -1,2 +1 @@
-"""Kaolin stub - minimum API for SAM3D."""
-from . import ops, render, visualize
+"""Kaolin stub — flexicubes only needs utils.testing.check_tensor."""

kaolin_stub/kaolin/ops/__init__.py

@@ -1,2 +0,0 @@
-"""Kaolin ops stub."""
-from . import mesh

kaolin_stub/kaolin/ops/mesh.py

@@ -1 +0,0 @@
-"""Stub."""

kaolin_stub/kaolin/render/__init__.py

@@ -1,2 +0,0 @@
-"""Kaolin render stub."""
-from . import camera

kaolin_stub/kaolin/render/camera.py

@@ -1,22 +0,0 @@
-"""Kaolin camera stub."""
-import torch
-import math
-
-class PinholeIntrinsics:
-    def __init__(self, fov=None, focal_length=None, width=None, height=None, **kwargs):
-        self.fov = fov
-        self.focal_length = focal_length
-        self.width = width
-        self.height = height
-
-class CameraExtrinsics:
-    def __init__(self, view_matrix=None, **kwargs):
-        self.view_matrix = view_matrix
-
-class Camera:
-    def __init__(self, extrinsics=None, intrinsics=None, **kwargs):
-        self.extrinsics = extrinsics
-        self.intrinsics = intrinsics
-    @classmethod
-    def from_args(cls, **kwargs):
-        return cls(**kwargs)

kaolin_stub/kaolin/visualize/__init__.py

@@ -1,4 +0,0 @@
-"""Kaolin visualize stub."""
-class IpyTurntableVisualizer:
-    def __init__(self, *a, **kw): pass
-    def show(self, *a, **kw): pass

pytorch3d_stub/pytorch3d/renderer/camera_utils.py

@@ -1,11 +0,0 @@
-"""pytorch3d.renderer.camera_utils stub."""
-import torch
-
-def camera_to_eye_at_up(camera):
-    """Extract eye, at, up from camera. Minimal stub."""
-    R = camera.R if hasattr(camera, "R") else torch.eye(3).unsqueeze(0)
-    T = camera.T if hasattr(camera, "T") else torch.zeros(1, 3)
-    eye = -torch.bmm(R, T.unsqueeze(-1)).squeeze(-1)
-    at = torch.zeros_like(eye)
-    up = torch.tensor([[0.0, 1.0, 0.0]])
-    return eye, at, up

pytorch3d_stub/pytorch3d/renderer/cameras.py

@@ -1,3 +0,0 @@
-"""pytorch3d.renderer.cameras stub."""
-from pytorch3d.renderer import PerspectiveCameras, CamerasBase
-__all__ = ["PerspectiveCameras", "CamerasBase"]

pytorch3d_stub/pytorch3d/renderer/mesh/__init__.py

@@ -1 +0,0 @@
-from pytorch3d.renderer import TexturesVertex

pytorch3d_stub/pytorch3d/renderer/mesh/textures.py

@@ -1 +0,0 @@
-from pytorch3d.renderer import TexturesVertex

pytorch3d_stub/pytorch3d/vis/__init__.py

@@ -1,17 +0,0 @@
-"""pytorch3d.vis stub."""
-import importlib
-import warnings
-
-def __getattr__(name):
-    if name.startswith("__") and name.endswith("__"):
-        raise AttributeError(name)
-    try:
-        return importlib.import_module(f".{name}", __name__)
-    except ImportError:
-        pass
-    warnings.warn(f"pytorch3d.vis stub: {name} not implemented", stacklevel=2)
-    class _Dummy:
-        def __init__(self, *a, **kw): pass
-        def __call__(self, *a, **kw): return None
-    _Dummy.__name__ = _Dummy.__qualname__ = name
-    return _Dummy

pytorch3d_stub/pytorch3d/vis/plotly_vis.py

@@ -1,42 +0,0 @@
-"""pytorch3d.vis.plotly_vis stub with catch-all."""
-import warnings
-from collections import namedtuple
-
-def __getattr__(name):
-    if name.startswith("__") and name.endswith("__"):
-        raise AttributeError(name)
-    # Return a callable dummy for any missing name
-    def _dummy(*a, **kw): return None
-    _dummy.__name__ = name
-    return _dummy
-
-def plot_scene(plots, **kwargs):
-    return None
-
-def get_camera_wireframe(**kwargs):
-    return None
-
-# These need to be namedtuples with _asdict() support because plot_scene.py calls ._asdict()
-AxisArgs = namedtuple("AxisArgs", ["showgrid", "backgroundcolor", "showticklabels", "tickcolor", "gridcolor", "zeroline"],
-                      defaults=[True, "rgb(230,230,230)", True, "black", "rgb(200,200,200)", False])
-Lighting = namedtuple("Lighting", ["ambient", "diffuse", "specular", "roughness", "fresnel"],
-                      defaults=[0.5, 1.0, 0.3, 0.5, 0.2])
-
-# Explicitly define all private functions that plot_scene imports
-def _add_camera_trace(fig, cameras, trace_name, subplot_idx, ncols, camera_scale, **kw):
-    pass
-
-def _add_pointcloud_trace(fig, pointclouds, trace_name, subplot_idx, ncols, max_points=20000, marker_size=1, **kw):
-    pass
-
-def _add_ray_bundle_trace(fig, ray_bundle, trace_name, subplot_idx, ncols, *a, **kw):
-    pass
-
-def _is_ray_bundle(obj):
-    return False
-
-def _scale_camera_to_bounds(value, vrange, is_position):
-    return value
-
-def _update_axes_bounds(verts_center, max_expand, current_layout):
-    pass

requirements.txt

@@ -1,50 +1,38 @@
-numpy
-Pillow
-trimesh
-hydra-core
-hydra-submitit-launcher
+# torch comes preinstalled from ZeroGPU (whitelisted versions only) — do not pin it here.
+# sam2, MoGe, utils3d and gsplat need torch at install time → installed at startup in app.py.
+torchvision
+
+# config / orchestration
+hydra-core==1.3.2
 omegaconf
-einops
-einops-exts
 loguru
-seaborn
-jaxtyping
-rich
-torchvision
+tqdm
+
+# numerics / imaging
+numpy
+Pillow
 opencv-python-headless
-ninja
-timm
-optree
-roma
-fvcore
-rootutils
+scipy
+matplotlib
 easydict
-scikit-image
-colorama
-ftfy
-astor
-av
-gdown
-deprecation
-orjson
-randomname
-simplejson
-pydot
-igraph
+optree
+
+# model loading (sam3d_objects.model.io uses lightning.pytorch)
+lightning
+safetensors
+huggingface_hub
+
+# 3D geometry / mesh processing
+trimesh
 plyfile
-point-cloud-utils
-pymeshfix
+open3d
 xatlas
-pycocotools
-lightning
-pytorch-lightning
-scipy
 pyvista
-plotly
-kaleido
-webdataset
-wandb
-tensorboard
-sentence-transformers
-accelerate
-safetensors
+pymeshfix
+igraph
+
+# sparse convolution — standalone binary (cumm runtime), independent of torch version
+spconv-cu124==2.3.8
+
+# sam2 runtime dependency
+iopath

sam3d_inference.py

@@ -0,0 +1,60 @@
+"""Minimal SAM 3D Objects inference wrapper.
+
+Replaces upstream notebook/inference.py, whose module-level imports pull in
+kaolin.visualize, SceneVisualizer and plotly — none of which are needed to
+run the pipeline. Import this module only when sam-3d-objects is on sys.path
+and a GPU context is available.
+"""
+import os
+from typing import Optional, Union
+
+import numpy as np
+from PIL import Image
+from omegaconf import OmegaConf
+from hydra.utils import instantiate
+
+import sam3d_objects  # noqa: F401  guarded by LIDRA_SKIP_INIT
+
+# The attention modules read ATTN_BACKEND/SPARSE_ATTN_BACKEND from the
+# environment exactly once, at import time. inference_pipeline's
+# set_attention_backend() flips the env to flash_attn on datacenter GPUs,
+# so the modules must be imported BEFORE the pipeline to stay on sdpa.
+import sam3d_objects.model.backbone.tdfy_dit.modules.attention  # noqa: F401
+import sam3d_objects.model.backbone.tdfy_dit.modules.sparse  # noqa: F401
+
+from sam3d_objects.pipeline.inference_pipeline_pointmap import InferencePipelinePointMap
+
+
+class SAM3DInference:
+    def __init__(self, config_file: str, compile: bool = False):
+        config = OmegaConf.load(config_file)
+        config.rendering_engine = "pytorch3d"  # disable nvdiffrast
+        config.compile_model = compile
+        config.workspace_dir = os.path.dirname(config_file)
+        self._pipeline: InferencePipelinePointMap = instantiate(config)
+
+    @staticmethod
+    def merge_mask_to_rgba(image: np.ndarray, mask: np.ndarray) -> np.ndarray:
+        mask = mask.astype(np.uint8) * 255
+        return np.concatenate([image[..., :3], mask[..., None]], axis=-1)
+
+    def __call__(
+        self,
+        image: Union[Image.Image, np.ndarray],
+        mask: Optional[Union[Image.Image, np.ndarray]],
+        seed: Optional[int] = None,
+        pointmap=None,
+    ) -> dict:
+        image = self.merge_mask_to_rgba(np.asarray(image), np.asarray(mask))
+        return self._pipeline.run(
+            image,
+            None,
+            seed,
+            stage1_only=False,
+            with_mesh_postprocess=False,
+            with_texture_baking=False,
+            with_layout_postprocess=False,
+            use_vertex_color=True,
+            stage1_inference_steps=None,
+            pointmap=pointmap,
+        )