diff --git a/app/vjepa_droid/so101.py b/app/vjepa_droid/so101.py new file mode 100644 index 0000000..ee8d9db --- /dev/null +++ b/app/vjepa_droid/so101.py @@ -0,0 +1,208 @@ +"""LeRobot v3 SO-101 adapter for V-JEPA 2 action-conditioned post-training.""" + +from __future__ import annotations + +import csv +import json +from collections import OrderedDict, defaultdict +from pathlib import Path + +import numpy as np +import pyarrow.dataset as pads +import pyarrow.parquet as pq +import torch +from decord import VideoReader, cpu + +from app.vjepa_droid.so101_index import ( + build_candidates, + hierarchical_sample_weights, + resample_command_windows, +) +from src.datasets.utils.weighted_sampler import DistributedWeightedSampler + + +def init_data( + data_path, + batch_size, + frames_per_clip=8, + fps=4, + rank=0, + world_size=1, + camera_views=("observation.images.left", "observation.images.fpv"), + drop_last=True, + num_workers=10, + pin_mem=True, + persistent_workers=True, + collator=None, + transform=None, + action_history_frames=5, + action_samples_per_transition=13, + split="train", + demonstration_probability=0.70, + exploration_probability=0.30, + seed=239, + **_unused, +): + dataset = SO101VideoDataset( + data_path=data_path, + frames_per_clip=frames_per_clip, + transform=transform, + fps=fps, + camera_views=camera_views, + action_history_frames=action_history_frames, + action_samples_per_transition=action_samples_per_transition, + split=split, + task_probabilities={0: demonstration_probability, 1: exploration_probability}, + ) + sampler = DistributedWeightedSampler( + dataset, + num_replicas=world_size, + rank=rank, + shuffle=True, + seed=seed, + drop_last=drop_last, + ) + loader = torch.utils.data.DataLoader( + dataset, + collate_fn=collator, + sampler=sampler, + batch_size=batch_size, + drop_last=drop_last, + pin_memory=pin_mem, + num_workers=num_workers, + persistent_workers=(num_workers > 0) and persistent_workers, + ) + return loader, sampler + + +class SO101VideoDataset(torch.utils.data.Dataset): + def __init__( + self, + data_path, + camera_views, + frames_per_clip, + fps, + transform, + action_history_frames, + action_samples_per_transition, + split, + task_probabilities, + ): + self.root = Path(data_path).expanduser().resolve() + self.camera_views = tuple(camera_views) + self.frames_per_clip = int(frames_per_clip) + self.target_fps = float(fps) + self.transform = transform + self.action_history_frames = int(action_history_frames) + self.action_samples_per_transition = int(action_samples_per_transition) + self._readers: OrderedDict[tuple[str, int], VideoReader] = OrderedDict() + + info = json.loads((self.root / "meta/info.json").read_text(encoding="utf-8")) + self.source_fps = int(info["fps"]) + self.episode_rows = { + int(row["episode_index"]): row + for row in pq.read_table(self.root / "meta/episodes/chunk-000/file-000.parquet").to_pylist() + } + numeric = pads.dataset(self.root / "data", format="parquet").to_table( + columns=["action", "observation.state", "episode_index", "task_index"] + ) + self.commands = np.asarray(numeric["action"].to_pylist(), dtype=np.float32) + self.states = np.asarray(numeric["observation.state"].to_pylist(), dtype=np.float32) + episode_ids = numeric["episode_index"].to_numpy(zero_copy_only=False) + task_ids = numeric["task_index"].to_numpy(zero_copy_only=False) + self.task_by_episode = {} + for episode, task in zip(episode_ids, task_ids, strict=True): + episode = int(episode) + task = int(task) + previous = self.task_by_episode.setdefault(episode, task) + if previous != task: + raise ValueError(f"episode {episode} contains multiple task_index values") + + split_payload = json.loads( + (self.root / "meta/cleaning/episode_splits.json").read_text(encoding="utf-8") + ) + split_episodes = set(int(value) for value in split_payload["splits"][split]) + exclusions = self._load_exclusions() + episode_lengths = {episode: int(row["length"]) for episode, row in self.episode_rows.items()} + self.candidates, self.visual_offsets = build_candidates( + episode_lengths=episode_lengths, + task_by_episode=self.task_by_episode, + split_episodes=split_episodes, + exclusions_by_episode=exclusions, + frames_per_clip=self.frames_per_clip, + source_fps=self.source_fps, + target_fps=self.target_fps, + action_history_frames=self.action_history_frames, + ) + self.sample_weights = hierarchical_sample_weights(self.candidates, task_probabilities) + + normalization = json.loads( + (self.root / "meta/cleaning/normalization_stats.json").read_text(encoding="utf-8") + )["features"] + self.action_mean = np.asarray(normalization["action"]["mean"], dtype=np.float32) + self.action_std = np.maximum( + np.asarray(normalization["action"]["std"], dtype=np.float32), 1e-6 + ) + self.state_mean = np.asarray(normalization["observation.state"]["mean"], dtype=np.float32) + self.state_std = np.maximum( + np.asarray(normalization["observation.state"]["std"], dtype=np.float32), 1e-6 + ) + + def _load_exclusions(self): + by_episode = defaultdict(list) + path = self.root / "meta/cleaning/intervention_exclusions.csv" + with path.open(encoding="utf-8") as handle: + for row in csv.DictReader(handle): + if row["exclude_from_dynamics"] == "True": + by_episode[int(row["episode_index"])].append( + (float(row["episode_start_s"]), float(row["episode_end_s"])) + ) + return dict(by_episode) + + def _reader(self, view: str, file_index: int) -> VideoReader: + key = (view, file_index) + reader = self._readers.pop(key, None) + if reader is None: + path = self.root / "videos" / view / "chunk-000" / f"file-{file_index:03d}.mp4" + reader = VideoReader(str(path), num_threads=-1, ctx=cpu(0)) + self._readers[key] = reader + while len(self._readers) > 8: + self._readers.popitem(last=False) + return reader + + def __getitem__(self, index): + candidate = self.candidates[index] + episode = candidate.episode_index + row = self.episode_rows[episode] + local_visual = candidate.start_frame + self.visual_offsets + dataset_start = int(row["dataset_from_index"]) + dataset_end = int(row["dataset_to_index"]) + episode_commands = self.commands[dataset_start:dataset_end] + episode_states = self.states[dataset_start:dataset_end] + + action_windows = resample_command_windows( + episode_commands, + local_visual, + source_fps=self.source_fps, + action_history_frames=self.action_history_frames, + samples_per_transition=self.action_samples_per_transition, + ) + action_windows = (action_windows - self.action_mean) / self.action_std + actions = action_windows.reshape(len(action_windows), -1).astype(np.float32) + states = ((episode_states[local_visual] - self.state_mean) / self.state_std).astype(np.float32) + + view = self.camera_views[int(torch.randint(0, len(self.camera_views), (1,)).item())] + file_index = int(row[f"videos/{view}/file_index"]) + source_start = round(float(row[f"videos/{view}/from_timestamp"]) * self.source_fps) + video_indices = source_start + local_visual + reader = self._reader(view, file_index) + buffer = reader.get_batch(video_indices).asnumpy() + if self.transform is not None: + buffer = self.transform(buffer) + + extrinsics = np.zeros((self.frames_per_clip, 6), dtype=np.float32) + global_indices = (dataset_start + local_visual).astype(np.int64) + return buffer, actions, states, extrinsics, global_indices + + def __len__(self): + return len(self.candidates) diff --git a/app/vjepa_droid/so101_index.py b/app/vjepa_droid/so101_index.py new file mode 100644 index 0000000..d13d603 --- /dev/null +++ b/app/vjepa_droid/so101_index.py @@ -0,0 +1,111 @@ +"""Pure NumPy helpers for SO-101 clip indexing and action resampling.""" + +from __future__ import annotations + +from collections import defaultdict +from dataclasses import dataclass + +import numpy as np + + +@dataclass(frozen=True) +class ClipCandidate: + episode_index: int + start_frame: int + task_index: int + + +def visual_frame_offsets(frames_per_clip: int, source_fps: int, target_fps: float) -> np.ndarray: + if frames_per_clip < 2: + raise ValueError("frames_per_clip must be at least 2") + if source_fps <= 0 or target_fps <= 0: + raise ValueError("frame rates must be positive") + offsets = np.rint(np.arange(frames_per_clip, dtype=np.float64) * source_fps / target_fps).astype(np.int64) + if np.any(np.diff(offsets) <= 0): + raise ValueError("target_fps is too high for distinct source frames") + return offsets + + +def interval_overlaps(start_s: float, end_s: float, exclusions: list[tuple[float, float]]) -> bool: + return any(start_s < excluded_end and end_s > excluded_start for excluded_start, excluded_end in exclusions) + + +def build_candidates( + episode_lengths: dict[int, int], + task_by_episode: dict[int, int], + split_episodes: set[int], + exclusions_by_episode: dict[int, list[tuple[float, float]]], + frames_per_clip: int, + source_fps: int, + target_fps: float, + action_history_frames: int, +) -> tuple[list[ClipCandidate], np.ndarray]: + offsets = visual_frame_offsets(frames_per_clip, source_fps, target_fps) + candidates: list[ClipCandidate] = [] + for episode in sorted(split_episodes): + length = episode_lengths[episode] + last_start = length - 1 - int(offsets[-1]) + for start in range(action_history_frames, last_start + 1): + covered_start_s = (start - action_history_frames) / source_fps + covered_end_s = (start + int(offsets[-1])) / source_fps + if interval_overlaps(covered_start_s, covered_end_s, exclusions_by_episode.get(episode, [])): + continue + candidates.append(ClipCandidate(episode, start, task_by_episode[episode])) + if not candidates: + raise ValueError("no valid clip candidates remain") + return candidates, offsets + + +def hierarchical_sample_weights( + candidates: list[ClipCandidate], task_probabilities: dict[int, float] +) -> np.ndarray: + probability_sum = sum(task_probabilities.values()) + if not np.isclose(probability_sum, 1.0): + raise ValueError(f"task probabilities must sum to 1, got {probability_sum}") + + candidates_per_episode: dict[int, int] = defaultdict(int) + episodes_per_task: dict[int, set[int]] = defaultdict(set) + for candidate in candidates: + candidates_per_episode[candidate.episode_index] += 1 + episodes_per_task[candidate.task_index].add(candidate.episode_index) + + missing = set(episodes_per_task) - set(task_probabilities) + if missing: + raise ValueError(f"missing probabilities for task_index values {sorted(missing)}") + + weights = [] + for candidate in candidates: + task = candidate.task_index + episode = candidate.episode_index + weight = task_probabilities[task] / len(episodes_per_task[task]) / candidates_per_episode[episode] + weights.append(weight) + weights_array = np.asarray(weights, dtype=np.float64) + return weights_array / weights_array.sum() + + +def resample_command_windows( + commands: np.ndarray, + visual_indices: np.ndarray, + source_fps: int, + action_history_frames: int, + samples_per_transition: int, +) -> np.ndarray: + commands = np.asarray(commands, dtype=np.float64) + visual_indices = np.asarray(visual_indices, dtype=np.int64) + if commands.ndim != 2: + raise ValueError("commands must have shape [frames, joints]") + if samples_per_transition < 2: + raise ValueError("samples_per_transition must be at least 2") + + command_times = np.arange(len(commands), dtype=np.float64) / source_fps + windows = [] + for current, following in zip(visual_indices[:-1], visual_indices[1:], strict=True): + start_s = (int(current) - action_history_frames) / source_fps + end_s = int(following) / source_fps + sample_times = np.linspace(start_s, end_s, samples_per_transition, dtype=np.float64) + samples = np.stack( + [np.interp(sample_times, command_times, commands[:, joint]) for joint in range(commands.shape[1])], + axis=1, + ) + windows.append(samples) + return np.asarray(windows, dtype=np.float32) diff --git a/app/vjepa_droid/train.py b/app/vjepa_droid/train.py index c0e4fac..e70c013 100644 --- a/app/vjepa_droid/train.py +++ b/app/vjepa_droid/train.py @@ -28,7 +28,8 @@ import torch.multiprocessing as mp import torch.nn.functional as F from torch.nn.parallel import DistributedDataParallel -from app.vjepa_droid.droid import init_data +from app.vjepa_droid.droid import init_data as init_droid_data +from app.vjepa_droid.so101 import init_data as init_so101_data from app.vjepa_droid.transforms import make_transforms from app.vjepa_droid.utils import init_opt, init_video_model, load_checkpoint, load_pretrained from src.utils.distributed import init_distributed @@ -97,11 +98,14 @@ def main(args, resume_preempt=False): use_pred_silu = cfgs_model.get("use_pred_silu", False) wide_silu = cfgs_model.get("wide_silu", True) use_extrinsics = cfgs_model.get("use_extrinsics", False) + action_embed_dim = cfgs_model.get("action_embed_dim", 7) + state_embed_dim = cfgs_model.get("state_embed_dim", action_embed_dim) # -- DATA cfgs_data = args.get("data") datasets = cfgs_data.get("datasets", []) dataset_path = datasets[0] + dataset_type = cfgs_data.get("dataset_type", "droid") dataset_fpcs = cfgs_data.get("dataset_fpcs") max_num_frames = max(dataset_fpcs) camera_frame = cfgs_data.get("camera_frame", False) @@ -200,7 +204,8 @@ def main(args, resume_preempt=False): pred_depth=pred_depth, pred_num_heads=pred_num_heads, pred_embed_dim=pred_embed_dim, - action_embed_dim=7, + action_embed_dim=action_embed_dim, + state_embed_dim=state_embed_dim, pred_is_frame_causal=pred_is_frame_causal, use_extrinsics=use_extrinsics, use_sdpa=use_sdpa, @@ -231,6 +236,17 @@ def main(args, resume_preempt=False): ) # -- init data-loaders/samplers + init_data = init_so101_data if dataset_type == "so101_lerobot" else init_droid_data + so101_kwargs = {} + if dataset_type == "so101_lerobot": + so101_kwargs = { + "action_history_frames": cfgs_data.get("action_history_frames", 5), + "action_samples_per_transition": cfgs_data.get("action_samples_per_transition", 13), + "split": cfgs_data.get("split", "train"), + "demonstration_probability": cfgs_data.get("demonstration_probability", 0.70), + "exploration_probability": cfgs_data.get("exploration_probability", 0.30), + "seed": seed, + } (unsupervised_loader, unsupervised_sampler) = init_data( data_path=dataset_path, batch_size=batch_size, @@ -247,6 +263,7 @@ def main(args, resume_preempt=False): pin_mem=pin_mem, persistent_workers=persistent_workers, rank=rank, + **so101_kwargs, ) _dlen = len(unsupervised_loader) if ipe is None: diff --git a/app/vjepa_droid/utils.py b/app/vjepa_droid/utils.py index 50d014a..d6fa2d9 100644 --- a/app/vjepa_droid/utils.py +++ b/app/vjepa_droid/utils.py @@ -144,6 +144,7 @@ def init_video_model( use_activation_checkpointing=False, return_all_tokens=False, action_embed_dim=7, + state_embed_dim=None, use_extrinsics=False, old_pred=False, ): @@ -168,6 +169,7 @@ def init_video_model( embed_dim=encoder.embed_dim, predictor_embed_dim=pred_embed_dim, action_embed_dim=action_embed_dim, + state_embed_dim=state_embed_dim, depth=pred_depth, is_frame_causal=pred_is_frame_causal, num_heads=encoder.num_heads if pred_num_heads is None else pred_num_heads, diff --git a/configs/train/vitg16/so101-256px-8f.yaml b/configs/train/vitg16/so101-256px-8f.yaml new file mode 100644 index 0000000..524eeeb --- /dev/null +++ b/configs/train/vitg16/so101-256px-8f.yaml @@ -0,0 +1,79 @@ +app: vjepa_droid +cpus_per_task: 8 +folder: /path/to/output/so101-vjepa2-ac +mem_per_gpu: 64G +nodes: 1 +tasks_per_node: 8 +data: + action_history_frames: 5 + action_samples_per_transition: 13 + batch_size: 1 + camera_views: + - observation.images.left + - observation.images.fpv + crop_size: 256 + dataset_type: so101_lerobot + datasets: + - /path/to/so101_wm + dataset_fpcs: + - 8 + demonstration_probability: 0.70 + exploration_probability: 0.30 + fps: 4 + num_workers: 4 + patch_size: 16 + persistent_workers: true + pin_mem: true + split: train + stereo_view: false + tubelet_size: 2 +data_aug: + auto_augment: false + horizontal_flip: false + motion_shift: false + random_resize_aspect_ratio: + - 0.75 + - 1.35 + random_resize_scale: + - 1.777 + - 1.777 + reprob: 0.0 +loss: + auto_steps: 2 + loss_exp: 1.0 + normalize_reps: true + reg_coeff: 0.0 +meta: + context_encoder_key: target_encoder + dtype: bfloat16 + eval_freq: 100 + load_predictor: false + pretrain_checkpoint: /path/to/checkpoints/vitg.pt + resume_checkpoint: null + save_every_freq: 5 + seed: 239 + target_encoder_key: target_encoder + use_sdpa: true +model: + action_embed_dim: 78 + model_name: vit_giant_xformers + pred_depth: 24 + pred_embed_dim: 1024 + pred_is_frame_causal: true + pred_num_heads: 16 + state_embed_dim: 6 + uniform_power: true + use_activation_checkpointing: true + use_extrinsics: false + use_rope: true +optimization: + anneal: 10 + enc_lr_scale: 0.10 + epochs: 100 + final_lr: 0.0 + final_weight_decay: 0.04 + ipe: 500 + lr: 0.00002 + start_lr: 0.000002 + warmup: 5 + weight_decay: 0.04 diff --git a/configs/train/vitg16/so101-smoke-256px-8f.yaml b/configs/train/vitg16/so101-smoke-256px-8f.yaml new file mode 100644 index 0000000..bd6120b --- /dev/null +++ b/configs/train/vitg16/so101-smoke-256px-8f.yaml @@ -0,0 +1,78 @@ +app: vjepa_droid +cpus_per_task: 4 +folder: /path/to/output/so101-smoke +mem_per_gpu: 64G +nodes: 1 +tasks_per_node: 1 +data: + action_history_frames: 5 + action_samples_per_transition: 13 + batch_size: 1 + camera_views: + - observation.images.left + - observation.images.fpv + crop_size: 256 + dataset_type: so101_lerobot + datasets: + - /path/to/so101_wm + dataset_fpcs: + - 8 + demonstration_probability: 0.70 + exploration_probability: 0.30 + fps: 4 + num_workers: 2 + patch_size: 16 + persistent_workers: true + pin_mem: true + split: train + stereo_view: false + tubelet_size: 2 +data_aug: + auto_augment: false + horizontal_flip: false + motion_shift: false + random_resize_aspect_ratio: + - 0.75 + - 1.35 + random_resize_scale: + - 1.777 + - 1.777 + reprob: 0.0 +loss: + auto_steps: 2 + loss_exp: 1.0 + normalize_reps: true + reg_coeff: 0.0 +meta: + context_encoder_key: target_encoder + dtype: bfloat16 + load_predictor: false + pretrain_checkpoint: /path/to/checkpoints/vitg.pt + resume_checkpoint: null + save_every_freq: 1 + seed: 239 + target_encoder_key: target_encoder + use_sdpa: true +model: + action_embed_dim: 78 + model_name: vit_giant_xformers + pred_depth: 24 + pred_embed_dim: 1024 + pred_is_frame_causal: true + pred_num_heads: 16 + state_embed_dim: 6 + uniform_power: true + use_activation_checkpointing: true + use_extrinsics: false + use_rope: true +optimization: + anneal: 1 + enc_lr_scale: 0.10 + epochs: 3 + final_lr: 0.0 + final_weight_decay: 0.04 + ipe: 2 + lr: 0.00002 + start_lr: 0.000002 + warmup: 1 + weight_decay: 0.04 diff --git a/src/models/ac_predictor.py b/src/models/ac_predictor.py index 3d4007d..cd6689e 100644 --- a/src/models/ac_predictor.py +++ b/src/models/ac_predictor.py @@ -42,6 +42,7 @@ class VisionTransformerPredictorAC(nn.Module): use_activation_checkpointing=False, use_rope=True, action_embed_dim=7, + state_embed_dim=None, use_extrinsics=False, **kwargs ): @@ -52,7 +53,11 @@ class VisionTransformerPredictorAC(nn.Module): # Map input to predictor dimension self.predictor_embed = nn.Linear(embed_dim, predictor_embed_dim, bias=True) self.action_encoder = nn.Linear(action_embed_dim, predictor_embed_dim, bias=True) - self.state_encoder = nn.Linear(action_embed_dim, predictor_embed_dim, bias=True) + self.state_encoder = nn.Linear( + action_embed_dim if state_embed_dim is None else state_embed_dim, + predictor_embed_dim, + bias=True, + ) self.extrinsics_encoder = nn.Linear(action_embed_dim - 1, predictor_embed_dim, bias=True) # Determine positional embedding diff --git a/tests/test_so101_index.py b/tests/test_so101_index.py new file mode 100644 index 0000000..6fdc56d --- /dev/null +++ b/tests/test_so101_index.py @@ -0,0 +1,69 @@ +import unittest + +import numpy as np + +from app.vjepa_droid.so101_index import ( + build_candidates, + hierarchical_sample_weights, + resample_command_windows, + visual_frame_offsets, +) + + +class TestSO101Index(unittest.TestCase): + def test_visual_offsets_alternate_seven_and_eight_source_frames(self): + offsets = visual_frame_offsets(8, 30, 4) + np.testing.assert_array_equal(offsets, [0, 8, 15, 22, 30, 38, 45, 52]) + + def test_exclusion_rejects_complete_context_window(self): + candidates, _ = build_candidates( + episode_lengths={0: 100, 1: 100}, + task_by_episode={0: 0, 1: 1}, + split_episodes={0, 1}, + exclusions_by_episode={0: [(1.0, 1.5)]}, + frames_per_clip=4, + source_fps=30, + target_fps=4, + action_history_frames=5, + ) + episode_zero_starts = {item.start_frame for item in candidates if item.episode_index == 0} + self.assertNotIn(25, episode_zero_starts) + self.assertIn(25, {item.start_frame for item in candidates if item.episode_index == 1}) + + def test_hierarchical_weights_match_group_and_episode_targets(self): + candidates, _ = build_candidates( + episode_lengths={0: 90, 1: 120, 2: 150}, + task_by_episode={0: 0, 1: 0, 2: 1}, + split_episodes={0, 1, 2}, + exclusions_by_episode={}, + frames_per_clip=4, + source_fps=30, + target_fps=4, + action_history_frames=5, + ) + weights = hierarchical_sample_weights(candidates, {0: 0.7, 1: 0.3}) + task_zero = sum(weight for item, weight in zip(candidates, weights, strict=True) if item.task_index == 0) + task_one = sum(weight for item, weight in zip(candidates, weights, strict=True) if item.task_index == 1) + self.assertAlmostEqual(task_zero, 0.7) + self.assertAlmostEqual(task_one, 0.3) + episode_weights = { + episode: sum(weight for item, weight in zip(candidates, weights, strict=True) if item.episode_index == episode) + for episode in (0, 1, 2) + } + self.assertAlmostEqual(episode_weights[0], 0.35) + self.assertAlmostEqual(episode_weights[1], 0.35) + self.assertAlmostEqual(episode_weights[2], 0.30) + + def test_command_resampling_preserves_order_and_shape(self): + commands = np.arange(120, dtype=np.float64)[:, None] + commands = np.repeat(commands, 6, axis=1) + visual = np.asarray([10, 18, 25]) + result = resample_command_windows(commands, visual, 30, 5, 13) + self.assertEqual(result.shape, (2, 13, 6)) + self.assertAlmostEqual(float(result[0, 0, 0]), 5.0) + self.assertAlmostEqual(float(result[0, -1, 0]), 18.0) + self.assertTrue(np.all(np.diff(result[0, :, 0]) > 0)) + + +if __name__ == "__main__": + unittest.main()