| """S3/HTTPS WebDataset consumer using SpatialEncoder's native geometry code. |
| |
| Shards stream through WebDataset; only the current sample is materialized. |
| Linux memfd handles allow existing PIL/OpenCV readers to seek inside a sample. |
| HDF5 requires a real path and uses a bounded per-sample temporary file instead. |
| Install this module alongside the matching SpatialEncoder checkout. |
| """ |
| from __future__ import annotations |
|
|
| import base64 |
| import copy |
| import json |
| import os |
| import random |
| import re |
| import tempfile |
| from contextlib import contextmanager |
| from pathlib import Path |
|
|
|
|
| def restore_blobs(value): |
| if isinstance(value, dict): |
| if set(value) == {"__bytes_base64__"}: |
| return base64.b64decode(value["__bytes_base64__"], validate=True) |
| return {k: restore_blobs(v) for k, v in value.items()} |
| if isinstance(value, list): |
| return [restore_blobs(v) for v in value] |
| return value |
|
|
|
|
| def header_of(sample): |
| header = restore_blobs(json.loads(sample["meta.json"])) |
| if header.get("schema") != "spatialencoder-wds-native-v1": |
| raise ValueError("Unsupported WDS schema") |
| return header |
|
|
|
|
| @contextmanager |
| def memory_assets(sample): |
| """Suffix-preserving handles; HDF5 alone needs a real temporary file.""" |
| descriptors = [] |
| with tempfile.TemporaryDirectory(prefix="spatial-wds-", dir=os.environ.get("SPATIAL_WDS_TMPDIR")) as directory: |
| paths = {} |
| try: |
| for field, data in sample.items(): |
| if field.startswith("__") or field == "meta.json": |
| continue |
| if not re.fullmatch(r"[a-zA-Z0-9_]+\.[a-zA-Z0-9]+", field): |
| raise ValueError(f"Unsafe asset field: {field}") |
| path = Path(directory) / field |
| if field.endswith(".h5"): |
| |
| |
| |
| path.write_bytes(data) |
| paths[field] = str(path) |
| continue |
| descriptor = os.memfd_create("spatial-wds", flags=os.MFD_CLOEXEC) |
| descriptors.append(descriptor) |
| view = memoryview(data) |
| while view: |
| view = view[os.write(descriptor, view):] |
| path.symlink_to(f"/proc/{os.getpid()}/fd/{descriptor}") |
| paths[field] = str(path) |
| yield Path(directory), paths |
| finally: |
| for descriptor in descriptors: |
| os.close(descriptor) |
|
|
|
|
| def native_instance(header, *, training=True, transforms=None, capture=False, **options): |
| from sam3.train.data.ca1m_dataset import ( |
| _CA1MDatapointMixin, CA1MTrainIterableDataset, DEFAULT_CA1M_EXCLUSION_MANIFEST, |
| ) |
| from sam3.train.data.object_detection_dataset import ObjectDetectionDataset |
| from sam3.train.data.uco3d_dataset import UCO3DDetectionDataset |
| if transforms is None: |
| from sam3.train.transforms.basic_for_api import ToTensorAPI |
| transforms = [ToTensorAPI()] |
| kind = header["kind"] |
| cls = {"object": ObjectDetectionDataset, "ca1m": CA1MTrainIterableDataset, |
| "uco3d": UCO3DDetectionDataset}[kind] |
| instance = cls.__new__(cls) |
| settings = {"resolution": 1024, "resolution_aug_scale": (0.8, 1.2), |
| "min_crop_visible_ratio": 0.2, "spatial_type": "vggt", "spatial_resolution": 518, |
| "exclusion_manifest": DEFAULT_CA1M_EXCLUSION_MANIFEST if kind == "ca1m" else None} |
| settings.update({k:v for k,v in options.items() if k in settings}) |
| _CA1MDatapointMixin.__init__(instance, transforms=[] if transforms is None else transforms, training=training, |
| load_segmentation=True, max_train_queries=100000, max_val_queries=100000, **settings) |
| values = {"predict_metric": True, "use_extrinsic": False, "norm_scale": 2.5, |
| "video_split_per_frame": 15, "frame_num_range": (2, 8), |
| "frame_sample_gap_range": (1, 5), "max_num_objects": 12} |
| values.update(header.get("options", {})) |
| values.update(options) |
| for key, value in values.items(): |
| setattr(instance, key, value) |
| instance.dataset_name = header["dataset"] |
| instance.default_scale = float(header["default_scale"]) |
| instance.base_dir = "" |
| instance.meta_base_dir = None |
| if capture: |
| instance._assemble_clip_datapoint = lambda **kwargs: kwargs |
| return instance |
|
|
|
|
| class SpatialWDSDecoder: |
| """Map raw WDS dictionaries to native training Datapoints. |
| |
| A block owns 64 clip starts plus up to 14 lookahead frames. By default one |
| owned start is sampled uniformly each visit, keeping temporal windows |
| intact. Use iter_block() to enumerate all owned starts for evaluation or an |
| exact clip-coverage pass. Normal native filtering can produce None. |
| """ |
| def __init__(self, training=True, transforms=None, **options): |
| self.training, self.transforms, self.options = training, transforms, options |
|
|
| def __call__(self, sample, start=None, capture=False): |
| header = header_of(sample) |
| instance = native_instance(header, training=self.training, transforms=self.transforms, |
| capture=capture, **self.options) |
| if start is None: |
| start = random.randrange(header.get("owned_starts", 1)) if self.training else 0 |
| if not 0 <= start < header.get("owned_starts", 1): |
| raise ValueError("Start must belong to this sample's owned region") |
| kind = header["kind"] |
| if kind == "ca1m": |
| metadata = header["metadata"] |
| selected = list(metadata["frames"])[start:start + instance.video_split_per_frame] |
| records = [{"ts": r["ts"], "key": r["key"], "data": {"data": sample[r["field"]]}} |
| for r in header["records"] if r["ts"] in selected] |
| frames = instance._sampled_frames_from_webdataset(metadata, records) |
| result = instance._build_train_sample(metadata, frames) |
| else: |
| with memory_assets(sample) as (directory, paths): |
| if kind == "uco3d": |
| sequence = copy.deepcopy(header["sequence"]) |
| sequence["_video_path"] = paths["video.mp4"] |
| sequence["_depth_video_path"] = paths["depth.h5"] |
| instance._sequence_and_frames = lambda _: (sequence, header["box"], header["frames"]) |
| result = instance._load_clip(header["source_id"]) |
| else: |
| metadata = copy.deepcopy(header["metadata"]) |
| original_assemble = instance._assemble_clip_datapoint |
| def assemble_global_start(**kwargs): |
| kwargs["scene_id"] = f"{metadata['scene_id']}_{header['start_frame'] + start}" |
| return original_assemble(**kwargs) |
| instance._assemble_clip_datapoint = assemble_global_start |
| bindings = {source: paths[field] for source, field in header["bindings"].items()} |
| for frame in metadata["frames"].values(): |
| if "wds_tfrecord_binding" in frame: |
| |
| |
| binding = frame.pop("wds_tfrecord_binding") |
| frame["tfrecord_path"] = binding |
| frame["tfrecord_offset"] = 0 |
| instance._resolve_path = lambda original: bindings[original] |
| meta_path = directory / "scene.json" |
| meta_path.write_text(json.dumps(metadata, allow_nan=False)) |
| length = min(instance.video_split_per_frame, header["frame_count"] - start) |
| result = instance._load_frames(header["dataset"], instance.default_scale, |
| str(meta_path), length, start) |
| if result is not None and not capture: |
| result.reference_payload["wds_source"] = { |
| "key": sample.get("__key__"), "url": sample.get("__url__"), |
| "dataset": header["dataset"], "split": header["split"], |
| "source_id": header["source_id"], "start_frame": header.get("start_frame", 0) + start, |
| } |
| return result |
|
|
| def iter_block(self, sample): |
| for start in range(header_of(sample).get("owned_starts", 1)): |
| result = self(sample, start=start) |
| if result is not None: |
| yield result |
|
|
|
|
| def dataset(urls, *, training=True, shuffle_shards=True, **decoder_options): |
| """URLs may be HTTPS, local tar paths, or trusted `pipe:aws s3 cp ... -`.""" |
| import webdataset as wds |
| decoder = SpatialWDSDecoder(training=training, **decoder_options) |
| source = wds.WebDataset(urls, shardshuffle=100 if shuffle_shards else False, |
| nodesplitter=wds.split_by_node, workersplitter=wds.split_by_worker) |
| return source.map(decoder).select(lambda value: value is not None) |
|
|
