""" PyTorch Dataset for loading raw video segments for VAE preprocessing. Fully self-contained — all data-side operations (segment filtering, frame sampling, video decoding, batch padding) are implemented here without importing from other preprocessing scripts. """ from __future__ import annotations from pathlib import Path import numpy as np import torch import torch.nn.functional as F from torch.utils.data import Dataset from tqdm import tqdm from lerobot.datasets.video_utils import decode_video_frames # ---- helpers ---------------------------------------------------------------- def _get_latent_output_path( dataset_root: Path, camera_key: str, episode_index: int, start_frame: int, end_frame: int, ) -> Path: chunk_id = episode_index // 1000 return ( dataset_root / "latents" / f"chunk-{chunk_id:03d}" / camera_key / f"episode_{episode_index:06d}_{start_frame}_{end_frame}.pth" ) def _resolve_episode_data_source( dataset_root: Path, episode_row: dict, data_path_template: str, ) -> Path: chunk_key = "data/chunk_index" file_key = "data/file_index" if chunk_key not in episode_row or file_key not in episode_row: raise KeyError( "Can not find v3.0 data parquet metadata for " f"episode_index={int(episode_row['episode_index'])}" ) data_path = dataset_root / data_path_template.format( chunk_index=int(episode_row[chunk_key]), file_index=int(episode_row[file_key]), ) if not data_path.exists(): raise FileNotFoundError(f"Data parquet not found: {data_path}") return data_path def _batch_load_episode_frame_timestamps( dataset_root: Path, episode_indices: set[int], episode_lookup: dict[int, dict], data_path_template: str, ) -> dict[int, dict[int, float]]: """Load timestamps for many episodes at once, reading each parquet file only once.""" if not episode_indices: return {} import pandas as pd from collections import defaultdict # Group episodes by their data parquet file file_to_episodes: dict[Path, list[int]] = defaultdict(list) for ep_idx in episode_indices: episode_row = episode_lookup.get(ep_idx) if episode_row is None: raise KeyError(f"episode_index not found in metadata: {ep_idx}") data_path = _resolve_episode_data_source(dataset_root, episode_row, data_path_template) file_to_episodes[data_path].append(ep_idx) result: dict[int, dict[int, float]] = {} for data_path, ep_list in tqdm( file_to_episodes.items(), desc="Loading timestamps", unit="file", ): frame_table = pd.read_parquet( data_path, columns=["episode_index", "frame_index", "timestamp"], filters=[("episode_index", "in", ep_list)], ) if frame_table.empty: raise ValueError(f"No frame timestamps found in {data_path} for episodes {ep_list}") for ep_idx in ep_list: ep_rows = frame_table[frame_table["episode_index"] == ep_idx] if ep_rows.empty: raise ValueError( f"No frame timestamps found in {data_path} for episode_index={ep_idx}" ) ep_rows = ep_rows.sort_values("frame_index", kind="stable").reset_index(drop=True) frame_ids = [int(v) for v in ep_rows["frame_index"].tolist()] timestamps = [float(v) for v in ep_rows["timestamp"].tolist()] if len(frame_ids) != len(set(frame_ids)): raise ValueError( f"Duplicated frame_index in {data_path} for episode_index={ep_idx}" ) episode_row = episode_lookup[ep_idx] expected_num_frames = None if "dataset_from_index" in episode_row and "dataset_to_index" in episode_row: expected_num_frames = int(episode_row["dataset_to_index"]) - int(episode_row["dataset_from_index"]) elif "length" in episode_row: expected_num_frames = int(episode_row["length"]) if expected_num_frames is not None and len(frame_ids) != expected_num_frames: raise ValueError( f"Frame count mismatch for episode_index={ep_idx}: " f"metadata says {expected_num_frames}, parquet has {len(frame_ids)} ({data_path})" ) expected_frame_ids = list(range(len(frame_ids))) if frame_ids != expected_frame_ids: raise ValueError( f"frame_index is not contiguous 0..N-1 for episode_index={ep_idx} in {data_path}" ) if any(b <= a for a, b in zip(timestamps, timestamps[1:])): raise ValueError( f"timestamp is not strictly increasing for episode_index={ep_idx} in {data_path}" ) result[ep_idx] = dict(zip(frame_ids, timestamps)) return result def _resolve_episode_video_source( dataset_root: Path, camera_key: str, episode_index: int, episode_lookup: dict[int, dict], legacy: bool = False, ) -> tuple[Path, float]: """Return ``(video_path, start_timestamp)``. Args: legacy: True for v2.1 layout (one mp4 per episode), False for v3.0 layout (chunk/file based). """ if legacy: chunk_id = episode_index // 1000 video_path = ( dataset_root / "videos" / f"chunk-{chunk_id:03d}" / camera_key / f"episode_{episode_index:06d}.mp4" ) if not video_path.exists(): raise FileNotFoundError(f"Video not found: {video_path}") return video_path, 0.0 episode_row = episode_lookup.get(int(episode_index)) if episode_row is None: raise KeyError(f"episode_index not found in metadata: {episode_index}") chunk_key = f"videos/{camera_key}/chunk_index" file_key = f"videos/{camera_key}/file_index" from_ts_key = f"videos/{camera_key}/from_timestamp" if chunk_key not in episode_row or file_key not in episode_row: raise KeyError( f"Can not find v3.0 video metadata for camera={camera_key}, " f"episode_index={episode_index}" ) video_path = ( dataset_root / "videos" / camera_key / f"chunk-{int(episode_row[chunk_key]):03d}" / f"file-{int(episode_row[file_key]):03d}.mp4" ) if not video_path.exists(): raise FileNotFoundError(f"Video not found: {video_path}") return video_path, float(episode_row.get(from_ts_key, 0.0)) def _sample_frame_ids( start_frame: int, end_frame: int, ori_fps: float, target_fps: int, ) -> list[int]: if target_fps <= 0 or ori_fps <= 0: raise ValueError(f"FPS must be positive: target_fps={target_fps}, ori_fps={ori_fps}") if target_fps > ori_fps: target_fps = ori_fps if end_frame <= start_frame: raise ValueError(f"Invalid frame range: {start_frame} -> {end_frame}") ori_fps = max(float(ori_fps), 1.0) stride = max(int(round(ori_fps / target_fps)), 1) frame_ids = list(range(start_frame, end_frame, stride)) if not frame_ids: frame_ids = [start_frame] if frame_ids[-1] != end_frame - 1: frame_ids.append(end_frame - 1) return sorted(set(frame_ids)) def _read_video_frames( video_path: Path, timestamps: list[float], height: int, width: int, tolerance_s: float, ) -> torch.Tensor: """Decode, resize and normalise to [-1, 1]. Returns ``(1, 3, F, H, W)``.""" if not video_path.exists(): raise FileNotFoundError(f"Video not found: {video_path}") frames = decode_video_frames( video_path, timestamps=timestamps, tolerance_s=tolerance_s, backend="pyav", ) # (F, C, H, W) in [0, 1] if frames.shape[-2:] != (height, width): frames = F.interpolate(frames, size=(height, width), mode="bilinear", align_corners=False) return frames.unsqueeze(0).permute(0, 2, 1, 3, 4) * 2.0 - 1.0 def _compute_valid_frame_count(num_sampled): """Frames kept after dropping incomplete tail chunk (temporal downsample = 4).""" n = np.maximum(num_sampled, 1) return np.where(n <= 1, n, 1 + ((n - 1) // 4) * 4) def _compute_latent_frame_count(num_valid): """Latent temporal frames from valid input frames (temporal downsample = 4).""" n = np.maximum(num_valid, 1) return np.where(n <= 1, n, 1 + (n - 1) // 4) # ---- dataset ---------------------------------------------------------------- class SegmentVideoDataset(Dataset): """Dataset that loads and preprocesses video segments for VAE encoding. * **init** — segment filtering (skip existing / invalid), frame sampling, valid-frame & latent-frame count, timestamp resolution. * **getitem** — video frame loading, decoding, resize, normalisation. * **collate** — batch-level temporal padding (see ``collate_segment_videos``). Parameters ---------- segments : list[dict] Raw action segments (from ``ensure_action_config_store``). camera_key, dataset_root, episode_lookup, data_path_template : Passed through to video / timestamp resolution helpers. dataset_fps : float Original dataset FPS. target_fps : int Target FPS for frame sampling. height, width : int Target frame resolution. skip_existing : bool Skip segments whose latent files already exist. legacy_video : bool True for v2.1 video layout, False for v3.0. """ def __init__( self, segments: list[dict], camera_key: str, dataset_root: Path, episode_lookup: dict, data_path_template: str, dataset_fps: float, target_fps: int, height: int, width: int, skip_existing: bool = False, legacy_video: bool = False, ): self.camera_key = camera_key self.dataset_root = dataset_root self.episode_lookup = episode_lookup self.height = height self.width = width self.legacy_video = legacy_video self.metas: list[dict] = [] self.skipped_keys: dict[tuple[int, int, int], int] = {} # Pass 1: filter segments, compute frame sampling, collect needed episodes pending: list[dict] = [] needed_episodes: set[int] = set() for seg in tqdm(segments, desc=f"Filtering [{camera_key}]", unit="seg"): ep_idx = int(seg["episode_index"]) sf = int(seg["start_frame"]) ef = int(seg["end_frame"]) key = (ep_idx, sf, ef) all_sampled = _sample_frame_ids(sf, ef, dataset_fps, target_fps) valid_count = int(_compute_valid_frame_count(len(all_sampled))) sampled_ids = all_sampled[:valid_count] if not sampled_ids: continue latent_count = int(_compute_latent_frame_count(valid_count)) if skip_existing: out_path = _get_latent_output_path(dataset_root, camera_key, ep_idx, sf, ef) if out_path.exists(): self.skipped_keys[key] = latent_count continue needed_episodes.add(ep_idx) pending.append({ "episode_index": ep_idx, "start_frame": sf, "end_frame": ef, "action_text": seg["action_text"], "sampled_ids": sampled_ids, "valid_frame_count": valid_count, "latent_frame_count": latent_count, }) # Batch load timestamps: each parquet file is read only once ts_map = _batch_load_episode_frame_timestamps( dataset_root, needed_episodes, episode_lookup, data_path_template, ) # Pass 2: resolve timestamps and build final metas for item in pending: exact_ts = ts_map[item["episode_index"]] item["relative_timestamps"] = [float(exact_ts[fid]) for fid in item["sampled_ids"]] self.metas.append(item) # Sort by frame count so similarly-sized segments land in the same batch self.metas.sort(key=lambda m: m["valid_frame_count"],reverse=True) # Trim episode_lookup to only needed episodes (reduces pickle size for workers) used_episodes = {m["episode_index"] for m in self.metas} self.episode_lookup = {k: v for k, v in episode_lookup.items() if k in used_episodes} def __len__(self): return len(self.metas) def __getitem__(self, idx): meta = self.metas[idx] video_path, start_ts = _resolve_episode_video_source( self.dataset_root, self.camera_key, meta["episode_index"], self.episode_lookup, legacy=self.legacy_video, ) query_ts = [ts + start_ts for ts in meta["relative_timestamps"]] video = _read_video_frames( video_path, query_ts, self.height, self.width, tolerance_s=1e-4, ) # (1, 3, F, H, W) return meta, video # ---- collate ---------------------------------------------------------------- def collate_segment_videos(batch: list) -> tuple[list[dict], torch.Tensor]: """Pad videos to the longest temporal dim in the batch and stack. Returns ``(metas, batch_tensor)`` where *batch_tensor* is ``(B, 3, max_T, H, W)``. """ metas = [item[0] for item in batch] videos = [item[1] for item in batch] max_t = max(v.shape[2] for v in videos) padded = [] for v in videos: pad_t = max_t - v.shape[2] if pad_t > 0: v = F.pad(v, (0, 0, 0, 0, 0, pad_t), value=0) padded.append(v) batch_tensor = torch.cat(padded, dim=0) return metas, batch_tensor