"""Read sparse PointZero WebDataset shards without extracting any files. Training intentionally samples with replacement, as the original PointZero weighted dataset does. Evaluation traverses each shard exactly once globally. """ import io import json import multiprocessing from pathlib import Path import random import tarfile import numpy as np from PIL import Image import torch COMPONENT_WEIGHTS = { 'shorts_v7': 0.33, 'tshirt_v7': 0.33, 'towel_v7': 0.33, 'genesis_partnet_50k': 1.0, 'kubric_50k_v2': 0.33, } def image_tensor(blob): with Image.open(io.BytesIO(blob)) as image: array = np.array(image) if array.ndim == 2: array = array[None] else: array = array.transpose(2, 0, 1) return torch.from_numpy(array) def decode_sample(sample, load_images=True): metadata = json.loads(sample['json']) result = {'points': torch.from_numpy(np.load(io.BytesIO(sample['points.npy']), allow_pickle=False)), 'graspers': None, 'dirs': np.array(metadata['timestep_names']), 'pred_dir': metadata['key']} if 'graspers.npy' in sample: result['graspers'] = torch.from_numpy(np.load(io.BytesIO(sample['graspers.npy']), allow_pickle=False)) if load_images: result['rgb'] = image_tensor(sample['rgb_000.png']).unsqueeze(0) result['segmentation'] = (image_tensor(sample['segmentation_000.png']).unsqueeze(0) > 0).bool() return {'current_scene': result, 'context': {}} def iter_shard(path, all_images=False): """Iterate adjacent WebDataset members; retain only conditioning images by default.""" key = None sample = {} wanted = {'points.npy', 'graspers.npy', 'json', 'rgb_000.png', 'segmentation_000.png'} with tarfile.open(path, 'r|') as archive: for member in archive: if not member.isfile(): raise ValueError(f'Unexpected member: {member.name}') current, suffix = member.name.split('.', 1) if current != key: if sample: yield sample key, sample = current, {'__key__': current} if suffix in wanted or all_images: sample[suffix] = archive.extractfile(member).read() if sample: yield sample class PointZeroShardDataset(torch.utils.data.IterableDataset): """Local-shard training adapter with distributed/worker-aware iteration. `epoch_samples` is the number of training samples per distributed rank. Do not attach a DistributedSampler: this iterable manages partitioning. Call set_epoch(epoch) before each epoch, including with persistent workers. Download the shards with huggingface_hub.snapshot_download beforehand. """ def __init__(self, root, split='train', components=None, training=None, weights=None, epoch_samples=100000, shuffle_buffer=128, load_images=True, seed=787, rank=None, world_size=None): super().__init__() self.root = Path(root) self.split = split self.components = list(components or COMPONENT_WEIGHTS) self.training = split == 'train' if training is None else training self.weights = weights or COMPONENT_WEIGHTS self.epoch_samples = epoch_samples self.shuffle_buffer = shuffle_buffer if epoch_samples <= 0 or shuffle_buffer <= 0: raise ValueError('epoch_samples and shuffle_buffer must be positive') self.load_images = load_images self.seed = seed self.epoch = multiprocessing.Value('q', 0) distributed = torch.distributed.is_available() and torch.distributed.is_initialized() self.rank = torch.distributed.get_rank() if rank is None and distributed else (rank or 0) self.world_size = (torch.distributed.get_world_size() if world_size is None and distributed else (world_size or 1)) self.shards = {} for component in self.components: files = sorted((self.root / 'data' / component / split).glob('shard-*.tar')) if not files: raise ValueError(f'No shards for {component}/{split}; select components with this split') self.shards[component] = files if self.training and any(self.weights.get(c, 0) <= 0 for c in self.components): raise ValueError('Every selected training component needs a positive sampling weight') def set_epoch(self, epoch): self.epoch.value = epoch def __len__(self): if self.training: return self.epoch_samples files = [p for c in self.components for p in self.shards[c]][self.rank::self.world_size] return sum(json.loads((self.root / 'manifests/shards' / p.relative_to(self.root / 'data')) .with_suffix('.json').read_text())['trajectories'] for p in files) def __iter__(self): worker = torch.utils.data.get_worker_info() worker_id, workers = (worker.id, worker.num_workers) if worker else (0, 1) global_worker = self.rank * workers + worker_id rng = random.Random(self.seed + 1000003 * self.epoch.value + 1009 * global_worker) if not self.training: # Rank partition first makes __len__ agree with iteration regardless of worker count. files = [p for c in self.components for p in self.shards[c]] for shard in files[self.rank::self.world_size][worker_id::workers]: for sample in iter_shard(shard): yield decode_sample(sample, self.load_images) return def component_stream(component): files = self.shards[component] while True: # Uniform shard choice followed by all samples gives uniform long-run # sample frequency. Variable shard size affects block length, not frequency. for sample in iter_shard(rng.choice(files)): # Retain short source sequences in the release, but require # the ten-frame horizon for default PointZero pretraining. if len(json.loads(sample['json'])['timestep_names']) == 10: yield sample streams = {c: component_stream(c) for c in self.components} probabilities = [self.weights[c] for c in self.components] budget = max(0, (self.epoch_samples + workers - 1 - worker_id) // workers) buffer = [] for _ in range(min(self.shuffle_buffer, budget)): component = rng.choices(self.components, probabilities)[0] buffer.append(next(streams[component])) for i in range(budget): index = rng.randrange(len(buffer)) sample = buffer[index] if i + len(buffer) < budget: component = rng.choices(self.components, probabilities)[0] buffer[index] = next(streams[component]) else: buffer.pop(index) yield decode_sample(sample, self.load_images) if __name__ == '__main__': import argparse parser = argparse.ArgumentParser() parser.add_argument('root') parser.add_argument('--component', default='shorts_v7') parser.add_argument('--split', default='train') args = parser.parse_args() dataset = PointZeroShardDataset(args.root, components=[args.component], split=args.split, training=False) example = next(iter(dataset))['current_scene'] print('points:', tuple(example['points'].shape)) print('graspers:', None if example['graspers'] is None else tuple(example['graspers'].shape)) print('rgb:', tuple(example['rgb'].shape))