|
|
| new file mode 100644
|
|
|
|
|
|
|
| @@ -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)
|
|
|
| new file mode 100644
|
|
|
|
|
|
|
| @@ -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)
|
|
|
|
|
|
|
|
|
| @@ -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:
|
|
|
|
|
|
|
|
|
| @@ -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,
|
|
|
| new file mode 100644
|
|
|
|
|
|
|
| @@ -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
|
|
|
| new file mode 100644
|
|
|
|
|
|
|
| @@ -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
|
|
|
|
|
|
|
|
|
| @@ -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
|
|
|
| new file mode 100644
|
|
|
|
|
|
|
| @@ -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()
|
|
|
