Update workspace code without replacing data

encoder/__init__.py

@@ -0,0 +1 @@
+"""Spatial-code encoder package."""

encoder/adapters.py

@@ -15,6 +15,7 @@ of those representations cross this file boundary.
 import gzip
 import os
 import pickle
+import sys
 
 import numpy as np
 
@@ -92,6 +93,74 @@ def _load_masks(path):
     raise FileNotFoundError(f"no SAM3 cache found at {path}")
 
 
+def _load_native_sam3(path):
+    """Decode the raw, per-frame SAM3 image-processor responses without tracking."""
+    try:
+        import torch
+    except ImportError as exc:
+        raise RuntimeError("PyTorch is required to read a raw SAM3 .pt cache") from exc
+    responses = torch.load(path, map_location="cpu", weights_only=False)
+    if not isinstance(responses, list):
+        raise ValueError(f"invalid SAM3 raw cache {path}; expected a response list")
+    class_name = os.environ.get("VSI_SAM3_PROMPT", "object")
+    frames = {}
+    for frame_index, response in enumerate(responses):
+        if not isinstance(response, dict):
+            raise ValueError(
+                f"invalid SAM3 response at frame {frame_index}; expected a dict"
+            )
+        masks = response.get("masks")
+        if masks is None and isinstance(response.get("outputs"), dict):
+            masks = response["outputs"].get("masks")
+        if masks is None:
+            raise ValueError(f"SAM3 response at frame {frame_index} has no masks")
+        masks = masks.detach().cpu().numpy() if hasattr(masks, "detach") else np.asarray(masks)
+        if masks.ndim == 2:
+            masks = masks[None]
+        if masks.ndim == 4 and masks.shape[1] == 1:
+            masks = masks[:, 0]
+        if masks.ndim != 3:
+            raise ValueError(
+                f"SAM3 masks at frame {frame_index} must be [N,H,W], got {masks.shape}"
+            )
+        frames[frame_index] = {
+            object_id: mask.astype(bool) for object_id, mask in enumerate(masks)
+        }
+    return {class_name: frames}
+
+
+def _load_native_da3(path):
+    """Decode DA3's exact pickled Prediction object into projection inputs."""
+    model_root = os.environ.get("VSI_DA3_ROOT", "/root/models/depth-anything-3")
+    source_root = os.path.join(model_root, "src")
+    if source_root not in sys.path:
+        sys.path.insert(0, source_root)
+    with open(path, "rb") as stream:
+        prediction = pickle.load(stream)
+
+    def field(name, required=True):
+        value = getattr(prediction, name, None)
+        if value is None and isinstance(prediction, dict):
+            value = prediction.get(name)
+        if required and value is None:
+            raise ValueError(f"DA3 Prediction in {path} has no {name}")
+        return value
+
+    depth = np.asarray(field("depth"), np.float32)
+    intr = np.asarray(field("intrinsics"), np.float32)
+    extr = np.asarray(field("extrinsics"), np.float32)
+    if extr.shape[-2:] == (3, 4):
+        homogeneous = np.broadcast_to(np.eye(4, dtype=np.float32), extr.shape[:-2] + (4, 4)).copy()
+        homogeneous[..., :3, :] = extr
+        extr = homogeneous
+    if extr.shape[-2:] != (4, 4):
+        raise ValueError(f"DA3 extrinsics must end in [3,4] or [4,4], got {extr.shape}")
+    c2w = np.linalg.inv(extr).astype(np.float32)
+    conf_value = field("conf", required=False)
+    conf = np.asarray(conf_value, np.float32) if conf_value is not None else None
+    return depth, intr, c2w, conf
+
+
 def _backproject(depth, K, c2w, mask, conf=None):
     ys, xs = np.nonzero(mask)
     z = depth[ys, xs]
@@ -105,23 +174,26 @@ def _backproject(depth, K, c2w, mask, conf=None):
     return Xw.astype(np.float32), cf
 
 
-def adapt_da3_sam3(root=None, da3_path=None, sam3_path=None, **_):
-    """Flat DA3 and SAM3 cache files -> the canonical geometry dict."""
+def adapt_da3_sam3(root=None, da3_path=None, sam3_path=None, scene=None, **_):
+    """Fuse raw DA3 geometry and raw per-frame SAM3 masks into canonical geometry."""
+    if root and scene:
+        da3_path = da3_path or os.path.join(root, "depth-anything-3", f"{scene}.pkl")
+        sam3_path = sam3_path or os.path.join(root, "sam3", f"{scene}.pt")
     if da3_path is None:
         da3_path = os.path.join(root, "da3.npz") if root else None
     if sam3_path is None:
         sam3_path = root
     if not da3_path:
         raise ValueError("da3_path is required")
-    d = np.load(da3_path)
-    depth, intr, c2w = d["depth"], d["intr"], d["c2w"]
-    conf = d["conf"] if "conf" in d and d["conf"].size else None
-    ft = (
-        d["frame_times"]
-        if "frame_times" in d
-        else np.arange(len(depth), dtype=np.float32)
-    )
-    per = _load_masks(sam3_path)
+    if str(da3_path).endswith(".pkl"):
+        depth, intr, c2w, conf = _load_native_da3(da3_path)
+        ft = np.arange(len(depth), dtype=np.float32)
+    else:
+        d = np.load(da3_path)
+        depth, intr, c2w = d["depth"], d["intr"], d["c2w"]
+        conf = d["conf"] if "conf" in d and d["conf"].size else None
+        ft = d["frame_times"] if "frame_times" in d else np.arange(len(depth), dtype=np.float32)
+    per = _load_native_sam3(sam3_path) if str(sam3_path).endswith(".pt") else _load_masks(sam3_path)
     instances, stats = {}, {}
     for cls, frames in per.items():
         by_id = {}
@@ -198,16 +270,106 @@ def adapt_da3_sam3(root=None, da3_path=None, sam3_path=None, **_):
 # ==========================================================================================
 
 
-def adapt_segvggt(root=None, path=None, **_):
-    """Translate an existing SegVGGT NPZ export to canonical geometry."""
-    path = path or root
+SEGVGGT_CLASSES = """wall|floor|chair|table|door|couch|cabinet|shelf|desk|office chair|bed|pillow|sink|picture|window|toilet|bookshelf|monitor|curtain|book|armchair|coffee table|box|refrigerator|lamp|kitchen cabinet|towel|clothes|tv|nightstand|counter|dresser|stool|cushion|plant|ceiling|bathtub|end table|dining table|keyboard|bag|backpack|toilet paper|printer|tv stand|whiteboard|blanket|shower curtain|trash can|closet|stairs|microwave|stove|shoe|computer tower|bottle|bin|ottoman|bench|board|washing machine|mirror|copier|basket|sofa chair|file cabinet|fan|laptop|shower|paper|person|paper towel dispenser|oven|blinds|rack|plate|blackboard|piano|suitcase|rail|radiator|recycling bin|container|wardrobe|soap dispenser|telephone""".split("|")
+
+
+def _decode_segvggt_raw(path):
+    """Decode the official SegVGGT.forward tensor dictionary for this adapter."""
+    import sys
+
+    try:
+        import torch
+        import torch.nn.functional as functional
+    except ImportError as exc:
+        raise RuntimeError("PyTorch is required to read a SegVGGT .pt cache") from exc
+
+    model_root = os.environ.get("VSI_SEGVGGT_ROOT", "/root/models/SegVGGT")
+    if model_root not in sys.path:
+        sys.path.insert(0, model_root)
+    try:
+        from eval.instance_eval_common import predict_by_feat_instance
+        from segvggt.utils.pose_enc import pose_encoding_to_extri_intri
+    except ImportError as exc:
+        raise RuntimeError(
+            "SegVGGT is required to decode its native prediction dictionary"
+        ) from exc
+
+    raw = torch.load(path, map_location="cpu", weights_only=False)
+    required = {"world_points", "instance_maps", "instance_labels", "pose_enc"}
+    if not isinstance(raw, dict) or not required.issubset(raw):
+        missing = sorted(required - set(raw)) if isinstance(raw, dict) else sorted(required)
+        raise ValueError(f"invalid SegVGGT raw cache {path}; missing keys: {missing}")
+
+    logits = raw["instance_maps"][0]
+    query_count, frame_total, height, width = logits.shape
+    masks, label_ids, _ = predict_by_feat_instance(
+        raw["instance_labels"][0],
+        logits.reshape(query_count, -1),
+        mask_thr=float(os.environ.get("VSI_MASK_THR", "0.4")),
+        npoint_thr=1,
+    )
+    masks = masks.reshape(-1, frame_total, height, width).cpu().numpy()
+    label_ids = label_ids.cpu().numpy()
+    keep = [index for index, label in enumerate(label_ids) if int(label) >= 2]
+
+    world = raw["world_points"][0].float()
+    if tuple(world.shape[1:3]) != (height, width):
+        world = (
+            functional.interpolate(
+                world.permute(0, 3, 1, 2),
+                (height, width),
+                mode="nearest",
+            )
+            .permute(0, 2, 3, 1)
+        )
+    world = world.cpu().numpy()
+
+    if "images" in raw:
+        image_size = raw["images"].shape[-2:]
+    elif "depth" in raw:
+        image_size = raw["depth"].shape[2:4]
+    else:
+        image_size = (height, width)
+    extrinsics, _ = pose_encoding_to_extri_intri(
+        raw["pose_enc"].float(), image_size
+    )
+    extrinsics = extrinsics[0].cpu().numpy()
+    rotations = extrinsics[:, :3, :3]
+    translations = extrinsics[:, :3, 3]
+    cameras = -np.einsum("sji,sj->si", rotations, translations)
+    labels = np.asarray(
+        [
+            SEGVGGT_CLASSES[int(label_ids[index])]
+            if int(label_ids[index]) < len(SEGVGGT_CLASSES)
+            else f"class {int(label_ids[index])}"
+            for index in keep
+        ],
+        dtype=object,
+    )
+    return {
+        "world_points": world,
+        "instance_masks": masks[keep].astype(bool),
+        "labels": labels,
+        "camera_positions": cameras.astype(np.float32),
+    }
+
+
+def adapt_segvggt(root=None, path=None, scene=None, **_):
+    """Translate a raw-preserving SegVGGT cache to canonical geometry."""
+    if path is None and root and scene:
+        path = os.path.join(root, "segvggt", f"{scene}.pt")
+    else:
+        path = path or root
     if path is None:
         raise ValueError("SegVGGT cache path is required")
     if os.path.isdir(path):
-        path = os.path.join(path, "geometry.npz")
+        path = os.path.join(path, f"{scene}.pt" if scene else "geometry.pt")
     if not os.path.exists(path):
         raise FileNotFoundError(f"SegVGGT raw cache does not exist: {path}")
-    d = np.load(path, allow_pickle=True)
+    if str(path).endswith(".pt"):
+        d = _decode_segvggt_raw(path)
+    else:
+        d = np.load(path, allow_pickle=True)
     world, masks = (
         np.asarray(d["world_points"], np.float32),
         np.asarray(d["instance_masks"], bool),
@@ -256,3 +418,24 @@ def adapt_segvggt(root=None, path=None, **_):
             "cameras": d["camera_positions"] if "camera_positions" in d else None,
         }
     )
+
+
+RAW_ADAPTERS = {
+    "da3_sam3": adapt_da3_sam3,
+    "segvggt": adapt_segvggt,
+}
+
+
+def available_models():
+    """Return raw model formats supported by the encoder."""
+    return tuple(sorted(RAW_ADAPTERS))
+
+
+def adapt(model, **raw_cache):
+    """Dispatch one model's native cache to its isolated format adapter."""
+    adapter = RAW_ADAPTERS.get(model)
+    if adapter is None:
+        raise KeyError(
+            f"no raw encoder adapter for {model!r}; expected one of {available_models()}"
+        )
+    return validate(adapter(**raw_cache))

encoder/config.py

@@ -13,15 +13,11 @@ DATA_ROOT = Path(os.environ.get("VSI_DATA_ROOT", "/workspace/data"))
 VSI_ROOT = Path(os.environ.get("VSI_ROOT", "/root/data/VSI-Bench"))
 JSONL = Path(os.environ.get("VSI_JSONL", VSI_ROOT / "test.jsonl"))
 CACHE_ROOT = Path(os.environ.get("VSI_CACHE_ROOT", "/root/data/caches"))
-CODES_ROOT = Path(os.environ.get("VSI_CODES", DATA_ROOT / "spatial codes"))
+CODES_ROOT = Path(
+    os.environ.get("VSI_CODES", DATA_ROOT / "spatial codes" / "segvggt")
+)
 VIDEO_DATASETS = ("scannet", "scannetpp", "arkitscenes")
 
-ADAPTERS = {
-    "da3_sam3": "adapt_da3_sam3",
-    "segvggt": "adapt_segvggt",
-}
-
-
 def video_path(scene: str, dataset: str | None = None) -> str:
     """Return the unique MP4 for ``scene`` from the VSI-Bench dataset folders."""
     scene = str(scene)
@@ -56,15 +52,15 @@ def cache_file(scene: str, model: str | None = None) -> str:
 
 
 def segvggt_cache_file(scene: str, model: str | None = None) -> str:
-    return str(Path(model_cache_dir(model or "segvggt")) / f"{scene}.npz")
+    return str(Path(model_cache_dir(model or "segvggt")) / f"{scene}.pt")
 
 
 def da3_cache_file(scene: str, model: str | None = None) -> str:
-    return str(Path(model_cache_dir(model or "da3_sam3")) / f"{scene}.da3.npz")
+    return str(Path(model_cache_dir(model or "depth-anything-3")) / f"{scene}.pkl")
 
 
 def sam3_cache_file(scene: str, model: str | None = None) -> str:
-    return str(Path(model_cache_dir(model or "da3_sam3")) / f"{scene}.sam3.pkl.gz")
+    return str(Path(model_cache_dir(model or "sam3")) / f"{scene}.pt")
 
 
 def spatial_code_path(scene: str) -> str:

encoder/geometric.py

@@ -179,12 +179,19 @@ def room_gravity(
 
 
 def pos3(rec):
-    """[floor_x, floor_y, height_above_floor] from a spatial-code instance record's named position."""
+    """Read either legacy numeric or current unit-string position formatting."""
     p = rec.get("position") or {}
+
+    def meters(current, legacy):
+        value = p.get(current, p.get(legacy, 0.0))
+        if isinstance(value, str):
+            value = value.removesuffix(" meters").strip()
+        return float(value)
+
     return [
-        p.get("floor_x_meters", 0.0),
-        p.get("floor_y_meters", 0.0),
-        p.get("height_above_floor_meters", 0.0),
+        meters("x coordinate", "floor_x_meters"),
+        meters("y coordinate", "floor_y_meters"),
+        meters("height above floor", "height_above_floor_meters"),
     ]
 
 
@@ -210,6 +217,26 @@ def _floor_basis(up_vec):
     return u, v, g
 
 
+def _floor_level(points, gravity, v2=None):
+    """Reference floor estimator shared by every model representation.
+
+    The supplied geometry uses the densest gravity-height slab for its reproducible v1
+    behavior and the robust second percentile for v2.  Keep that switch here, after model
+    adapters have produced world points, so it cannot become model-specific.
+    """
+    heights = np.asarray(points, np.float64) @ np.asarray(gravity, np.float64)
+    heights = heights[np.isfinite(heights)]
+    if not len(heights):
+        return 0.0
+    if v2 is None:
+        v2 = os.environ.get("VSI_CODE_V2") == "1"
+    if v2:
+        return float(np.percentile(heights, 2))
+    counts, edges = np.histogram(heights, bins=80)
+    index = int(counts.argmax())
+    return float(0.5 * (edges[index] + edges[index + 1]))
+
+
 def _object_records(insts, count, u, v, g, floor_level):
     """Up to `count` instances, strongest-evidence first (most observed points = best-segmented,
     closest, most geometry). `count` (peak co-visibility) decides HOW MANY; total observed points
@@ -1114,8 +1141,7 @@ def build_spatial_code_raw(depth, intr, c2w, conf, ftimes, per):
         up_vec
     )  # shared gravity floor frame (bu,bv horizontal, bg up)
     P = np.concatenate([i["pts"] for cl in inst.values() for i in cl], 0)
-    # floor = robust bottom of observed geometry along gravity (low percentile).
-    floor_level = float(np.percentile(P @ bg, 2))
+    floor_level = _floor_level(P, bg)
     fa = compute_floor_area(depth, intr, c2w, conf, None, up_vec=up_vec)
     code = to_spatial_code(inst, stats, fa, up_ax, up_vec, floor_level)
     cls = list(inst.keys())
@@ -1473,7 +1499,7 @@ def build_spatial_code(scene):
     all_points = np.concatenate(
         [i["pts"] for values in inst.values() for i in values], 0
     )
-    floor_level = float(np.percentile(all_points @ g, 2))
+    floor_level = _floor_level(all_points, g)
     objects = {}
     for cls, items in inst.items():
         requested_count = max(0, int(stats[cls].get("peak", len(items))))

encoder/launch.py

@@ -8,10 +8,16 @@ import argparse
 import json
 import multiprocessing as mp
 import os
+from pathlib import Path
 import subprocess
+import sys
 import traceback
 
-import config as C
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from encoder import config as C
 
 
 def _scenes():
@@ -39,7 +45,7 @@ def _visible_gpus():
 def _worker(task_queue, result_queue, model, rebuild, gpu):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
-    import render
+    from encoder import render
 
     while True:
         scene = task_queue.get()

encoder/render.py

@@ -4,9 +4,9 @@ from __future__ import annotations
 
 import os
 
-import config as C
-import geometric as geometry_math
-import run as perceive
+from encoder import config as C
+from encoder import geometric as geometry_math
+from encoder import run as perceive
 
 
 def build_spatial_code_for(scene, model=None, rebuild=False):

encoder/run.py

@@ -5,22 +5,16 @@ from __future__ import annotations
 import argparse
 import gzip
 import os
+from pathlib import Path
 import pickle
+import sys
 
-import adapters
-import config as C
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
 
-
-def _adapter_kwargs(scene: str, model: str) -> dict:
-    if model == "segvggt":
-        return {"scene": scene, "path": C.segvggt_cache_file(scene, model)}
-    if model == "da3_sam3":
-        return {
-            "scene": scene,
-            "da3_path": C.da3_cache_file(scene, model),
-            "sam3_path": C.sam3_cache_file(scene, model),
-        }
-    return {"scene": scene, "root": C.model_cache_dir(model)}
+from encoder import adapters
+from encoder import config as C
 
 
 def cache_or_load(scene: str, model: str | None = None, rebuild: bool = False):
@@ -31,12 +25,12 @@ def cache_or_load(scene: str, model: str | None = None, rebuild: bool = False):
         with gzip.open(path, "rb") as f:
             return adapters.validate(pickle.load(f)), "loaded"
 
-    adapter_name = C.ADAPTERS.get(model)
-    if adapter_name is None:
-        raise KeyError(f"no adapter configured for {model!r}")
-    kwargs = _adapter_kwargs(scene, model)
-    kwargs["rebuild"] = rebuild
-    geometry = adapters.validate(getattr(adapters, adapter_name)(**kwargs))
+    geometry = adapters.adapt(
+        model,
+        scene=scene,
+        root=str(C.CACHE_ROOT),
+        rebuild=rebuild,
+    )
     os.makedirs(os.path.dirname(path), exist_ok=True)
     with gzip.open(path, "wb") as f:
         pickle.dump(geometry, f, protocol=pickle.HIGHEST_PROTOCOL)
@@ -54,7 +48,7 @@ def main() -> None:
     print(
         f"[{a.scene}] model={a.model} cache={how} classes={len(geometry['instances'])} instances={count}"
     )
-    import render
+    from encoder import render
 
     _, _, path = render.write_spatial_code_for(a.scene, a.model, False)
     print(f"[{a.scene}] spatial_code={path}")

inference/__init__.py

@@ -1 +1,40 @@
-"""Model inference that produces raw geometry caches for the encoder."""
+"""Self-contained configuration and helpers for model inference."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+FRAMES_PER_VIDEO = int(os.environ.get("VSI_FRAMES_PER_VIDEO", "32"))
+VSI_ROOT = Path(os.environ.get("VSI_ROOT", "/root/data/VSI-Bench"))
+JSONL = Path(os.environ.get("VSI_JSONL", VSI_ROOT / "test.jsonl"))
+CACHE_ROOT = Path(os.environ.get("VSI_CACHE_ROOT", "/root/data/caches"))
+VIDEO_DATASETS = ("scannet", "scannetpp", "arkitscenes")
+
+
+def video_path(scene: str, dataset: str | None = None) -> str:
+    """Return the unique VSI-Bench video for a scene."""
+    scene = str(scene)
+    datasets = (dataset,) if dataset else VIDEO_DATASETS
+    matches: list[Path] = []
+    for name in datasets:
+        if name not in VIDEO_DATASETS:
+            raise ValueError(
+                f"unknown VSI dataset {name!r}; expected one of {VIDEO_DATASETS}"
+            )
+        candidate = VSI_ROOT / name / f"{scene}.mp4"
+        if candidate.is_file():
+            matches.append(candidate)
+    if not matches:
+        searched = ", ".join(str(VSI_ROOT / name / f"{scene}.mp4") for name in datasets)
+        raise FileNotFoundError(
+            f"video for scene {scene!r} not found; searched: {searched}"
+        )
+    if len(matches) > 1:
+        raise RuntimeError(f"scene {scene!r} exists in multiple datasets: {matches}")
+    return str(matches[0])
+
+
+def model_cache_dir(model: str) -> str:
+    """Return the inference cache directory for a model."""
+    return str(CACHE_ROOT / model)

inference/adapters.py

@@ -1,10 +1,11 @@
-"""Model-specific inference adapters that write encoder-compatible raw caches."""
+"""Model-specific inference adapters that preserve native outputs in model caches."""
 
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
 import os
 from pathlib import Path
+import pickle
 import sys
 
 import numpy as np
@@ -13,7 +14,7 @@ import numpy as np
 class InferenceAdapter(ABC):
     """Common interface implemented by every inference backend."""
 
-    output_suffix = ".npz"
+    output_suffix: str
 
     @abstractmethod
     def load_model(self, device: str) -> None:
@@ -21,11 +22,13 @@ class InferenceAdapter(ABC):
 
     @abstractmethod
     def run_scene(self, video_path: str, output_path: str, frame_count: int) -> None:
-        """Run one video and atomically write a raw encoder cache."""
+        """Run one video and atomically preserve the model's native output."""
 
 
 class SegVGGTAdapter(InferenceAdapter):
-    """SegVGGT inference producing the NPZ fields consumed by encoder/adapters.py."""
+    """SegVGGT inference preserving native tensors plus derived encoder geometry."""
+
+    output_suffix = ".pt"
 
     classes = """wall|floor|chair|table|door|couch|cabinet|shelf|desk|office chair|bed|pillow|sink|picture|window|toilet|bookshelf|monitor|curtain|book|armchair|coffee table|box|refrigerator|lamp|kitchen cabinet|towel|clothes|tv|nightstand|counter|dresser|stool|cushion|plant|ceiling|bathtub|end table|dining table|keyboard|bag|backpack|toilet paper|printer|tv stand|whiteboard|blanket|shower curtain|trash can|closet|stairs|microwave|stove|shoe|computer tower|bottle|bin|ottoman|bench|board|washing machine|mirror|copier|basket|sofa chair|file cabinet|fan|laptop|shower|paper|person|paper towel dispenser|oven|blinds|rack|plate|blackboard|piano|suitcase|rail|radiator|recycling bin|container|wardrobe|soap dispenser|telephone""".split(
         "|"
@@ -52,15 +55,8 @@ class SegVGGTAdapter(InferenceAdapter):
         sys.path.insert(0, str(self.model_root))
         try:
             import torch
-            import torch.nn.functional as functional
-            from eval.instance_eval_common import predict_by_feat_instance
             from hydra import compose, initialize_config_dir
             from hydra.utils import instantiate
-            from segvggt.utils.geometry import (
-                closed_form_inverse_se3,
-                unproject_depth_map_to_point_map,
-            )
-            from segvggt.utils.pose_enc import pose_encoding_to_extri_intri
         except ImportError as exc:
             raise RuntimeError(
                 f"missing SegVGGT dependency ({exc}); install {self.model_root}/requirements.txt"
@@ -84,14 +80,7 @@ class SegVGGTAdapter(InferenceAdapter):
             state["model"] if "model" in state else state, strict=False
         )
         self.model = model.to(self.device).to(self.dtype).eval()
-        self.runtime = (
-            torch,
-            functional,
-            predict_by_feat_instance,
-            unproject_depth_map_to_point_map,
-            closed_form_inverse_se3,
-            pose_encoding_to_extri_intri,
-        )
+        self.runtime = torch
 
     @staticmethod
     def _read_video(path, frame_count):
@@ -131,8 +120,8 @@ class SegVGGTAdapter(InferenceAdapter):
     def run_scene(self, video_path, output_path, frame_count):
         if self.model is None or self.runtime is None:
             raise RuntimeError("load_model() must be called before run_scene()")
-        torch, functional, predict, unproject, inverse, decode_pose = self.runtime
-        frames, times = self._read_video(video_path, frame_count)
+        torch = self.runtime
+        frames, _ = self._read_video(video_path, frame_count)
         images = (
             torch.from_numpy(frames)
             .permute(0, 3, 1, 2)
@@ -146,58 +135,181 @@ class SegVGGTAdapter(InferenceAdapter):
             torch.autocast(device_type=self.device.type, dtype=self.dtype),
         ):
             prediction = self.model(images)
-        logits = prediction["instance_maps"][0]
-        query_count, frame_total, height, width = logits.shape
-        masks, labels, _ = predict(
-            prediction["instance_labels"][0],
-            logits.reshape(query_count, -1),
-            mask_thr=float(os.environ.get("VSI_MASK_THR", "0.4")),
-            npoint_thr=1,
-        )
-        masks = masks.reshape(-1, frame_total, height, width).detach().cpu().numpy()
-        labels = labels.detach().cpu().numpy()
-        depth = prediction["depth"][0].float().cpu()
-        extrinsics, intrinsics = decode_pose(
-            prediction["pose_enc"].float(), depth.shape[1:3]
+        raw_prediction = _to_cpu(prediction)
+        output = Path(output_path)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        temporary = output.with_suffix(output.suffix + ".tmp")
+        torch.save(raw_prediction, temporary)
+        os.replace(temporary, output)
+
+
+def _to_cpu(value):
+    """Move tensors to CPU without changing dtype, shape, or nested structure."""
+    if hasattr(value, "detach") and hasattr(value, "cpu"):
+        return value.detach().cpu()
+    if isinstance(value, dict):
+        return {key: _to_cpu(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_to_cpu(item) for item in value]
+    if isinstance(value, tuple):
+        return tuple(_to_cpu(item) for item in value)
+    return value
+
+
+class DepthAnything3Adapter(InferenceAdapter):
+    """Run DA3's official API and preserve its native Prediction object."""
+
+    output_suffix = ".pkl"
+
+    def __init__(self, model_root=None, checkpoint=None):
+        self.model_root = Path(
+            model_root
+            or os.environ.get(
+                "VSI_DA3_ROOT", "/root/models/depth-anything-3"
+            )
         )
-        extrinsics = extrinsics[0].detach().cpu().numpy()
-        intrinsics = intrinsics[0].detach().cpu().numpy()
-        world = unproject(depth.numpy(), extrinsics, intrinsics)
-        world = (
-            functional.interpolate(
-                torch.from_numpy(world).permute(0, 3, 1, 2),
-                (height, width),
-                mode="nearest",
+        self.checkpoint = Path(
+            checkpoint
+            or os.environ.get(
+                "VSI_DA3_CHECKPOINT",
+                self.model_root / "checkpoints" / "DA3-LARGE-1.1",
             )
-            .permute(0, 2, 3, 1)
-            .numpy()
         )
-        cameras = inverse(extrinsics)[:, :3, 3]
-        keep = [index for index, label in enumerate(labels) if int(label) >= 2]
-        names = np.asarray(
-            [
-                self.classes[int(labels[index])]
-                if int(labels[index]) < len(self.classes)
-                else f"class {int(labels[index])}"
-                for index in keep
-            ],
-            dtype=object,
+        self.model = self.device = None
+
+    def load_model(self, device: str) -> None:
+        source_root = self.model_root / "src"
+        if not source_root.is_dir():
+            raise FileNotFoundError(
+                f"Depth Anything 3 repository not found: {self.model_root}"
+            )
+        if not self.checkpoint.is_dir():
+            raise FileNotFoundError(
+                f"Depth Anything 3 checkpoint not found: {self.checkpoint}"
+            )
+        if str(source_root) not in sys.path:
+            sys.path.insert(0, str(source_root))
+        try:
+            from depth_anything_3.api import DepthAnything3
+        except ImportError as exc:
+            raise RuntimeError(
+                f"missing Depth Anything 3 dependency ({exc}); "
+                f"install {self.model_root}"
+            ) from exc
+        self.device = device
+        self.model = DepthAnything3.from_pretrained(
+            str(self.checkpoint), local_files_only=True
+        ).to(device)
+
+    @staticmethod
+    def _read_video(path, frame_count):
+        import cv2
+
+        capture = cv2.VideoCapture(path)
+        if not capture.isOpened():
+            raise RuntimeError(f"cannot open video: {path}")
+        try:
+            total = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
+            if total < frame_count:
+                raise ValueError(
+                    f"{path} has {total} frames; {frame_count} are required"
+                )
+            frames = []
+            for index in np.linspace(0, total - 1, frame_count, dtype=int):
+                capture.set(cv2.CAP_PROP_POS_FRAMES, int(index))
+                ok, frame = capture.read()
+                if not ok:
+                    raise RuntimeError(f"failed reading frame {index} from {path}")
+                frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+            return frames
+        finally:
+            capture.release()
+
+    def run_scene(self, video_path, output_path, frame_count):
+        if self.model is None:
+            raise RuntimeError("load_model() must be called before run_scene()")
+        prediction = self.model.inference(
+            self._read_video(video_path, frame_count),
+            export_dir=None,
         )
         output = Path(output_path)
         output.parent.mkdir(parents=True, exist_ok=True)
-        temporary = output.with_suffix(output.suffix + ".tmp.npz")
-        np.savez_compressed(
-            temporary,
-            world_points=world.astype(np.float32),
-            instance_masks=masks[keep].astype(bool),
-            labels=names,
-            frame_times=times,
-            camera_positions=cameras.astype(np.float32),
+        temporary = output.with_suffix(output.suffix + ".tmp")
+        with open(temporary, "wb") as stream:
+            pickle.dump(prediction, stream, protocol=pickle.HIGHEST_PROTOCOL)
+        os.replace(temporary, output)
+
+
+class SAM3Adapter(InferenceAdapter):
+    """Run SAM3 independently on sampled images, with no video tracking."""
+
+    output_suffix = ".pt"
+
+    def __init__(self, model_root=None, checkpoint=None, prompt=None):
+        self.model_root = Path(
+            model_root or os.environ.get("VSI_SAM3_ROOT", "/root/models/sam3")
         )
+        self.checkpoint = Path(
+            checkpoint
+            or os.environ.get(
+                "VSI_SAM3_CHECKPOINT",
+                self.model_root / "checkpoints" / "sam3.pt",
+            )
+        )
+        self.prompt = prompt or os.environ.get("VSI_SAM3_PROMPT", "object")
+        self.model = self.processor = self.runtime = None
+
+    def load_model(self, device: str) -> None:
+        if not self.model_root.is_dir():
+            raise FileNotFoundError(f"SAM3 repository not found: {self.model_root}")
+        if not self.checkpoint.is_file():
+            raise FileNotFoundError(f"SAM3 checkpoint not found: {self.checkpoint}")
+        if str(self.model_root) not in sys.path:
+            sys.path.insert(0, str(self.model_root))
+        try:
+            import torch
+            from sam3.model.sam3_image_processor import Sam3Processor
+            from sam3.model_builder import build_sam3_image_model
+        except ImportError as exc:
+            raise RuntimeError(
+                f"missing SAM3 dependency ({exc}); install {self.model_root}"
+            ) from exc
+        self.runtime = torch
+        self.model = build_sam3_image_model(
+            checkpoint_path=str(self.checkpoint),
+            load_from_HF=False,
+            device=device,
+            eval_mode=True,
+            enable_segmentation=True,
+        )
+        self.processor = Sam3Processor(self.model)
+
+    def run_scene(self, video_path, output_path, frame_count):
+        if self.model is None or self.processor is None or self.runtime is None:
+            raise RuntimeError("load_model() must be called before run_scene()")
+        from PIL import Image
+
+        frames = DepthAnything3Adapter._read_video(video_path, frame_count)
+        raw_outputs = []
+        with self.runtime.inference_mode():
+            for frame in frames:
+                state = self.processor.set_image(Image.fromarray(frame))
+                raw_outputs.append(
+                    self.processor.set_text_prompt(state=state, prompt=self.prompt)
+                )
+        raw_outputs = _to_cpu(raw_outputs)
+        output = Path(output_path)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        temporary = output.with_suffix(output.suffix + ".tmp")
+        self.runtime.save(raw_outputs, temporary)
         os.replace(temporary, output)
 
 
-_ADAPTERS = {"segvggt": SegVGGTAdapter}
+_ADAPTERS = {
+    "depth-anything-3": DepthAnything3Adapter,
+    "sam3": SAM3Adapter,
+    "segvggt": SegVGGTAdapter,
+}
 
 
 def available_models():
@@ -213,3 +325,13 @@ def get_adapter(model, **config):
             f"unknown inference model {model!r}; expected one of {available_models()}"
         )
     return adapter_type(**config)
+
+
+def output_suffix(model):
+    """Return the native cache suffix owned by a registered model adapter."""
+    adapter_type = _ADAPTERS.get(model)
+    if adapter_type is None:
+        raise KeyError(
+            f"unknown inference model {model!r}; expected one of {available_models()}"
+        )
+    return adapter_type.output_suffix

inference/launch.py

@@ -14,13 +14,11 @@ import traceback
 
 HERE = Path(__file__).resolve().parent
 WORKSPACE_ROOT = HERE.parent
-ENCODER_ROOT = WORKSPACE_ROOT / "encoder"
-for path in (WORKSPACE_ROOT, ENCODER_ROOT):
-    if str(path) not in sys.path:
-        sys.path.insert(0, str(path))
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
 
+import inference as inference_config  # noqa: E402
 from inference import adapters  # noqa: E402
-import config as encoder_config  # noqa: E402
 
 
 def _load_run_module():
@@ -33,7 +31,7 @@ def _load_run_module():
 
 def scenes():
     """Return unique manifest scenes in their original order."""
-    with open(encoder_config.JSONL) as manifest:
+    with open(inference_config.JSONL) as manifest:
         return list(
             dict.fromkeys(str(json.loads(line)["scene_name"]) for line in manifest)
         )
@@ -94,7 +92,7 @@ def main():
     parser.add_argument(
         "--model", default="segvggt", choices=adapters.available_models()
     )
-    parser.add_argument("--frames", type=int, default=encoder_config.FRAMES_PER_VIDEO)
+    parser.add_argument("--frames", type=int, default=inference_config.FRAMES_PER_VIDEO)
     parser.add_argument("--rebuild", action="store_true")
     args = parser.parse_args()
     selected = [args.scene] if args.scene else scenes()

inference/run.py

@@ -6,34 +6,34 @@ import argparse
 from pathlib import Path
 import sys
 
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent
-ENCODER_ROOT = WORKSPACE_ROOT / "encoder"
-for path in (WORKSPACE_ROOT, ENCODER_ROOT):
-    if str(path) not in sys.path:
-        sys.path.insert(0, str(path))
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
 
+import inference as inference_config  # noqa: E402
 from inference import adapters  # noqa: E402
-import config as encoder_config  # noqa: E402
 
 
 def output_path(scene, model):
-    """Return the flat raw-cache path for one scene and model."""
-    return str(Path(encoder_config.model_cache_dir(model)) / f"{scene}.npz")
+    """Return the adapter-owned raw-cache path for one scene and model."""
+    suffix = adapters.output_suffix(model)
+    return str(Path(inference_config.model_cache_dir(model)) / f"{scene}{suffix}")
 
 
 def run_scene(
     scene, model="segvggt", frame_count=None, rebuild=False, adapter=None, device=None
 ):
     """Run one scene, optionally reusing an adapter already loaded by a batch worker."""
+    owns_adapter = adapter is None
+    if owns_adapter:
+        adapter = adapters.get_adapter(model)
     destination = output_path(scene, model)
     if Path(destination).is_file() and not rebuild:
         return "skipped", destination
-    frame_count = frame_count or encoder_config.FRAMES_PER_VIDEO
-    if adapter is None:
-        adapter = adapters.get_adapter(model)
+    frame_count = frame_count or inference_config.FRAMES_PER_VIDEO
+    if owns_adapter:
         adapter.load_model(device or "cuda")
-    adapter.run_scene(encoder_config.video_path(scene), destination, frame_count)
+    adapter.run_scene(inference_config.video_path(scene), destination, frame_count)
     return "built", destination
 
 
@@ -43,7 +43,7 @@ def main():
     parser.add_argument(
         "--model", default="segvggt", choices=adapters.available_models()
     )
-    parser.add_argument("--frames", type=int, default=encoder_config.FRAMES_PER_VIDEO)
+    parser.add_argument("--frames", type=int, default=inference_config.FRAMES_PER_VIDEO)
     parser.add_argument("--device", default="cuda")
     parser.add_argument("--rebuild", action="store_true")
     args = parser.parse_args()