From d86a2d905bfce2a30c8b503685b51a96592dae80 Mon Sep 17 00:00:00 2001 From: Aidan Gao Date: Mon, 9 Feb 2026 16:07:26 -0500 Subject: [PATCH] Zarr writing utils --- .gitignore | 5 +- egomimic/algo/hpt.py | 20 +- egomimic/hydra_configs/data/zarr_test.yaml | 60 + .../model/hpt_bc_flow_scale.yaml | 122 ++ egomimic/hydra_configs/train_zarr.yaml | 33 + egomimic/pl_utils/pl_data_utils.py | 2 +- egomimic/rldb/.gitignore | 4 +- egomimic/rldb/utils.py | 3 + egomimic/rldb/zarr/__init__.py | 6 + egomimic/rldb/zarr/action_chunk_transforms.py | 15 +- egomimic/rldb/zarr/benchmark_forward_pass.py | 524 ++++++++ egomimic/rldb/zarr/test_zarr.py | 155 +++ egomimic/rldb/zarr/utils.py | 396 ++++++ egomimic/rldb/zarr/zarr_dataset_multi.py | 66 +- egomimic/rldb/zarr/zarr_write_test.py | 498 +++++++ egomimic/rldb/zarr/zarr_writer.py | 2 +- egomimic/robot/data_visualization.ipynb | 1116 +--------------- egomimic/scripts/data_visualisation.ipynb | 145 ++- egomimic/scripts/eva_process/zarr_utils.py | 1159 +++++++++++++++++ egomimic/scripts/zarr_data_viz.ipynb | 388 +++++- egomimic/trainHydra.py | 52 +- egomimic/utils/egomimicUtils.py | 20 +- external/scale/scripts/sfsEgoverseUtils.py | 316 +++++ .../scale/scripts/sfs_to_egoverse_zarr.py | 636 +++++++++ 24 files changed, 4501 insertions(+), 1242 deletions(-) create mode 100644 egomimic/hydra_configs/data/zarr_test.yaml create mode 100644 egomimic/hydra_configs/model/hpt_bc_flow_scale.yaml create mode 100644 egomimic/hydra_configs/train_zarr.yaml create mode 100755 egomimic/rldb/zarr/benchmark_forward_pass.py create mode 100644 egomimic/rldb/zarr/utils.py create mode 100644 egomimic/rldb/zarr/zarr_write_test.py create mode 100644 egomimic/scripts/eva_process/zarr_utils.py create mode 100644 external/scale/scripts/sfsEgoverseUtils.py create mode 100644 external/scale/scripts/sfs_to_egoverse_zarr.py diff --git a/.gitignore b/.gitignore index 315c803a..6721e101 100644 --- a/.gitignore +++ b/.gitignore @@ -33,4 +33,7 @@ lerobot_test/ **/lerobot_test/ **/lerobot_test/** **/robot/models/** -**/robot/models/ \ No newline at end of file +**/robot/models/ +external/scale/scripts/datasets +_turbojpeg_lib/ +external/scale/scripts/scale_data/ \ No newline at end of file diff --git a/egomimic/algo/hpt.py b/egomimic/algo/hpt.py index e72754d4..252a9b28 100644 --- a/egomimic/algo/hpt.py +++ b/egomimic/algo/hpt.py @@ -971,14 +971,12 @@ def process_batch_for_training(self, batch): """ processed_batch = {} - for embodiment_id, _batch in batch.items(): + for embodiment_name, _batch in batch.items(): + embodiment_id = get_embodiment_id(embodiment_name) processed_batch[embodiment_id] = {} for key, value in _batch.items(): - key_name = self.data_schematic.lerobot_key_to_keyname( - key, embodiment_id - ) - if key_name is not None: - processed_batch[embodiment_id][key_name] = value + if key is not None: + processed_batch[embodiment_id][key] = value ac_key = self.ac_keys[embodiment_id] if len(processed_batch[embodiment_id][ac_key].shape) != 3: @@ -992,6 +990,9 @@ def process_batch_for_training(self, batch): processed_batch[embodiment_id] = self.data_schematic.normalize_data( processed_batch[embodiment_id], embodiment_id ) + processed_batch[embodiment_id]["embodiment"] = torch.tensor( + [embodiment_id], device=self.device, dtype=torch.int64 + ) return processed_batch @@ -1009,12 +1010,12 @@ def forward_training(self, batch): predictions = OrderedDict() hpt_batches = {} self.training_step += 1 - for embodiment_id, _batch in batch.items(): + for embodiment_id, _batch in batch.items(): # TODO why don't we use batch with embodiment_name to keep things consistent + embodiment_name = get_embodiment(embodiment_id).lower() cam_keys = self.camera_keys[embodiment_id] proprio_keys = self.proprio_keys[embodiment_id] lang_keys = self.lang_keys[embodiment_id] ac_key = self.ac_keys[embodiment_id] - embodiment_name = get_embodiment(embodiment_id).lower() aux_ac_keys = self.auxiliary_ac_keys.get(embodiment_name, []) data = self._robomimic_to_hpt_data( _batch, cam_keys, proprio_keys, lang_keys, ac_key, aux_ac_keys @@ -1059,11 +1060,11 @@ def forward_eval(self, batch): """ unnorm_preds = {} for embodiment_id, _batch in batch.items(): + embodiment_name = get_embodiment(embodiment_id).lower() cam_keys = self.camera_keys[embodiment_id] proprio_keys = self.proprio_keys[embodiment_id] lang_keys = self.lang_keys[embodiment_id] ac_key = self.ac_keys[embodiment_id] - embodiment_name = get_embodiment(embodiment_id).lower() aux_ac_keys = self.auxiliary_ac_keys.get(embodiment_name, []) data = self._robomimic_to_hpt_data( _batch, cam_keys, proprio_keys, lang_keys, ac_key, aux_ac_keys @@ -1250,6 +1251,7 @@ def visualize_preds(self, predictions, batch): Returns: ims (np.ndarray): (B, H, W, 3) - images with actions drawn on top """ + embodiment_id = batch["embodiment"][0].item() embodiment_name = get_embodiment(embodiment_id).lower() ac_key = self.ac_keys[embodiment_id] diff --git a/egomimic/hydra_configs/data/zarr_test.yaml b/egomimic/hydra_configs/data/zarr_test.yaml new file mode 100644 index 00000000..92eb23c1 --- /dev/null +++ b/egomimic/hydra_configs/data/zarr_test.yaml @@ -0,0 +1,60 @@ +_target_: egomimic.pl_utils.pl_data_utils.MultiDataModuleWrapper + +train_datasets: + scale_bimanual: + _target_: egomimic.rldb.zarr.ZarrDataset + Episode_path: external/scale/scripts/datasets/2026-02-19-03-21-23-570038/697c1e6c0cac8cd3c4873844_episode_000000.zarr + key_map: + front_img_1: + key_type: camera_keys + zarr_key: observations.images.front_img_1 + ee_pose: + key_type: proprio_keys + zarr_key: observations.state.ee_pose + horizon: 100 + actions_cartesian: + key_type: action_keys + zarr_key: actions_ee_se3_world + horizon: 100 + actions_keypoints: + key_type: action_keys + zarr_key: actions_keypoint_world + horizon: 100 + actions_head_cartesian: + key_type: action_keys + zarr_key: actions_head_se3_world + horizon: 100 +valid_datasets: + scale_bimanual: + _target_: egomimic.rldb.zarr.ZarrDataset + Episode_path: external/scale/scripts/datasets/2026-02-19-03-21-23-570038/697c1e6c0cac8cd3c4873844_episode_000000.zarr + key_map: + front_img_1: + key_type: camera_keys + zarr_key: observations.images.front_img_1 + ee_pose: + key_type: proprio_keys + zarr_key: observations.state.ee_pose + horizon: 100 + actions_cartesian: + key_type: action_keys + zarr_key: actions_ee_se3_world + horizon: 100 + actions_keypoints: + key_type: action_keys + zarr_key: actions_keypoint_world + horizon: 100 + actions_head_cartesian: + key_type: action_keys + zarr_key: actions_head_se3_world + horizon: 100 + +train_dataloader_params: + dataset1: + batch_size: 32 + num_workers: 10 + +valid_dataloader_params: + dataset1: + batch_size: 32 + num_workers: 10 \ No newline at end of file diff --git a/egomimic/hydra_configs/model/hpt_bc_flow_scale.yaml b/egomimic/hydra_configs/model/hpt_bc_flow_scale.yaml new file mode 100644 index 00000000..2c9d66ef --- /dev/null +++ b/egomimic/hydra_configs/model/hpt_bc_flow_scale.yaml @@ -0,0 +1,122 @@ +_target_: egomimic.pl_utils.pl_model.ModelWrapper +robomimic_model: + _target_: egomimic.algo.hpt.HPT + data_schematic: _${data.dataset.data_schematic} + camera_transforms: + scale_bimanual: + _target_: egomimic.utils.egomimicUtils.CameraTransforms + intrinsics_key: "scale" # change to base_half if using half res + extrinsics_key: "scale" + + diffusion: true + 6dof: true + + ac_keys: + scale_bimanual: "actions_cartesian" + + trunk: + embed_dim: 256 + num_blocks: 64 + num_heads: 8 + token_postprocessing: "action_token" + observation_horizon: 1 + action_horizon: 64 + no_trunk: false + use_domain_embedding: true + drop_path: 0.1 + weight_init_style: "pytorch" + + multitask: false + pretrained: false + pretrained_checkpoint: "" # TODO + reverse_kl_samples: 8 + + domains: ["scale_bimanual"] + shared_obs_keys: ["front_img_1"] + + shared_stem_specs: + front_img_1: + _target_: egomimic.models.hpt_nets.MLPPolicyStem + input_dim: 256 + output_dim: 256 + widths: [256] + specs: + random_horizon_masking: false + cross_attn: + crossattn_latent: 16 + crossattn_heads: 8 + crossattn_dim_head: 64 + crossattn_modality_dropout: 0.1 + modality_embed_dim: 256 + + stem_specs: + scale_bimanual: + state_ee_pose: + _target_: egomimic.models.hpt_nets.MLPPolicyStem + input_dim: 14 + output_dim: 256 + widths: [256] + specs: + random_horizon_masking: false + cross_attn: + crossattn_latent: 16 + crossattn_heads: 8 + crossattn_dim_head: 64 + crossattn_modality_dropout: 0.1 + modality_embed_dim: 256 + + head_specs: + scale_bimanual: + _target_: egomimic.models.fm_policy.FMPolicy + action_horizon: 100 + num_inference_steps: 50 + pooling: null + time_dist: "beta" + infer_ac_dims: + scale_bimanual: 14 + model: + _target_: egomimic.models.denoising_nets.CrossTransformer + nblocks: 6 + cond_dim: 256 + hidden_dim: 128 + act_dim: 14 + act_seq: 100 + n_heads: 4 + dropout: 0.1 + mlp_layers: 4 + mlp_ratio: 4 + + encoder_specs: + front_img_1: + _target_: egomimic.models.hpt_nets.ResNet + output_dim: 256 + + train_image_augs: + _target_: torchvision.transforms.Compose + transforms: + - _target_: torchvision.transforms.ColorJitter + brightness: 0.1 + contrast: 0.1 + saturation: 0.1 + hue: 0.05 + - _target_: torchvision.transforms.Normalize + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + eval_image_augs: + _target_: torchvision.transforms.Compose + transforms: + - _target_: torchvision.transforms.Normalize + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +optimizer: + _target_: torch.optim.AdamW + _partial_: true + lr: 3e-4 + weight_decay: 0.0001 + +scheduler: + _target_: torch.optim.lr_scheduler.CosineAnnealingLR + _partial_: true + T_max: 1400 + eta_min: 1e-5 \ No newline at end of file diff --git a/egomimic/hydra_configs/train_zarr.yaml b/egomimic/hydra_configs/train_zarr.yaml new file mode 100644 index 00000000..a3487959 --- /dev/null +++ b/egomimic/hydra_configs/train_zarr.yaml @@ -0,0 +1,33 @@ +defaults: + - model: hpt_bc_flow_aria + - paths: default + - trainer: ddp + - debug: null + - logger: wandb + - data: test_multi_zarr + - callbacks: checkpoints + - override hydra/launcher: submitit + - _self_ + +name: test +description: test +ckpt_path: null +train: true +eval: false + +eval_class: + _target_: egomimic.scripts.evaluation.Eve + mode: real + arm: both + eval_path: "./logs/eval/${name}_${now:%Y-%m-%d_%H-%M-%S}" + +hydra: + run: + # Dir should be experiment_name/description_{timestamp} + dir: ./logs/${name}/${description}_${now:%Y-%m-%d_%H-%M-%S} + sweep: + dir: ./logs/${name}/${description}_${now:%Y-%m-%d_%H-%M-%S} + +launch_params: + gpus_per_node: 1 + nodes: 1 diff --git a/egomimic/pl_utils/pl_data_utils.py b/egomimic/pl_utils/pl_data_utils.py index cc1a828c..f4eaf571 100644 --- a/egomimic/pl_utils/pl_data_utils.py +++ b/egomimic/pl_utils/pl_data_utils.py @@ -94,7 +94,7 @@ def val_dataloader(self): iterables = dict() for dataset_name, dataset in self.valid_datasets.items(): dataset_params = self.valid_dataloader_params.get(dataset_name, {}) - iterables[dataset.embodiment] = DataLoader( + iterables[dataset_name] = DataLoader( dataset, shuffle=False, collate_fn=self.collate_fn, diff --git a/egomimic/rldb/.gitignore b/egomimic/rldb/.gitignore index 8f2c486d..9eb5bfa4 100644 --- a/egomimic/rldb/.gitignore +++ b/egomimic/rldb/.gitignore @@ -2,4 +2,6 @@ benchmark_files/ *.egg-info *.parquet *.pyc -*.hdf5 \ No newline at end of file +*.hdf5 +*/lerobot +*/zarr \ No newline at end of file diff --git a/egomimic/rldb/utils.py b/egomimic/rldb/utils.py index 86638451..9ed886cd 100644 --- a/egomimic/rldb/utils.py +++ b/egomimic/rldb/utils.py @@ -94,6 +94,9 @@ class EMBODIMENT(Enum): MECKA_BIMANUAL = 9 MECKA_RIGHT_ARM = 10 MECKA_LEFT_ARM = 11 + SCALE_BIMANUAL = 12 + SCALE_RIGHT_ARM = 13 + SCALE_LEFT_ARM = 14 SEED = 42 diff --git a/egomimic/rldb/zarr/__init__.py b/egomimic/rldb/zarr/__init__.py index 70219109..c23d6f52 100644 --- a/egomimic/rldb/zarr/__init__.py +++ b/egomimic/rldb/zarr/__init__.py @@ -7,11 +7,17 @@ MultiDataset, ZarrDataset, ZarrEpisode, + LocalEpisodeResolver, + S3EpisodeResolver, ) +#from egomimic.rldb.zarr.zarr_writer import ZarrWriter __all__ = [ "EpisodeResolver", "MultiDataset", "ZarrDataset", "ZarrEpisode", + "ZarrWriter", + "LocalEpisodeResolver", + "S3EpisodeResolver", ] diff --git a/egomimic/rldb/zarr/action_chunk_transforms.py b/egomimic/rldb/zarr/action_chunk_transforms.py index 59de1081..40921e1e 100644 --- a/egomimic/rldb/zarr/action_chunk_transforms.py +++ b/egomimic/rldb/zarr/action_chunk_transforms.py @@ -25,7 +25,7 @@ _matrix_to_xyzypr, _xyzwxyz_to_matrix, ) - +from egomimic.utils.egomimicUtils import EXTRINSICS # --------------------------------------------------------------------------- # Base Transform # --------------------------------------------------------------------------- @@ -436,12 +436,16 @@ def build_eva_bimanual_transform_list( obs_key: str = "observations.state.ee_pose", chunk_length: int = 100, stride: int = 1, + extrinsics_key: str = "x5Dec13_2", is_quat: bool = True, - left_extra_batch_key: dict | None = None, - right_extra_batch_key: dict | None = None, ) -> list[Transform]: """Canonical EVA bimanual transform pipeline used by tests and notebooks.""" - transform_list: list[Transform] = [ + extrinsics = EXTRINSICS[extrinsics_key] + left_extrinsics_pose = _matrix_to_xyzwxyz(extrinsics["left"][None, :])[0] + right_extrinsics_pose = _matrix_to_xyzwxyz(extrinsics["right"][None, :])[0] + left_extra_batch_key = {"left_extrinsics_pose": left_extrinsics_pose} + right_extra_batch_key = {"right_extrinsics_pose": right_extrinsics_pose} + transform_list = [ ActionChunkCoordinateFrameTransform( target_world=left_target_world, chunk_world=left_cmd_world, @@ -495,6 +499,7 @@ def build_eva_bimanual_transform_list( stride=stride, ), ] + if is_quat: transform_list.append( XYZWXYZ_to_XYZYPR( @@ -644,4 +649,4 @@ def build_aria_bimanual_transform_list( DeleteKeys(keys_to_delete=keys_to_delete), ] ) - return transform_list + return transform_list \ No newline at end of file diff --git a/egomimic/rldb/zarr/benchmark_forward_pass.py b/egomimic/rldb/zarr/benchmark_forward_pass.py new file mode 100755 index 00000000..63f2dc08 --- /dev/null +++ b/egomimic/rldb/zarr/benchmark_forward_pass.py @@ -0,0 +1,524 @@ +#!/usr/bin/env python3 +""" +Benchmark Zarr data loading speed for forward pass simulation. + +Uses ZarrDataset from zarr_dataset_multi.py for per-episode Zarr loading. + +Measures: +1. DataLoader throughput: Shuffled DataLoader simulating training +2. Per-sample loading breakdown with profiling +""" + +import argparse +import time +from pathlib import Path + +import psutil +import torch +from torch.profiler import profile, ProfilerActivity +from torch.utils.data import ConcatDataset, DataLoader, Dataset +from torch.utils.data._utils.collate import default_collate + +# Local imports +from egomimic.rldb.zarr.zarr_dataset_multi import ZarrDataset, ZarrEpisode + + +def get_memory_mb() -> float: + """Get current process memory usage in MB.""" + process = psutil.Process() + return process.memory_info().rss / (1024 * 1024) + + +def safe_collate(batch: list[dict]) -> dict: + """Collate dict batches while tolerating missing keys across samples.""" + if not batch: + return {} + common_keys = set(batch[0].keys()) + for item in batch[1:]: + common_keys &= set(item.keys()) + return {key: default_collate([item[key] for item in batch]) for key in common_keys} + + +def _infer_batch_size(batch) -> int: + """Best-effort batch size inference for different dataset outputs.""" + if isinstance(batch, dict): + if "frame_index" in batch: + return int(batch["frame_index"].shape[0]) + for value in batch.values(): + if hasattr(value, "shape") and len(value.shape) > 0: + return int(value.shape[0]) + if isinstance(batch, (list, tuple)): + return len(batch) + return 0 + + +def benchmark_dataloader( + dataset: Dataset, + num_samples: int, + batch_size: int, + num_workers: int, + warmup: int, + prefetch_factor: int = 2, + collate_fn=None, + simulated_compute_sec: float = 0.0, + pytorch_profile: bool = False, + profile_output: str | None = None, +) -> dict: + """Benchmark DataLoader throughput with shuffling.""" + dataloader = DataLoader( + dataset, + batch_size=batch_size, + shuffle=True, + num_workers=num_workers, + collate_fn=collate_fn, + prefetch_factor=prefetch_factor if num_workers > 0 else None, + ) + + # Calculate iterations needed + warmup_batches = warmup + benchmark_batches = (num_samples + batch_size - 1) // batch_size + + # Warmup + print(f" Warming up with {warmup_batches} batches...") + batch_iter = iter(dataloader) + for _ in range(warmup_batches): + try: + _ = next(batch_iter) + except StopIteration: + batch_iter = iter(dataloader) + _ = next(batch_iter) + + # Record memory before benchmark + memory_start_mb = get_memory_mb() + + # Benchmark + compute_info = f", simulated_compute={simulated_compute_sec}s" if simulated_compute_sec > 0 else "" + print(f" Benchmarking {benchmark_batches} batches (batch_size={batch_size}, workers={num_workers}, prefetch={prefetch_factor}{compute_info})...") + samples_processed = 0 + progress_step = max(1, benchmark_batches // 10) + total_loading_time = 0.0 + peak_memory_mb = memory_start_mb + memory_samples = [] + + def run_benchmark_loop(): + nonlocal samples_processed, total_loading_time, batch_iter, peak_memory_mb + for i in range(benchmark_batches): + load_start = time.perf_counter() + try: + batch = next(batch_iter) + except StopIteration: + batch_iter = iter(dataloader) + batch = next(batch_iter) + total_loading_time += time.perf_counter() - load_start + + # Track memory usage + current_memory_mb = get_memory_mb() + peak_memory_mb = max(peak_memory_mb, current_memory_mb) + if i % max(1, benchmark_batches // 20) == 0: # Sample memory periodically + memory_samples.append(current_memory_mb) + + # Count actual samples in batch (last batch may be smaller) + batch_samples = _infer_batch_size(batch) + samples_processed += batch_samples + + # Simulate forward/backward pass (allows prefetching to overlap) + if simulated_compute_sec > 0: + time.sleep(simulated_compute_sec) + + if (i + 1) % progress_step == 0 or (i + 1) == benchmark_batches: + print(f" Progress: {i + 1}/{benchmark_batches} ({(i + 1) / benchmark_batches:.0%})") + + total_start = time.perf_counter() + if pytorch_profile: + with profile( + activities=[ProfilerActivity.CPU], + record_shapes=True, + profile_memory=True, + with_stack=True, + ) as prof: + run_benchmark_loop() + print("\n PyTorch Profiler Summary (top 20 by CPU time):") + print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=20)) + if profile_output: + prof.export_chrome_trace(profile_output) + print(f" Trace saved to: {profile_output}") + else: + run_benchmark_loop() + total_elapsed = time.perf_counter() - total_start + + batches_per_sec = benchmark_batches / total_elapsed if total_elapsed > 0 else 0 + avg_loading_time_per_batch = total_loading_time / benchmark_batches if benchmark_batches > 0 else 0 + + # Actual overhead: how much longer did training take vs pure compute? + expected_compute_time = simulated_compute_sec * benchmark_batches + actual_overhead = total_elapsed - expected_compute_time + avg_overhead_per_batch = actual_overhead / benchmark_batches if benchmark_batches > 0 else 0 + + # Memory statistics + memory_end_mb = get_memory_mb() + memory_delta_mb = memory_end_mb - memory_start_mb + avg_memory_mb = sum(memory_samples) / len(memory_samples) if memory_samples else memory_end_mb + + return { + "batches_per_sec": batches_per_sec, + "samples_processed": samples_processed, + "avg_loading_time_per_batch": avg_loading_time_per_batch, + "avg_overhead_per_batch": avg_overhead_per_batch, + "total_elapsed_sec": total_elapsed, + "total_loading_time_sec": total_loading_time, + "simulated_compute_sec": simulated_compute_sec, + "memory_start_mb": memory_start_mb, + "memory_end_mb": memory_end_mb, + "peak_memory_mb": peak_memory_mb, + "memory_delta_mb": memory_delta_mb, + "avg_memory_mb": avg_memory_mb, + } + + +def run_benchmarks( + name: str, + dataset: Dataset, + num_samples: int, + batch_size: int, + num_workers: int, + warmup: int, + prefetch_factor: int, + collate_fn, + simulated_compute_sec: float = 0.0, + pytorch_profile: bool = False, + profile_output: str | None = None, +) -> dict: + """Run dataloader benchmark and return results for side-by-side comparison.""" + total_frames = len(dataset) + print(f"\n== {name} ==") + print(f"Total frames: {total_frames}") + if total_frames == 0: + print("Error: Dataset has no frames!") + return { + "name": name, + "total_frames": 0, + "dataloader": None, + } + + num_samples = min(num_samples, total_frames) + + dataloader_results = benchmark_dataloader( + dataset, + num_samples=num_samples, + batch_size=batch_size, + num_workers=num_workers, + warmup=warmup, + prefetch_factor=prefetch_factor, + collate_fn=collate_fn, + simulated_compute_sec=simulated_compute_sec, + pytorch_profile=pytorch_profile, + profile_output=profile_output, + ) + + return { + "name": name, + "total_frames": total_frames, + "dataloader": dataloader_results, + } + + +def print_results_table(results: list[dict]) -> None: + """Print benchmark results in a table format.""" + if not results: + return + + # Filter out results with no dataloader data + valid_results = [r for r in results if r.get("dataloader")] + if not valid_results: + return + + # Build table data + headers = ["Metric"] + [r["name"] for r in valid_results] + rows = [] + + # Total frames + rows.append(["Total frames"] + [f"{r['total_frames']:,}" for r in valid_results]) + + # Init time + if all(r.get("init_time_sec") is not None for r in valid_results): + rows.append(["Init time (s)"] + [f"{r['init_time_sec']:.3f}" for r in valid_results]) + + # Dataloader metrics + rows.append(["Batches/sec"] + [f"{r['dataloader']['batches_per_sec']:.1f}" for r in valid_results]) + rows.append(["Avg load time/batch (ms)"] + [f"{r['dataloader']['avg_loading_time_per_batch']*1000:.1f}" for r in valid_results]) + rows.append(["Avg overhead/batch (ms)"] + [f"{r['dataloader']['avg_overhead_per_batch']*1000:.1f}" for r in valid_results]) + rows.append(["Total time (s)"] + [f"{r['dataloader']['total_elapsed_sec']:.2f}" for r in valid_results]) + rows.append(["Samples processed"] + [f"{r['dataloader']['samples_processed']:,}" for r in valid_results]) + + # Memory metrics + rows.append(["Memory start (MB)"] + [f"{r['dataloader']['memory_start_mb']:.1f}" for r in valid_results]) + rows.append(["Memory end (MB)"] + [f"{r['dataloader']['memory_end_mb']:.1f}" for r in valid_results]) + rows.append(["Peak memory (MB)"] + [f"{r['dataloader']['peak_memory_mb']:.1f}" for r in valid_results]) + rows.append(["Memory delta (MB)"] + [f"{r['dataloader']['memory_delta_mb']:+.1f}" for r in valid_results]) + rows.append(["Avg memory (MB)"] + [f"{r['dataloader']['avg_memory_mb']:.1f}" for r in valid_results]) + + # Calculate column widths + col_widths = [max(len(str(row[i])) for row in [headers] + rows) for i in range(len(headers))] + + # Print table + print("\n" + "=" * (sum(col_widths) + 3 * len(col_widths) + 1)) + print("| " + " | ".join(h.ljust(col_widths[i]) for i, h in enumerate(headers)) + " |") + print("|" + "|".join("-" * (w + 2) for w in col_widths) + "|") + for row in rows: + print("| " + " | ".join(str(v).rjust(col_widths[i]) for i, v in enumerate(row)) + " |") + print("=" * (sum(col_widths) + 3 * len(col_widths) + 1)) + + +def build_zarr_dataset( + root: Path, + max_episodes: int | None = None, + action_horizon: int | None = None, +) -> tuple[Dataset, str, int]: + """ + Load Zarr dataset from root directory. + + Supports two structures: + 1. Single episode: root is a .zarr directory + 2. Multiple episodes: root contains multiple .zarr directories + + Args: + root: Path to dataset root + max_episodes: Maximum number of episodes to load (for debugging) + action_horizon: Number of future action timesteps to load per sample + + Returns: + Tuple of (dataset, name, num_episodes) + """ + root = root.resolve() + + # Check if root itself is a .zarr episode + if root.suffix == ".zarr": + print(f" Loading single episode: {root.name}") + dataset = ZarrDataset(str(root), action_horizon=action_horizon) + return dataset, f"Zarr ({root.name})", 1 + + # Look for .zarr episode directories + episode_dirs = sorted([ + path for path in root.iterdir() + if path.is_dir() and path.suffix == ".zarr" + ]) + + if not episode_dirs: + raise FileNotFoundError( + f"No .zarr episode directories found in {root}" + ) + + # Limit episodes if requested + if max_episodes is not None: + episode_dirs = episode_dirs[:max_episodes] + + print(f" Found {len(episode_dirs)} episodes") + + datasets = [] + total_frames = 0 + for i, episode_dir in enumerate(episode_dirs): + if (i + 1) % max(1, len(episode_dirs) // 10) == 0 or i == 0: + print(f" Loading episode {i + 1}/{len(episode_dirs)}: {episode_dir.name}") + ds = ZarrDataset(str(episode_dir), action_horizon=action_horizon) + datasets.append(ds) + total_frames += len(ds) # Triggers init_episode during loop with progress output + + print(f" Total frames: {total_frames:,}") + print(f" Creating ConcatDataset...") + dataset = ConcatDataset(datasets) # Now fast - lengths already cached + return dataset, f"Zarr ({root.name}, {len(datasets)} episodes)", len(datasets) + + +def profile_single_episode( + episode_path: Path, + num_samples: int = 100, +) -> None: + """Profile loading performance for a single episode.""" + print(f"\n== Profiling Single Episode ==") + print(f"Episode: {episode_path.name}") + + dataset = ZarrDataset(str(episode_path)) + total_frames = len(dataset) + num_samples = min(num_samples, total_frames) + + print(f"Total frames: {total_frames}") + print(f"Profiling {num_samples} samples...") + + # Warmup + for i in range(min(10, num_samples)): + _ = dataset[i] + + # Profile + times = [] + for i in range(num_samples): + start = time.perf_counter() + _ = dataset[i] + elapsed = time.perf_counter() - start + times.append(elapsed) + + times = sorted(times) + print(f"\nLoading time per sample:") + print(f" Min: {times[0]*1000:.2f}ms") + print(f" Median: {times[len(times)//2]*1000:.2f}ms") + print(f" Mean: {sum(times)/len(times)*1000:.2f}ms") + print(f" P95: {times[int(len(times)*0.95)]*1000:.2f}ms") + print(f" Max: {times[-1]*1000:.2f}ms") + + +def main(): + # Check multiprocessing context + import torch.multiprocessing as mp + print(f"Multiprocessing start method: {mp.get_start_method()}") + + parser = argparse.ArgumentParser( + description="Benchmark Zarr data loading speed for forward pass simulation", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Benchmark single episode + %(prog)s --zarr-path /data/episode_000000.zarr + + # Benchmark multiple episodes + %(prog)s --zarr-path /data/zarr_episodes --max-episodes 10 + + # Profile single episode + %(prog)s --zarr-path /data/episode_000000.zarr --profile-episode + + # Benchmark with simulated compute + %(prog)s --zarr-path /data/zarr_episodes --simulated-compute 0.05 + """ + ) + + # Dataset source + parser.add_argument( + "--zarr-path", + type=str, + required=True, + help="Path to Zarr dataset (single .zarr episode or directory containing episodes)", + ) + + # Benchmark parameters + parser.add_argument( + "--num-samples", + type=int, + default=5000, + help="Number of samples to load via DataLoader (default: 5000)", + ) + parser.add_argument( + "--batch-size", + type=int, + default=32, + help="Batch size for DataLoader test (default: 32)", + ) + parser.add_argument( + "--num-workers", + type=int, + default=10, + help="DataLoader workers (default: 10)", + ) + parser.add_argument( + "--prefetch-factor", + type=int, + default=2, + help="DataLoader prefetch factor (default: 2)", + ) + parser.add_argument( + "--simulated-compute", + type=float, + default=0.0, + help="Simulated forward/backward pass time in seconds per batch (default: 0.0). " + "Use this to test whether data loading can keep up with GPU compute.", + ) + parser.add_argument( + "--warmup", + type=int, + default=10, + help="Warmup iterations before timing (default: 10)", + ) + parser.add_argument( + "--max-episodes", + type=int, + default=None, + help="Limit number of episode directories to load (for debugging)", + ) + parser.add_argument( + "--pytorch-profile", + action="store_true", + help="Use PyTorch profiler for detailed performance breakdown", + ) + parser.add_argument( + "--profile-output", + type=str, + default=None, + help="Path to save PyTorch profiler trace (for Chrome trace viewer)", + ) + parser.add_argument( + "--profile-episode", + action="store_true", + help="Profile single-episode loading performance (requires single .zarr path)", + ) + parser.add_argument( + "--profile-samples", + type=int, + default=100, + help="Number of samples to profile for single-episode profiling", + ) + parser.add_argument( + "--action-horizon", + type=int, + default=None, + help="Number of future action timesteps to load per sample (enables dynamic chunking)", + ) + + args = parser.parse_args() + + # Display action chunking info if enabled + if args.action_horizon is not None: + print(f"NOTE: Action chunking enabled (horizon={args.action_horizon})") + print(" - actions_base_cartesian and actions_joints will be loaded as sequences") + print(f" - Shape: (action_horizon={args.action_horizon}, action_dim)\n") + + print("=== Zarr Forward Pass Benchmark ===\n") + + zarr_path = Path(args.zarr_path).resolve() + + # Profile single episode if requested + if args.profile_episode: + if not zarr_path.suffix == ".zarr": + parser.error("--profile-episode requires a single .zarr episode path") + profile_single_episode(zarr_path, num_samples=args.profile_samples) + return + + # Load dataset + print("Loading Zarr dataset...") + zarr_init_start = time.perf_counter() + zarr_dataset, zarr_name, num_episodes = build_zarr_dataset( + zarr_path, + max_episodes=args.max_episodes, + action_horizon=args.action_horizon, + ) + zarr_init_time = time.perf_counter() - zarr_init_start + print(f" Initialization time: {zarr_init_time:.3f}s") + + # Run benchmark + result = run_benchmarks( + name=zarr_name, + dataset=zarr_dataset, + num_samples=args.num_samples, + batch_size=args.batch_size, + num_workers=args.num_workers, + warmup=args.warmup, + prefetch_factor=args.prefetch_factor, + collate_fn=safe_collate, + simulated_compute_sec=args.simulated_compute, + pytorch_profile=args.pytorch_profile, + profile_output=args.profile_output, + ) + result["init_time_sec"] = zarr_init_time + + print_results_table([result]) + print("\n=== Benchmark Complete ===") + + +if __name__ == "__main__": + main() diff --git a/egomimic/rldb/zarr/test_zarr.py b/egomimic/rldb/zarr/test_zarr.py index 7b484584..7ddaea92 100644 --- a/egomimic/rldb/zarr/test_zarr.py +++ b/egomimic/rldb/zarr/test_zarr.py @@ -3,6 +3,7 @@ import numpy as np import pytest import torch +from scipy.spatial.transform import Rotation as R from egomimic.rldb.utils import S3RLDBDataset from egomimic.rldb.zarr.action_chunk_transforms import ( @@ -50,6 +51,24 @@ ) ARIA_IMAGE_KEYS = {"observations.images.front_img_1"} +SCALE_LEROBOT_EPISODE_HASH = "697c1e6c0cac8cd3c4873844" +SCALE_ZARR_EPISODE_PATH = Path( + "/nethome/agao81/flash/EgoVerse/external/scale/scripts/datasets/2026-02-20-18-52-08-062985/697c1e6c0cac8cd3c4873844_episode_000000.zarr" +) +SCALE_EMBODIMENT = "scale_bimanual" +SCALE_CACHE_ROOT = "/coc/flash7/scratch/.cache" +SCALE_ACTION_HORIZON_REAL = 30 +SCALE_ACTION_CHUNK_LENGTH = 100 +SCALE_ACTION_STRIDE = 1 +# zarr_key -> lerobot_key mapping for comparison +SCALE_KEY_MAP = { + "observations.images.front_img_1": "observations.images.front_img_1", + "actions_cartesian": "actions_ee_cartesian_cam", + "observations.state.ee_pose": "observations.state.ee_pose_cam", +} +SCALE_IMAGE_KEYS = {"observations.images.front_img_1"} +SCALE_KEYPOINT_KEYS = ("left.obs_keypoints", "right.obs_keypoints") + def _to_numpy(value): if isinstance(value, torch.Tensor): @@ -59,6 +78,50 @@ def _to_numpy(value): return value +def _assert_scale_pose_equivalent(zarr_val: np.ndarray, lerobot_val: np.ndarray, key_name: str) -> None: + if zarr_val.shape[-1] != 12 or lerobot_val.shape[-1] != 12: + np.testing.assert_allclose( + zarr_val, + lerobot_val, + atol=1e-5, + err_msg=f"{key_name}: expected last dim 12 for pose comparison", + ) + return + + np.testing.assert_allclose( + zarr_val[..., :3], + lerobot_val[..., :3], + rtol=0.0, + atol=1e-4, + err_msg=f"{key_name}: left xyz mismatch", + ) + np.testing.assert_allclose( + zarr_val[..., 6:9], + lerobot_val[..., 6:9], + rtol=0.0, + atol=1e-4, + err_msg=f"{key_name}: right xyz mismatch", + ) + + z_left = zarr_val[..., 3:6].reshape(-1, 3) + l_left = lerobot_val[..., 3:6].reshape(-1, 3) + z_right = zarr_val[..., 9:12].reshape(-1, 3) + l_right = lerobot_val[..., 9:12].reshape(-1, 3) + + np.testing.assert_allclose( + R.from_euler("ZYX", z_left, degrees=False).as_matrix(), + R.from_euler("zyx", l_left, degrees=False).as_matrix(), + atol=1e-5, + err_msg=f"{key_name}: left YPR rotation mismatch", + ) + np.testing.assert_allclose( + R.from_euler("ZYX", z_right, degrees=False).as_matrix(), + R.from_euler("zyx", l_right, degrees=False).as_matrix(), + atol=1e-5, + err_msg=f"{key_name}: right YPR rotation mismatch", + ) + + def _check_equal_dict(left: dict, right: dict, path: str = "root") -> None: assert set(left.keys()) == set(right.keys()), ( f"{path}: key mismatch. left_only={set(left.keys()) - set(right.keys())}, " @@ -288,3 +351,95 @@ def test_zarr_batch_matches_lerobot_batch_aria() -> None: } _check_equal_dict(non_image_lerobot, non_image_zarr) + + +# --------------------------------------------------------------------------- +# Scale bimanual helpers & test +# --------------------------------------------------------------------------- + + +def _build_zarr_dataset_scale() -> MultiDataset: + """Build a Scale zarr dataset with Aria-style head-frame transform.""" + key_map = { + "observations.images.front_img_1": {"zarr_key": "images.front_1"}, + "left.obs_ee_pose": {"zarr_key": "left.obs_ee_pose"}, + "right.obs_ee_pose": {"zarr_key": "right.obs_ee_pose"}, + "left.action_ee_pose": { + "zarr_key": "left.obs_ee_pose", + "horizon": SCALE_ACTION_HORIZON_REAL, + }, + "right.action_ee_pose": { + "zarr_key": "right.obs_ee_pose", + "horizon": SCALE_ACTION_HORIZON_REAL, + }, + "obs_head_pose": {"zarr_key": "obs_head_pose"}, + } + + transform_list = build_aria_bimanual_transform_list( + chunk_length=SCALE_ACTION_CHUNK_LENGTH, + stride=SCALE_ACTION_STRIDE, + left_action_world="left.action_ee_pose", + right_action_world="right.action_ee_pose", + target_world_is_quat=False, + actions_key="actions_cartesian", + obs_key="observations.state.ee_pose", + ) + + single_dataset = ZarrDataset( + Episode_path=SCALE_ZARR_EPISODE_PATH, + key_map=key_map, + transform_list=transform_list, + ) + return MultiDataset(datasets={"single_episode": single_dataset}, mode="total") + + +def _build_lerobot_dataset_scale() -> S3RLDBDataset: + return S3RLDBDataset( + filters={"episode_hash": SCALE_LEROBOT_EPISODE_HASH}, + mode="total", + cache_root=SCALE_CACHE_ROOT, + embodiment=SCALE_EMBODIMENT, + ) + + +def test_zarr_batch_matches_lerobot_batch_scale() -> None: + if not SCALE_ZARR_EPISODE_PATH.exists(): + pytest.skip(f"Scale zarr path not found: {SCALE_ZARR_EPISODE_PATH}") + + zarr_batch = _first_batch(_build_zarr_dataset_scale()) + lerobot_batch = _first_batch(_build_lerobot_dataset_scale()) + + # Check that expected keys exist in each batch (under their own names) + missing_zarr = [z for z in SCALE_KEY_MAP if z not in zarr_batch] + assert not missing_zarr, f"Zarr batch missing keys: {missing_zarr}" + + missing_lr = [l for l in SCALE_KEY_MAP.values() if l not in lerobot_batch] + assert not missing_lr, f"Lerobot batch missing keys: {missing_lr}" + + for zarr_key, lerobot_key in SCALE_KEY_MAP.items(): + zarr_val = _to_numpy(zarr_batch[zarr_key]) + lerobot_val = _to_numpy(lerobot_batch[lerobot_key]) + + if zarr_key in SCALE_IMAGE_KEYS: + assert isinstance(zarr_val, np.ndarray) and isinstance(lerobot_val, np.ndarray), ( + f"{zarr_key}: expected arrays, got {type(zarr_val)} / {type(lerobot_val)}" + ) + assert zarr_val.shape == lerobot_val.shape, ( + f"{zarr_key}: image shape mismatch {zarr_val.shape} vs {lerobot_val.shape}" + ) + else: + assert isinstance(zarr_val, np.ndarray) and isinstance(lerobot_val, np.ndarray), ( + f"{zarr_key}->{lerobot_key}: expected arrays, got " + f"{type(zarr_val)} / {type(lerobot_val)}" + ) + if zarr_key in {"actions_cartesian", "observations.state.ee_pose"}: + _assert_scale_pose_equivalent( + zarr_val, + lerobot_val, + key_name=f"{zarr_key} (zarr) vs {lerobot_key} (lerobot)", + ) + else: + np.testing.assert_allclose( + zarr_val, lerobot_val, atol=1e-5, + err_msg=f"{zarr_key} (zarr) vs {lerobot_key} (lerobot)", + ) \ No newline at end of file diff --git a/egomimic/rldb/zarr/utils.py b/egomimic/rldb/zarr/utils.py new file mode 100644 index 00000000..da9eaa97 --- /dev/null +++ b/egomimic/rldb/zarr/utils.py @@ -0,0 +1,396 @@ +import pandas as pd +import numpy as np +import torch +import ast +from egomimic.rldb.utils import get_embodiment_id +import logging + +logger = logging.getLogger(__name__) + +class DataSchematic(object): + def __init__(self, schematic_dict, viz_img_key, norm_mode="zscore"): + """ + Initialize with a schematic dictionary and create a DataFrame. + + + Args: + schematic_dict: + {embodiment_name}: + front_img_1_line: + key_type: camera_keys + zarr_key: front_img_1 + right_wrist_img: + key_type: camera_keys + zarr_key: right_wrist_img + joint_positions: + key_type: proprio_keys + zarr_key: joint_positions + actions_joints_act: + key_type: action_keys + zarr_key: actions_joints + . + . + . + . + + + Attributes: + df (pd.DataFrame): Columns include 'key_name', 'key_type', and 'shape', 'embodiment'. + """ + + rows = [] + self.embodiments = set() + + for embodiment, schematic in schematic_dict.items(): + embodiment_id = get_embodiment_id(embodiment) + self.embodiments.add(embodiment_id) + for key_name, key_info in schematic.items(): + rows.append( + { + "key_name": key_name, + "key_type": key_info["key_type"], + "zarr_key": key_info["zarr_key"], + "shape": None, + "embodiment": embodiment_id, + } + ) + + self.df = pd.DataFrame(rows) + self._viz_img_key = {get_embodiment_id(k): v for k, v in viz_img_key.items()} + self.shapes_infered = False + self.norm_mode = norm_mode + self.norm_stats = {emb: {} for emb in self.embodiments} + + def zarr_key_to_keyname(self, zarr_key, embodiment): + """ + Get the key name from the zarr key. + + + Args: + zarr_key (str): zarr key, e.g., "front_img_1". + embodiment (int): int id corresponding to embodiment + + + + + Returns: + str: Key name, e.g., "front_img_1". + """ + df_filtered = self.df[ + (self.df["zarr_key"] == zarr_key) + & (self.df["embodiment"] == embodiment) + ] + + if df_filtered.empty: + return None + + return df_filtered["key_name"].item() + + def keyname_to_zarr_key(self, key_name, embodiment): + """ + Get the zarr key from the key name. + + + Args: + key_name (str): Key name, e.g., "front_img_1_line". + embodiment (int): int id corresponding to embodiment + + + Returns: + str: zarr key, e.g., "front_img_1". + """ + df_filtered = self.df[ + (self.df["key_name"] == key_name) & (self.df["embodiment"] == embodiment) + ] + + if df_filtered.empty: + return None + return df_filtered["zarr_key"].item() + + def infer_shapes_from_batch(self, batch): + """ + Update shapes in the DataFrame based on a batch. + + + Args: + batch (dict): Maps key names (str) to tensors with shapes, e.g., + {"key": tensor of shape (3, 480, 640, 3)}. + + + Updates: + The 'shape' column in the DataFrame is updated to match the inferred shapes (stored as tuples). + """ + for key, tensor in batch.items(): + if hasattr(tensor, "shape"): + shape = tuple(tensor.shape) + elif isinstance(tensor, int): + shape = (1,) + else: + shape = None + if key in self.df["key_name"].values: + self.df.loc[self.df["key_name"] == key, "shape"] = str(shape) + + self.shapes_infered = True + + def infer_norm_from_dataset_zarr(self, dataset, dataset_name): + """ + dataset: huggingface dataset or zarr dataset + returns: dictionary of means and stds for proprio and action keys + """ + norm_columns = [] + + embodiment = dataset_name # TODO may need to clean this up to make the code nicer + if isinstance(embodiment, str): + embodiment = get_embodiment_id(embodiment) + + norm_columns.extend(self.keys_of_type("proprio_keys")) + norm_columns.extend(self.keys_of_type("action_keys")) + + logger.info( + f"[NormStats] Starting norm inference for embodiment={embodiment}, " + f"{len(norm_columns)} columns" + ) + + def get_zarr_data(ds, col): + if hasattr(ds, "episode_reader"): + # ZarrDataset + if col in ds.episode_reader._store: + return ds.episode_reader._store[col][:] + return None + elif hasattr(ds, "datasets"): + # MultiDataset wrapper + data_list = [] + for d in ds.datasets.values(): + res = get_zarr_data(d, col) + if res is not None: + data_list.append(res) + if data_list: + return np.concatenate(data_list, axis=0) + return None + + for column in norm_columns: + if not self.is_key_with_embodiment(column, embodiment): + continue + column_name = self.keyname_to_zarr_key(column, embodiment) # zarr key for retrieval + logger.info(f"[NormStats] Processing column={column_name}") + + column_data = get_zarr_data(dataset, column_name) + + if column_data is None: + logger.warning(f"Skipping {column_name}, data not found given dataset type") + continue + + if column_data.ndim not in (2, 3): + raise ValueError( + f"Column {column} has shape {column_data.shape}, " + "expected 2 or 3 dims" + ) + + mean = np.mean(column_data, axis=0) + std = np.std(column_data, axis=0) + minv = np.min(column_data, axis=0) + maxv = np.max(column_data, axis=0) + median = np.median(column_data, axis=0) + q1 = np.percentile(column_data, 1, axis=0) + q99 = np.percentile(column_data, 99, axis=0) + + self.norm_stats[embodiment][column] = { + "mean": torch.from_numpy(mean).float(), + "std": torch.from_numpy(std).float(), + "min": torch.from_numpy(minv).float(), + "max": torch.from_numpy(maxv).float(), + "median": torch.from_numpy(median).float(), + "quantile_1": torch.from_numpy(q1).float(), + "quantile_99": torch.from_numpy(q99).float(), + } + + logger.info("[NormStats] Finished norm inference") + + def viz_img_key(self): + """ + Get the key that should be used for offline visualization + """ + return self._viz_img_key + + def all_keys(self): + """ + Get all key names. + + + Returns: + list: Key names (str). + """ + return self.df["key_name"].tolist() + + def is_key_with_embodiment(self, key_name, embodiment): + """ + Check if a key_name exists with a given embodiment + + + Args: + key_name (str): name of key, e.g. actions_joints + embodiment (int): integer id of embodiment + + + Returns: + bool: if the key exists. + """ + return ( + (self.df["key_name"] == key_name) & (self.df["embodiment"] == embodiment) + ).any() + + def keys_of_type(self, key_type): + """ + Get keys of a specific type. + + + Args: + key_type (str): Type of keys, e.g., "camera_keys", "proprio_keys", "action_keys", "metadata_keys". + + + Returns: + list: Key names (str) of the given type. + """ + return self.df[self.df["key_type"] == key_type]["key_name"].tolist() + + def action_keys(self): + return self.keys_of_type("action_keys") + + def key_shape(self, key, embodiment): + """ + Get the shape of a specific key. + + + Args: + key (str): Name of the key. + embodiment (int): integer id of embodiment + + + Returns: + tuple or None: Shape as a tuple, or None if not found. + """ + if key not in self.df["key_name"].values: + raise ValueError(f"Keyname '{key}' is not in the schematic") + + df_filtered = self.df[ + (self.df["key_name"] == key) & (self.df["embodiment"] == embodiment) + ] + + if df_filtered.empty: + raise ValueError(f"Keyname '{key}' with embodiment {embodiment} not found.") + + shape = df_filtered["shape"].item() + return ast.literal_eval(shape) + + def normalize_data(self, data, embodiment): + """ + Normalize data using the stored normalization statistics. + + + Args: + data (dict): Maps key names to tensors. + joint_positions: tensor of shape (B, S, 7) + embodiment (int): Id of the embodiment. + + + Returns: + dict: Maps key names to normalized tensors. + """ + if self.norm_stats is None: + raise ValueError( + "Normalization statistics not set. Call infer_norm_from_dataset_zarr() first." + ) + + norm_data = {} + for key, tensor in data.items(): + if key in self.keys_of_type("proprio_keys") or key in self.keys_of_type( + "action_keys" + ): + if ( + embodiment not in self.norm_stats + or key not in self.norm_stats[embodiment] + ): + raise ValueError( + f"Missing normalization stats for key {key} and embodiment {embodiment}." + ) + + stats = self.norm_stats[embodiment][key] + if self.norm_mode == "zscore": + mean = stats["mean"].to(tensor.device) + std = stats["std"].to(tensor.device) + norm_data[key] = (tensor - mean) / (std + 1e-6) + elif self.norm_mode == "minmax": + min = stats["min"].to(tensor.device) + max = stats["max"].to(tensor.device) + ndata = (tensor - min) / (max - min + 1e-6) + norm_data[key] = 2.0 * ndata - 1.0 + elif self.norm_mode == "quantile": + quantile_1 = stats["quantile_1"].to(tensor.device) + quantile_99 = stats["quantile_99"].to(tensor.device) + ndata = (tensor - quantile_1) / (quantile_99 - quantile_1 + 1e-6) + norm_data[key] = 2.0 * ndata - 1.0 + else: + raise ValueError(f"Invalid normalization mode: {self.norm_mode}") + else: + norm_data[key] = tensor + + return norm_data + + def unnormalize_data(self, data, embodiment): + """ + Unnormalize data using the stored normalization statistics. + + + Args: + data (dict): Maps key names to tensors. + joint_positions: tensor of shape (B, S, 7) + embodiment (int): Id of the embodiment. + + + Returns: + dict: Maps key names to denormalized tensors. + """ + if self.norm_stats is None: + raise ValueError( + "Normalization statistics not set. Call infer_norm_from_dataset_zarr() first." + ) + + denorm_data = {} + for key, tensor in data.items(): + if key in self.keys_of_type("proprio_keys") or key in self.keys_of_type( + "action_keys" + ): + if ( + embodiment not in self.norm_stats + or key not in self.norm_stats[embodiment] + ): + raise ValueError( + f"Missing normalization stats for key {key} and embodiment {embodiment}." + ) + + stats = self.norm_stats[embodiment][key] + if self.norm_mode == "zscore": + mean = stats["mean"].to(tensor.device) + std = stats["std"].to(tensor.device) + denorm_data[key] = tensor * (std + 1e-6) + mean + + elif self.norm_mode == "minmax": + min_val = stats["min"].to(tensor.device) + max_val = stats["max"].to(tensor.device) + denorm_data[key] = (tensor + 1) * 0.5 * ( + max_val - min_val + 1e-6 + ) + min_val + + elif self.norm_mode == "quantile": + quantile_1 = stats["quantile_1"].to(tensor.device) + quantile_99 = stats["quantile_99"].to(tensor.device) + denorm_data[key] = (tensor + 1) * 0.5 * ( + quantile_99 - quantile_1 + 1e-6 + ) + quantile_1 + + else: + raise ValueError(f"Invalid normalization mode: {self.norm_mode}") + else: + denorm_data[key] = tensor + + return denorm_data \ No newline at end of file diff --git a/egomimic/rldb/zarr/zarr_dataset_multi.py b/egomimic/rldb/zarr/zarr_dataset_multi.py index f8d6f7e7..37aa09b6 100644 --- a/egomimic/rldb/zarr/zarr_dataset_multi.py +++ b/egomimic/rldb/zarr/zarr_dataset_multi.py @@ -152,13 +152,13 @@ def __init__( def resolve( self, - filters: dict = {}, - ) -> list[tuple[str, str]]: + filters: dict | None = None, + ) -> dict[str, "ZarrDataset"]: """ - Outputs a list of ZarrDatasets with relevant filters. - If sync_from_s3 is True, sync S3 paths to local_root before indexing. - If not True, assumes folders already exist locally. + Outputs a dict of ZarrDatasets with relevant filters. + Syncs S3 paths to local_root before indexing. """ + filters = dict(filters) if filters is not None else {} filters["is_deleted"] = False if self.folder_path.is_dir(): @@ -189,30 +189,31 @@ def resolve( return datasets @staticmethod - def _get_filtered_paths(filters: dict = {}) -> list[tuple[str, str]]: + def _get_filtered_paths(filters: dict | None = None) -> list[tuple[str, str]]: """ Filters episodes from the SQL episode table according to the criteria specified in `filters` - and returns a list of (processed_path, episode_hash) tuples for episodes that match and have - a non-null processed_path. + and returns a list of (zarr_processed_path, episode_hash) tuples for episodes that match and + have a non-null zarr_processed_path. Args: filters (dict): Dictionary of filter key-value pairs to apply on the episode table. Returns: - list[tuple[str, str]]: List of tuples, each containing (processed_path, episode_hash) + list[tuple[str, str]]: List of tuples, each containing (zarr_processed_path, episode_hash) for episodes passing the filter criteria. """ + filters = dict(filters) if filters is not None else {} engine = create_default_engine() df = episode_table_to_df(engine) series = pd.Series(filters) output = df.loc[ (df[list(filters)] == series).all(axis=1), - ["processed_path", "episode_hash"], + ["zarr_processed_path", "episode_hash"], ] - skipped = df[df["processed_path"].isnull()]["episode_hash"].tolist() + skipped = df[df["zarr_processed_path"].isnull()]["episode_hash"].tolist() logger.info( - f"Skipped {len(skipped)} episodes with null processed_path: {skipped}" + f"Skipped {len(skipped)} episodes with null zarr_processed_path: {skipped}" ) output = output[~output["episode_hash"].isin(skipped)] @@ -339,7 +340,11 @@ def _local_filters_match(metadata: dict, episode_hash: str, filters: dict) -> bo continue if key == "robot_name": - meta_value = metadata.get("robot_name", metadata.get("robot_type")) + meta_value = ( + metadata.get("robot_name") + or metadata.get("robot_type") + or metadata.get("embodiment") + ) elif key == "is_deleted": meta_value = metadata.get("is_deleted", False) else: @@ -381,15 +386,15 @@ def _get_local_filtered_paths(cls, search_path: Path, filters: dict): def resolve( self, sync_from_s3=False, - filters={}, - ) -> list[tuple[str, str]]: + filters: dict | None = None, + ) -> dict[str, "ZarrDataset"]: """ - Outputs a list of ZarrDatasets with relevant filters from local data. + Outputs a dict of ZarrDatasets with relevant filters from local data. """ if sync_from_s3: logger.warning("LocalEpisodeResolver does not sync from S3; ignoring sync_from_s3=True.") - filters = dict(filters or {}) + filters = dict(filters) if filters is not None else {} filters.setdefault("is_deleted", False) filtered_paths = self._get_local_filtered_paths(self.folder_path, filters) @@ -429,13 +434,6 @@ def __init__(self, valid_ratio (float, optional): Validation split ratio for datasets that support a train/valid split. **kwargs: Additional keyword arguments passed to underlying dataset constructors if needed. """ - self.datasets = datasets - - self.index_map = [] - for dataset_name, dataset in self.datasets.items(): - for local_idx in range(len(dataset)): - self.index_map.append((dataset_name, local_idx)) - self.train_collections, self.valid_collections = split_dataset_names( datasets.keys(), valid_ratio=valid_ratio, seed=SEED ) @@ -458,8 +456,13 @@ def __init__(self, else: raise ValueError(f"Unknown mode: {mode}") - datasets = {rid: ds for rid, ds in datasets.items() if rid in chosen} - assert datasets, "No datasets left after applying mode split." + self.datasets = {rid: ds for rid, ds in datasets.items() if rid in chosen} + assert self.datasets, "No datasets left after applying mode split." + + self.index_map = [] + for dataset_name, dataset in self.datasets.items(): + for local_idx in range(len(dataset)): + self.index_map.append((dataset_name, local_idx)) super().__init__() @@ -492,10 +495,13 @@ def _from_resolver(cls, resolver: EpisodeResolver, **kwargs): sync_from_s3 = kwargs.pop("sync_from_s3", False) filters = kwargs.pop("filters", {}) or {} - resolved = resolver.resolve( - sync_from_s3=sync_from_s3, - filters=filters, - ) + if isinstance(resolver, LocalEpisodeResolver): + resolved = resolver.resolve( + sync_from_s3=sync_from_s3, + filters=filters, + ) + else: + resolved = resolver.resolve(filters=filters) return cls(datasets=resolved, **kwargs) diff --git a/egomimic/rldb/zarr/zarr_write_test.py b/egomimic/rldb/zarr/zarr_write_test.py new file mode 100644 index 00000000..be9aa373 --- /dev/null +++ b/egomimic/rldb/zarr/zarr_write_test.py @@ -0,0 +1,498 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Convert HDF5 episodes to Zarr format using ZarrWriter and EvaHD5Extractor. + +This module provides a utility for converting Eva HDF5 episode files +to the Zarr v3 format compatible with ZarrEpisode reader, with full +forward kinematics, action preprocessing, and camera frame transformations. + +Usage: + # Convert a single episode + python zarr_write_test.py --hdf5-path /path/to/episode.hdf5 --output-dir /output/zarr --arm both --extrinsics-key x5Dec13_2 + + # Convert all episodes in a directory + python zarr_write_test.py --hdf5-dir /path/to/episodes --output-dir /output/zarr --arm both --extrinsics-key x5Dec13_2 +""" + +import argparse +from pathlib import Path +import numpy as np +from egomimic.rldb.zarr import ZarrWriter +from egomimic.rldb.zarr.zarr_dataset_multi import ZarrEpisode, ZarrDataset +from egomimic.scripts.eva_process.zarr_utils import EvaHD5Extractor +from egomimic.utils.egomimicUtils import EXTRINSICS + + +def is_image_array(arr) -> bool: + """ + Check if array is an image based on shape and dtype. + + Images are expected to be: + - 4D arrays with shape (T, H, W, C) or (T, C, H, W) + - C (channels) is typically 1, 3, or 4 + - H and W (spatial) are larger than C + - dtype is uint8 + + Args: + arr: Array to check + + Returns: + True if array appears to be an image sequence + """ + if not hasattr(arr, 'shape') or not hasattr(arr, 'dtype'): + return False + + if arr.ndim != 4: + return False + + # Check dtype (images should be uint8) + if arr.dtype != np.uint8: + return False + + # Check if it looks like (T, H, W, C) or (T, C, H, W) + T, dim1, dim2, dim3 = arr.shape + + # Check for channels-last (T, H, W, C) + if dim3 in [1, 3, 4] and dim1 > dim3 and dim2 > dim3: + return True + + # Check for channels-first (T, C, H, W) + if dim1 in [1, 3, 4] and dim2 > dim1 and dim3 > dim1: + return True + + return False + + +def needs_transpose_to_hwc(arr) -> bool: + """ + Check if image array needs transpose from (T, C, H, W) to (T, H, W, C). + + Args: + arr: Image array + + Returns: + True if array is in channels-first format and needs transpose + """ + if arr.ndim != 4: + return False + + T, dim1, dim2, dim3 = arr.shape + + # If first spatial dim is small (1-4) and others are large, it's channels-first + return dim1 in [1, 3, 4] and dim2 > dim1 and dim3 > dim1 + + +def convert_hdf5_to_zarr( + hdf5_path: str | Path, + zarr_episode_path: str | Path, + arm: str = "both", + extrinsics_key: str = "x5Dec13_2", + prestack: bool = False, + low_res: bool = False, + no_rot: bool = False, + fps: int = 30, + incremental: bool = False, + batch_size: int = 64, +): + """ + Convert an Eva HDF5 episode file to Zarr format using EvaHD5Extractor. + + This function processes the HDF5 file with full forward kinematics, + camera frame transformations, and action preprocessing before writing to Zarr. + + Args: + hdf5_path: Path to the input HDF5 file + zarr_episode_path: Output path for the Zarr episode (e.g., /data/episode_000000.zarr) + arm: Which arm to process - "left", "right", or "both" + extrinsics_key: Key to lookup camera extrinsics from EXTRINSICS dict + prestack: Whether to prestack future actions into chunks + low_res: Whether to downsample images to low resolution + no_rot: Whether to skip rotation processing (position only) + fps: Frames per second for the episode + + Returns: + Path to created Zarr episode + + Example: + >>> convert_hdf5_to_zarr( + ... hdf5_path="/data/episodes/episode_000000.hdf5", + ... zarr_episode_path="/data/zarr_episodes/episode_000000.zarr", + ... arm="both", + ... extrinsics_key="x5Dec13_2", + ... ) + """ + print("\n" + "=" * 60) + print(f"Converting HDF5 to Zarr: {hdf5_path}") + print(f" Arm: {arm}") + print(f" Extrinsics: {extrinsics_key}") + print(f" Prestack: {prestack}") + print(f" Low res: {low_res}") + print(f" No rotation: {no_rot}") + print("=" * 60) + + hdf5_path = Path(hdf5_path) + if not hdf5_path.exists(): + print(f"Error: HDF5 file not found at {hdf5_path}") + return None + + # Get camera extrinsics + if extrinsics_key not in EXTRINSICS: + print(f"Error: Unknown extrinsics key '{extrinsics_key}'") + print(f"Available keys: {list(EXTRINSICS.keys())}") + return None + + extrinsics = EXTRINSICS[extrinsics_key] + + # Process episode using EvaHD5Extractor + print(f"\nProcessing episode with EvaHD5Extractor...") + episode_feats = EvaHD5Extractor.process_episode( + episode_path=hdf5_path, + arm=arm, + extrinsics=extrinsics, + prestack=prestack, + low_res=low_res, + no_rot=no_rot, + ) + + # Flatten nested observations dictionary and separate numeric/image data and metadata + numeric_data = {} + image_data = {} + metadata_dict = {} + + for key, value in episode_feats.items(): + if key == "observations" and isinstance(value, dict): + # Preserve observations prefix: observations.images.camera + for nested_key, nested_value in value.items(): + full_key = f"observations.{nested_key}" + + # Auto-detect and convert images from T×C×H×W to T×H×W×C for JPEG compression + if is_image_array(nested_value): + if needs_transpose_to_hwc(nested_value): + # Transpose from (T, C, H, W) to (T, H, W, C) + nested_value = nested_value.transpose(0, 2, 3, 1) + print(f" Image: {nested_key} -> {nested_value.shape} (T×H×W×C) [transposed]") + else: + print(f" Image: {nested_key} -> {nested_value.shape} (T×H×W×C)") + image_data[full_key] = nested_value + else: + numeric_data[full_key] = nested_value + elif key.startswith("metadata."): + # Extract metadata separately (don't include as features) + metadata_key = key.replace("metadata.", "") + metadata_dict[metadata_key] = value + print(f" Metadata: {key} (excluded from features)") + else: + # Actions and other top-level data are numeric + numeric_data[key] = value + + print(f"\n{'='*60}") + print(f"Data Summary:") + print(f"{'='*60}") + print(f"Numeric data: {len(numeric_data)} arrays") + for key, value in numeric_data.items(): + if hasattr(value, 'shape'): + print(f" {key}: shape {value.shape}, dtype {value.dtype}") + else: + print(f" {key}: {type(value)}") + + print(f"\nImage data: {len(image_data)} arrays") + for key, value in image_data.items(): + print(f" {key}: shape {value.shape}, dtype {value.dtype}") + + if metadata_dict: + print(f"\nMetadata: {len(metadata_dict)} items (excluded from features)") + for key, value in metadata_dict.items(): + if hasattr(value, 'shape'): + print(f" {key}: shape {value.shape}, constant value {value[0] if len(value) > 0 else 'N/A'}") + else: + print(f" {key}: {value}") + print(f"{'='*60}") + + # Validate we have data to write + if not numeric_data and not image_data: + print(f"\n❌ ERROR: No data to write! Both numeric_data and image_data are empty.") + return None + + # Determine robot type from arm + if arm == "both": + embodiment = "eva_bimanual" + elif arm == "left": + embodiment = "eva_left_arm" + elif arm == "right": + embodiment = "eva_right_arm" + else: + embodiment = "eva" + + # Ensure output directory exists + zarr_episode_path = Path(zarr_episode_path) + zarr_episode_path.parent.mkdir(parents=True, exist_ok=True) + print(f"\nOutput directory: {zarr_episode_path.parent}") + print(f"Output file: {zarr_episode_path.name}") + + # Write to Zarr with explicit numeric/image separation + print(f"\nWriting to Zarr (incremental={incremental})...") + try: + if incremental: + # Determine total_frames from data + all_arrays = list(numeric_data.values()) + list(image_data.values()) + total_frames = len(all_arrays[0]) + + writer = ZarrWriter( + episode_path=zarr_episode_path, + fps=fps, + embodiment=embodiment, + enable_sharding=False, + task="", + ) + with writer.write_incremental(total_frames=total_frames) as inc: + for start in range(0, total_frames, batch_size): + end = min(start + batch_size, total_frames) + batch_numeric = {k: v[start:end] for k, v in numeric_data.items()} if numeric_data else {} + batch_images = {k: v[start:end] for k, v in image_data.items()} if image_data else {} + inc.add_frames(numeric=batch_numeric, images=batch_images) + print(f" Wrote frames {start}:{end} / {total_frames}") + + zarr_path = writer.episode_path + else: + zarr_path = ZarrWriter.create_and_write( + episode_path=zarr_episode_path, + numeric_data=numeric_data if numeric_data else None, + image_data=image_data if image_data else None, + fps=fps, + embodiment=embodiment, + enable_sharding=False, + task="", + ) + except Exception as e: + print(f"\n❌ ERROR writing Zarr file: {e}") + import traceback + traceback.print_exc() + return None + + print(f"\n✅ Successfully converted to: {zarr_path}") + print(f" File exists: {zarr_path.exists()}") + + if zarr_path.exists(): + # Get size of zarr directory + import os + total_size = sum( + os.path.getsize(os.path.join(dirpath, filename)) + for dirpath, _, filenames in os.walk(zarr_path) + for filename in filenames + ) + print(f" Size: {total_size / (1024*1024):.2f} MB") + + # Verify the conversion + print(f"\nVerifying Zarr episode...") + try: + episode = ZarrEpisode(zarr_path) + print(f" ✅ Total frames: {len(episode)}") + print(f" ✅ Available keys: {list(episode.keys.keys())}") + + # Sample first frame using ZarrDataset + if len(episode) > 0: + print(f"\n First frame sample:") + dataset = ZarrDataset(zarr_path) + frame = dataset[0] + for key, value in frame.items(): + if hasattr(value, 'shape'): + print(f" {key}: shape {value.shape}, dtype {value.dtype}") + else: + print(f" {key}: {type(value)}") + except Exception as e: + print(f" ❌ ERROR verifying Zarr episode: {e}") + import traceback + traceback.print_exc() + + return zarr_path + + +def main(): + """Main entry point for command-line usage.""" + parser = argparse.ArgumentParser( + description="Convert Eva HDF5 episodes to Zarr format with full processing", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Convert a single episode with both arms + %(prog)s --hdf5-path /data/episode_000000.hdf5 --output-dir /data/zarr --arm both --extrinsics-key x5Dec13_2 + + # Convert all episodes in a directory with prestacking + %(prog)s --hdf5-dir /data/episodes --output-dir /data/zarr --arm both --extrinsics-key x5Dec13_2 --prestack + +Expected HDF5 structure: + /observations/joint_positions -> (T, 14) joint angles + /observations/images/front_img_1 -> (T, H, W, 3) or compressed + /observations/images/right_wrist_img -> (T, H, W, 3) or compressed + /observations/images/left_wrist_img -> (T, H, W, 3) or compressed + /action -> (T, 14) joint actions + +The converter will: + - Compute forward kinematics for end-effector poses + - Transform poses to camera frame using extrinsics + - Compute Cartesian actions in base and camera frames + - Compute relative EEF actions + - Add embodiment metadata + - Optionally prestack future actions into chunks + +Image arrays will be automatically detected and JPEG-compressed. + """ + ) + + # Input arguments + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument( + "--hdf5-path", + type=Path, + help="Path to a single HDF5 episode file to convert" + ) + group.add_argument( + "--hdf5-dir", + type=Path, + help="Directory containing HDF5 episode files (*.hdf5) to convert" + ) + + # Output arguments + parser.add_argument( + "--output-dir", + type=Path, + required=True, + help="Output directory for Zarr episodes" + ) + + # Eva-specific processing arguments + parser.add_argument( + "--arm", + type=str, + choices=["left", "right", "both"], + default="both", + help="Which arm(s) to process (default: both)" + ) + parser.add_argument( + "--extrinsics-key", + type=str, + default="x5Dec13_2", + help="Camera extrinsics key from EXTRINSICS dict (default: x5Dec13_2)" + ) + parser.add_argument( + "--prestack", + action="store_true", + help="Prestack future actions into chunks" + ) + parser.add_argument( + "--low-res", + action="store_true", + help="Downsample images to low resolution (240x320)" + ) + parser.add_argument( + "--no-rot", + action="store_true", + help="Skip rotation processing (position only)" + ) + parser.add_argument( + "--fps", + type=int, + default=30, + help="Frames per second for the episode (default: 30)" + ) + parser.add_argument( + "--incremental", + action="store_true", + help="Use write_incremental with add_frames instead of bulk write" + ) + parser.add_argument( + "--batch-size", + type=int, + default=64, + help="Frames per batch when using --incremental (default: 64)" + ) + + args = parser.parse_args() + + # Create output directory + args.output_dir.mkdir(parents=True, exist_ok=True) + print(f"\nOutput directory: {args.output_dir.absolute()}") + print(f"Output directory exists: {args.output_dir.exists()}") + + # Convert single file or batch + if args.hdf5_path: + # Single file conversion + if not args.hdf5_path.exists(): + print(f"Error: HDF5 file not found at {args.hdf5_path}") + return 1 + + # Generate output path with same base name + zarr_filename = args.hdf5_path.stem + ".zarr" + zarr_episode_path = args.output_dir / zarr_filename + + convert_hdf5_to_zarr( + hdf5_path=args.hdf5_path, + zarr_episode_path=zarr_episode_path, + arm=args.arm, + extrinsics_key=args.extrinsics_key, + prestack=args.prestack, + low_res=args.low_res, + no_rot=args.no_rot, + fps=args.fps, + incremental=args.incremental, + batch_size=args.batch_size, + ) + + else: + # Batch conversion + if not args.hdf5_dir.exists(): + print(f"Error: Directory not found at {args.hdf5_dir}") + return 1 + + hdf5_files = sorted(args.hdf5_dir.glob("*.hdf5")) + if not hdf5_files: + print(f"Error: No HDF5 files found in {args.hdf5_dir}") + return 1 + + print(f"\nFound {len(hdf5_files)} HDF5 files to convert") + + for hdf5_path in hdf5_files: + # Generate output path with same base name + zarr_filename = hdf5_path.stem + ".zarr" + zarr_episode_path = args.output_dir / zarr_filename + + try: + convert_hdf5_to_zarr( + hdf5_path=hdf5_path, + zarr_episode_path=zarr_episode_path, + arm=args.arm, + extrinsics_key=args.extrinsics_key, + prestack=args.prestack, + low_res=args.low_res, + no_rot=args.no_rot, + fps=args.fps, + incremental=args.incremental, + batch_size=args.batch_size, + ) + except Exception as e: + print(f"Error converting {hdf5_path}: {e}") + import traceback + traceback.print_exc() + continue + + print("\n" + "=" * 60) + print("✅ Conversion completed successfully!") + print("=" * 60) + print(f"\nOutput location: {args.output_dir.absolute()}") + + # List created files + zarr_files = sorted(args.output_dir.glob("*.zarr")) + if zarr_files: + print(f"\nCreated {len(zarr_files)} Zarr episodes:") + for zarr_file in zarr_files: + print(f" - {zarr_file.name}") + else: + print("\n⚠️ Warning: No .zarr files found in output directory") + + print("=" * 60 + "\n") + return 0 + + +if __name__ == "__main__": + exit(main()) \ No newline at end of file diff --git a/egomimic/rldb/zarr/zarr_writer.py b/egomimic/rldb/zarr/zarr_writer.py index fb4aa324..a7a3c1ed 100644 --- a/egomimic/rldb/zarr/zarr_writer.py +++ b/egomimic/rldb/zarr/zarr_writer.py @@ -667,4 +667,4 @@ def create_and_write( metadata_override=metadata_override, ) - return writer.episode_path + return writer.episode_path \ No newline at end of file diff --git a/egomimic/robot/data_visualization.ipynb b/egomimic/robot/data_visualization.ipynb index 3841352d..808c96e8 100644 --- a/egomimic/robot/data_visualization.ipynb +++ b/egomimic/robot/data_visualization.ipynb @@ -204,28 +204,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "0a7bd553", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "right\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Corrected action visualization and saving\n", "import os\n", @@ -264,19 +246,10 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "549b682e", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/torch/cuda/__init__.py:61: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.\n", - " import pynvml # type: ignore[import]\n" - ] - } - ], + "outputs": [], "source": [ "\n", "import torch\n", @@ -304,1087 +277,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "64ffba99", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'left': array([[ 0.01329544, -0.71757193, 0.69635749, -0.04409191],\n", - " [-0.99959782, -0.02698416, -0.00872107, -0.23221381],\n", - " [ 0.02504862, -0.69596148, -0.7176421 , 0.57323278],\n", - " [ 0. , 0. , 0. , 1. ]]), 'right': array([[-0.04733948, -0.76631195, 0.64072222, -0.20998031],\n", - " [-0.9983006 , 0.05811952, -0.00424732, 0.32539554],\n", - " [-0.0339837 , -0.63983444, -0.76776103, 0.74809634],\n", - " [ 0. , 0. , 0. , 1. ]])}\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "right\n", - "Wrote 1062 frames -> ./visualization/overlay_every1_30fps.mp4\n" - ] - } - ], + "outputs": [], "source": [ "# HDF5 -> overlay (every_nth) -> 30fps MP4 (matches your loop exactly)\n", "\n", diff --git a/egomimic/scripts/data_visualisation.ipynb b/egomimic/scripts/data_visualisation.ipynb index 2530cf56..9e2124c5 100644 --- a/egomimic/scripts/data_visualisation.ipynb +++ b/egomimic/scripts/data_visualisation.ipynb @@ -7,15 +7,22 @@ "outputs": [], "source": [ "# IMPORTS\n", + "import imageio_ffmpeg\n", + "import cv2\n", + "from scipy.spatial.transform import Rotation as R\n", + "\n", "from egomimic.rldb.utils import S3RLDBDataset\n", "import torch\n", "import numpy as np\n", - "from egomimic.utils.egomimicUtils import CameraTransforms, draw_actions\n", + "from scipy.spatial.transform import Rotation as R\n", + "from egomimic.utils.egomimicUtils import CameraTransforms, draw_actions, cam_frame_to_cam_pixels\n", "import torchvision.io as io\n", "import os\n", "from egomimic.algo.hpt import HPT\n", "from egomimic.utils.egomimicUtils import nds\n", - "import mediapy as media" + "import mediapy as mpy\n", + "import imageio_ffmpeg\n", + "mpy.set_ffmpeg(imageio_ffmpeg.get_ffmpeg_exe())" ] }, { @@ -36,6 +43,17 @@ ")" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = S3RLDBDataset(\n", + " filters={\"episode_hash\": \"697c1e6c0cac8cd3c4873844\"}, mode=\"total\", cache_root=\"/coc/flash7/scratch/.cache\", embodiment=\"scale_bimanual\"\n", + ")" + ] + }, { "cell_type": "code", "execution_count": null, @@ -52,7 +70,7 @@ "metadata": {}, "outputs": [], "source": [ - "camera_transforms = CameraTransforms(intrinsics_key=\"base\", extrinsics_key=None)" + "camera_transforms = CameraTransforms(intrinsics_key=\"scale\", extrinsics_key=\"scale\")" ] }, { @@ -61,20 +79,82 @@ "metadata": {}, "outputs": [], "source": [ - "def visualize_actions(ims, actions, extrinsics, intrinsics, arm=\"both\"):\n", - " for b in range(ims.shape[0]):\n", - " if actions.shape[-1] == 7 or actions.shape[-1] == 14:\n", - " ac_type = \"joints\"\n", - " elif actions.shape[-1] == 3 or actions.shape[-1] == 6:\n", - " ac_type = \"xyz\"\n", - " else:\n", - " raise ValueError(f\"Unknown action type with shape {actions.shape}\")\n", - "\n", - " ims[b] = draw_actions(\n", - " ims[b], ac_type, \"Purples\", actions[b], extrinsics, intrinsics, arm=arm\n", + "def _split_action_pose(actions):\n", + " # 14D layout: [L xyz ypr g, R xyz ypr g]\n", + " # 12D layout: [L xyz ypr, R xyz ypr]\n", + " if actions.shape[-1] == 14:\n", + " left_xyz = actions[:, :3]\n", + " left_ypr = actions[:, 3:6]\n", + " right_xyz = actions[:, 7:10]\n", + " right_ypr = actions[:, 10:13]\n", + " elif actions.shape[-1] == 12:\n", + " left_xyz = actions[:, :3]\n", + " left_ypr = actions[:, 3:6]\n", + " right_xyz = actions[:, 6:9]\n", + " right_ypr = actions[:, 9:12]\n", + " else:\n", + " raise ValueError(f\"Unsupported action dim {actions.shape[-1]}\")\n", + " return left_xyz, left_ypr, right_xyz, right_ypr\n", + "\n", + "\n", + "def viz_lerobot_xyz(im, actions, intrinsics):\n", + " left_xyz, _, right_xyz, _ = _split_action_pose(actions)\n", + " vis = draw_actions(\n", + " im.copy(), \"xyz\", \"Blues\", left_xyz, None, intrinsics, arm=\"left\"\n", + " )\n", + " vis = draw_actions(\n", + " vis, \"xyz\", \"Reds\", right_xyz, None, intrinsics, arm=\"right\"\n", + " )\n", + " return vis\n", + "\n", + "\n", + "def viz_lerobot_ypr(im, actions, intrinsics, axis_len_m=0.04):\n", + " left_xyz, left_ypr, right_xyz, right_ypr = _split_action_pose(actions)\n", + " vis = im.copy()\n", + "\n", + " def _draw_rotation_at_palm(frame, xyz_seq, ypr_seq, label, anchor_color):\n", + " if len(xyz_seq) == 0 or len(ypr_seq) == 0:\n", + " return frame\n", + "\n", + " palm_xyz = xyz_seq[0]\n", + " palm_ypr = ypr_seq[0]\n", + " rot = R.from_euler(\"ZYX\", palm_ypr, degrees=False).as_matrix()\n", + "\n", + " axis_points_cam = np.vstack([\n", + " palm_xyz,\n", + " palm_xyz + rot[:, 0] * axis_len_m,\n", + " palm_xyz + rot[:, 1] * axis_len_m,\n", + " palm_xyz + rot[:, 2] * axis_len_m,\n", + " ])\n", + "\n", + " px = cam_frame_to_cam_pixels(axis_points_cam, intrinsics)[:, :2]\n", + " if not np.isfinite(px).all():\n", + " return frame\n", + "\n", + " pts = np.round(px).astype(np.int32)\n", + " h, w = frame.shape[:2]\n", + " x0, y0 = pts[0]\n", + " if not (0 <= x0 < w and 0 <= y0 < h):\n", + " return frame\n", + "\n", + " cv2.circle(frame, (x0, y0), 4, anchor_color, -1)\n", + " axis_colors = [(0, 0, 255), (0, 255, 0), (255, 0, 0)] # x,y,z\n", + "\n", + " for i, color in enumerate(axis_colors, start=1):\n", + " x1, y1 = pts[i]\n", + " if 0 <= x1 < w and 0 <= y1 < h:\n", + " cv2.line(frame, (x0, y0), (x1, y1), color, 2)\n", + " cv2.circle(frame, (x1, y1), 2, color, -1)\n", + "\n", + " cv2.putText(\n", + " frame, label, (x0 + 6, max(12, y0 - 8)),\n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.4, anchor_color, 1, cv2.LINE_AA,\n", " )\n", + " return frame\n", "\n", - " return ims" + " vis = _draw_rotation_at_palm(vis, left_xyz, left_ypr, \"L rot\", (255, 180, 80))\n", + " vis = _draw_rotation_at_palm(vis, right_xyz, right_ypr, \"R rot\", (80, 180, 255))\n", + " return vis" ] }, { @@ -85,18 +165,41 @@ "source": [ "ims = []\n", "image_key = \"observations.images.front_img_1\"\n", - "actions_key = \"actions_cartesian\"\n", + "actions_key = \"actions_ee_cartesian_cam\"\n", "for i, data in enumerate(data_loader):\n", " im = data[image_key][0].permute(1, 2, 0).cpu().numpy() * 255\n", " im = im.astype(np.uint8)\n", " actions = data[actions_key][0].cpu().numpy()\n", - " xyz, rot = HPT._extract_xyz(torch.from_numpy(actions))\n", - " im = draw_actions(im, \"xyz\", \"Purples\", xyz.numpy(), None, camera_transforms.intrinsics, arm=\"both\")\n", + " im = viz_lerobot_xyz(im, actions, camera_transforms.intrinsics)\n", " ims.append(im)\n", " if i > 200:\n", " break\n", "\n", - "media.show_video(ims, fps=30)" + "mpy.show_video(ims, fps=30)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Separate LeRobot YPR video (same logic, palm-centered projection)\n", + "ims_ypr = []\n", + "image_key = \"observations.images.front_img_1\"\n", + "actions_key = \"actions_ee_cartesian_cam\"\n", + "for i, data in enumerate(data_loader):\n", + " im = data[image_key][0].permute(1, 2, 0).cpu().numpy() * 255\n", + " im = im.astype(np.uint8)\n", + " \n", + " actions = data[actions_key][0].cpu().numpy()\n", + " im_ypr = viz_lerobot_ypr(im, actions, camera_transforms.intrinsics)\n", + " ims_ypr.append(im_ypr)\n", + " if i > 200:\n", + " break\n", + "\n", + "mpy.show_video(ims_ypr, fps=30)" ] }, { @@ -146,13 +249,13 @@ " if i > 500:\n", " break\n", "\n", - "media.show_video(ims, fps=30)" + "mpy.show_video(ims, fps=30)" ] } ], "metadata": { "kernelspec": { - "display_name": "emimic", + "display_name": "emimic (3.11.14)", "language": "python", "name": "python3" }, diff --git a/egomimic/scripts/eva_process/zarr_utils.py b/egomimic/scripts/eva_process/zarr_utils.py new file mode 100644 index 00000000..83a43a18 --- /dev/null +++ b/egomimic/scripts/eva_process/zarr_utils.py @@ -0,0 +1,1159 @@ +import logging +import os +import time +from pathlib import Path +from typing import Union + +import cv2 +import h5py +import numpy as np +import torch +import torch.nn.functional as F +from scipy.spatial.transform import Rotation as R + +import egomimic +from egomimic.robot.eva.eva_kinematics import EvaMinkKinematicsSolver +from egomimic.rldb.utils import EMBODIMENT +from egomimic.utils.egomimicUtils import ( + ee_orientation_to_cam_frame, + ee_pose_to_cam_frame, + interpolate_arr, + interpolate_arr_euler, +) + +DATASET_KEY_MAPPINGS = { + "joint_positions": "joint_positions", + "front_img_1": "front_img_1", + "right_wrist_img": "right_wrist_img", + "left_wrist_img": "left_wrist_img", +} + +EVA_XML_PATH = os.path.join( + os.path.dirname(egomimic.__file__), "resources/model_x5.xml" +) + +HORIZON_BASE = 45 # horizon in real timesteps +CHUNK_LENGTH_BASE = 100 # number of interpolated points per chunk + +Array2D = Union[np.ndarray, torch.Tensor] + + +def _to_numpy(x): + """Convert torch / numpy / anything array-like to np.ndarray.""" + if isinstance(x, np.ndarray): + return x + if isinstance(x, torch.Tensor): + return x.detach().cpu().numpy() + return np.asarray(x) + + +def _as_rotation(x): + """Return a scipy Rotation from either Rotation or 3x3 ndarray.""" + return x if isinstance(x, R) else R.from_matrix(np.asarray(x, dtype=float)) + + +def _as_matrix(x): + """Return a 3x3 ndarray from either Rotation or 3x3 ndarray.""" + return x.as_matrix() if isinstance(x, R) else np.asarray(x, dtype=float) + + +def _row_to_numpy(x: Array2D, i: int) -> np.ndarray: + """Get i-th row as numpy array (handles torch or numpy input).""" + if isinstance(x, np.ndarray): + return x[i] + return x[i].detach().cpu().numpy() + + +def _wrap_to_pi(x: np.ndarray) -> np.ndarray: + return (x + np.pi) % (2 * np.pi) - np.pi + + +def assert_fk_matches_eepose( + actions_base_cartesian: np.ndarray, + actions_eepose: np.ndarray, + *, + arm: str = "both", + atol_pose: float = 2e-4, + rtol_pose: float = 0.0, + mismatch_frac_threshold: float = 0.01, + skip_first: int = 1, + zero_eps: float = 1e-12, +): + # prestack handling + base0 = ( + actions_base_cartesian[:, 0] + if actions_base_cartesian.ndim == 3 + else actions_base_cartesian + ) + eep = actions_eepose + + if eep.ndim != 2 or eep.shape[1] != 14: + print(f"[FK WARNING] Expected eepose (T,14), got {eep.shape}") + return + + if base0.ndim != 2: + print(f"[FK WARNING] Expected base_cartesian 2D, got {base0.shape}") + return + + if base0.shape[0] != eep.shape[0]: + print(f"[FK WARNING] T mismatch: base={base0.shape}, eepose={eep.shape}") + return + + T = eep.shape[0] + idx_all = np.arange(T) + + # -------------------------------------------------- + # dimension layout + # -------------------------------------------------- + # base_cartesian: + # arm=left/right : (T,7) -> [x y z yaw pitch roll g] + # arm=both : (T,14) -> [L pose g | R pose g] + # + # eepose (always): + # [L xyz ypr g | R xyz ypr g] + # -------------------------------------------------- + + if arm == "left": + b_pos = [0, 1, 2] + b_ang = [3, 4, 5] + e_pos = [0, 1, 2] + e_ang = [3, 4, 5] + arm_name = "left" + + if base0.shape[1] != 7: + print(f"[FK WARNING] base_cartesian expected (T,7) for left, got {base0.shape}") + return + + elif arm == "right": + b_pos = [0, 1, 2] + b_ang = [3, 4, 5] + e_pos = [7, 8, 9] + e_ang = [10, 11, 12] + arm_name = "right" + + if base0.shape[1] != 7: + print(f"[FK WARNING] base_cartesian expected (T,7) for right, got {base0.shape}") + return + + elif arm == "both": + b_pos = [0, 1, 2, 7, 8, 9] + b_ang = [3, 4, 5, 10, 11, 12] + e_pos = [0, 1, 2, 7, 8, 9] + e_ang = [3, 4, 5, 10, 11, 12] + arm_name = "both" + + if base0.shape[1] != 14: + print(f"[FK WARNING] base_cartesian expected (T,14) for both, got {base0.shape}") + return + + else: + print(f"[FK WARNING] Unknown arm='{arm}'") + return + + # -------------------------------------------------- + # validity mask (eepose only) + # -------------------------------------------------- + pose_dims_e = e_pos + e_ang + valid = (np.abs(eep[:, pose_dims_e]) > zero_eps).any(axis=1) + if skip_first > 0: + valid[:skip_first] = False + + if not valid.any(): + return + + b = base0[valid] + a = eep[valid] + v_idx = idx_all[valid] + + # -------------------------------------------------- + # position diff + # -------------------------------------------------- + dpos = b[:, b_pos] - a[:, e_pos] + tolpos = atol_pose + rtol_pose * np.abs(a[:, e_pos]) + viol = (np.abs(dpos) > tolpos).any(axis=1) + + # -------------------------------------------------- + # angle diff (inline wrap) + # -------------------------------------------------- + dang = b[:, b_ang] - a[:, e_ang] + dang = (dang + np.pi) % (2 * np.pi) - np.pi + tolang = atol_pose + rtol_pose * np.abs(a[:, e_ang]) + viol |= (np.abs(dang) > tolang).any(axis=1) + + mismatch_frac = float(viol.mean()) + if mismatch_frac <= mismatch_frac_threshold: + return + + bad_ts = v_idx[viol] + show = bad_ts[:20].tolist() + extra = "" if bad_ts.size <= 20 else f" ... (+{bad_ts.size - 20} more)" + + print( + f"[FK WARNING] ({arm_name}) FK/eepose mismatch rate " + f"{mismatch_frac*100:.3f}% " + f"({int(viol.sum())}/{int(viol.size)} rows). " + f"First bad timesteps: {show}{extra}. " + f"(atol={atol_pose}, rtol={rtol_pose}, skip_first={skip_first})" + ) + + +def print_fk_eepose_diffs( + actions_base_cartesian: np.ndarray, + actions_eepose: np.ndarray, + *, + atol: float = 2e-4, + rtol: float = 0.0, + skip_first: int = 1, + zero_eps: float = 1e-12, + max_rows: int = 50, + max_cols: int = 20, + with_angles: bool = True, +): + """ + Print all diffs (per timestep, per dim) where FK(base0) != eepose beyond tolerance. + + - If base is (T,S,D), compares base[:,0,:] against eepose. + - Drops gripper dims by default via dim selection based on D. + - For angles, compares wrapped diff into [-pi,pi]. + - Masks out padded all-zero eepose rows in pose dims and also skips first `skip_first`. + + Prints: + - summary stats + - list of violating timesteps + - for each violating timestep: FK, EE, DIFF for selected dims + """ + base0 = actions_base_cartesian[:, 0] if actions_base_cartesian.ndim == 3 else actions_base_cartesian + eep = actions_eepose + + if base0.shape != eep.shape: + raise ValueError(f"Shape mismatch: base0={base0.shape} vs eepose={eep.shape}") + + T, D = base0.shape + + if D == 14: + pos_dims = [0, 1, 2, 7, 8, 9] + ang_dims = [3, 4, 5, 10, 11, 12] if with_angles else [] + dim_names = ( + ["Lx","Ly","Lz","L_yaw","L_pitch","L_roll","L_g", + "Rx","Ry","Rz","R_yaw","R_pitch","R_roll","R_g"] + ) + elif D == 7: + pos_dims = [0, 1, 2] + ang_dims = [3, 4, 5] if with_angles else [] + dim_names = ["x","y","z","yaw","pitch","roll","g"] + else: + pos_dims = list(range(0, min(3, D))) + ang_dims = list(range(3, min(6, D))) if with_angles else [] + dim_names = [f"d{i}" for i in range(D)] + + pose_dims = pos_dims + ang_dims + + # mask padded all-zero-ish rows (in pose dims) + skip_first + nonzero_row = (np.abs(eep[:, pose_dims]) > zero_eps).any(axis=1) + mask = nonzero_row.copy() + if skip_first > 0: + mask[:skip_first] = False + + idx_all = np.arange(T) + valid_idx = idx_all[mask] + if valid_idx.size == 0: + print(f"[diff] No valid rows after masking. skip_first={skip_first}, zero_eps={zero_eps}") + return + + b = base0[mask] + a = eep[mask] + + # build a "diff" array for pose dims: pos direct, angles wrapped + diff_pose = np.zeros((b.shape[0], len(pose_dims)), dtype=np.float64) + # positions + diff_pose[:, :len(pos_dims)] = (b[:, pos_dims] - a[:, pos_dims]) + + # angles + if ang_dims: + diff_pose[:, len(pos_dims):] = _wrap_to_pi(b[:, ang_dims] - a[:, ang_dims]) + + # tolerance per-element + # elementwise allowed = atol + rtol * abs(desired) + desired_pose = a[:, pose_dims] + tol = atol + rtol * np.abs(desired_pose) + viol = np.abs(diff_pose) > tol + + viol_rows = np.where(viol.any(axis=1))[0] + if viol_rows.size == 0: + print(f"[diff] ✅ No violations. compared_rows={b.shape[0]} masked_out={(~mask).sum()}") + return + + # summary + abs_diff = np.abs(diff_pose) + print(f"[diff] compared_rows={b.shape[0]} masked_out={(~mask).sum()} atol={atol} rtol={rtol}") + print(f"[diff] violations: {viol_rows.size} / {b.shape[0]} rows ({100*viol_rows.size/b.shape[0]:.3f}%)") + print(f"[diff] max_abs_over_pose_dims={abs_diff[viol].max():.6g}") + # per-dim summary + mean_abs_per_dim = abs_diff.mean(axis=0) + max_abs_per_dim = abs_diff.max(axis=0) + dim_labels = [dim_names[d] if d < len(dim_names) else str(d) for d in pose_dims] + print("[diff] per-dim mean_abs:", dict(zip(dim_labels, mean_abs_per_dim))) + print("[diff] per-dim max_abs :", dict(zip(dim_labels, max_abs_per_dim))) + + # print violating timesteps + detailed diffs + print("\n[diff] Violating timesteps (original t indices):") + ts = valid_idx[viol_rows] + print(ts.tolist()[:max_rows], ("..." if ts.size > max_rows else "")) + + to_show = min(max_rows, viol_rows.size) + for k in range(to_show): + r = viol_rows[k] + t = valid_idx[r] # original timestep + cols = np.where(viol[r])[0] + cols = cols[:max_cols] + + fk_vals = b[r, pose_dims] + ee_vals = a[r, pose_dims] + dvals = diff_pose[r] + + print(f"\n--- t={t} (valid_row_idx={r}) ---") + for c in cols: + name = dim_labels[c] + fk_v = fk_vals[c] + ee_v = ee_vals[c] + dv = dvals[c] + allowed = tol[r, c] + print(f"{name:>8s}: fk={fk_v:+.6f} ee={ee_v:+.6f} diff={dv:+.6f} |diff|>{allowed:.6g}") + + if viol_rows.size > max_rows: + print(f"\n[diff] (only first {max_rows} violating rows printed; set max_rows larger to see all)") + + return { + "valid_idx": valid_idx, + "viol_valid_rows": viol_rows, + "viol_timesteps": valid_idx[viol_rows], + "pose_dims": pose_dims, + "pos_dims": pos_dims, + "ang_dims": ang_dims, + "diff_pose": diff_pose, + "viol_mask": viol, + } + + +def fk_xyz( + joints_2d: Array2D, eva_fk: EvaMinkKinematicsSolver, *, dtype=torch.float32, device=None +) -> torch.Tensor: + """ + Eva FK positions for a sequence of joint vectors. + Returns torch.Tensor of shape (T, 3). + """ + T = joints_2d.shape[0] + out = torch.empty((T, 3), dtype=dtype, device=device) + for i in range(T): + q = _row_to_numpy(joints_2d, i) # (DoF,) + pos, _R = eva_fk.fk(q) # pos: (3,), _R: (3,3) numpy + out[i] = torch.as_tensor(pos, dtype=dtype, device=device) + return out + + +def fk_SE3( + joints_2d: Array2D, eva_fk: EvaMinkKinematicsSolver, *, dtype=torch.float32, device=None +) -> torch.Tensor: + """ + Eva FK full SE(3) for a sequence of joint vectors. + Returns torch.Tensor of shape (T, 4, 4) with bottom-right set to 1. + Downstream can keep using fk[:, :3, 3] and fk[:, :3, :3]. + """ + T = joints_2d.shape[0] + out = torch.zeros((T, 4, 4), dtype=dtype, device=device) + out[:, 3, 3] = 1.0 + for i in range(T): + q = _row_to_numpy(joints_2d, i) + pos, R_obj = eva_fk.fk(q) # numpy: (3,), (3,3) + Rm = _as_matrix(R_obj) + out[i, :3, :3] = torch.as_tensor(Rm, dtype=dtype, device=device) + out[i, :3, 3] = torch.as_tensor(pos, dtype=dtype, device=device) + return out + + +def build_future_windows(arr: np.ndarray, horizon: int) -> np.ndarray: + arr = np.asarray(arr) + T, D = arr.shape + out = np.empty((T, horizon, D), dtype=arr.dtype) + for t in range(T): + end = min(t + horizon, T) + length = end - t + out[t, :length, :] = arr[t:end] + out[t, length:, :] = arr[end - 1] + return out + + +def prestack_with_mode( + arr: np.ndarray, + horizon: int, + chunk_length: int, + mode: str = "linear", +) -> np.ndarray: + windows = build_future_windows(arr, horizon) + if mode == "euler": + return interpolate_arr_euler(windows, chunk_length) + else: + return interpolate_arr(windows, chunk_length) + + +def joint_to_pose(pose, arm, left_extrinsics=None, right_extrinsics=None, no_rot=False): + """ + pose: (T, ACTION_DIM) + arm: left, right, both arms of the robot + left_extrinsics: the left camera extrinsics + right_extrinsics: the right camera extrinsics + """ + eva_fk = EvaMinkKinematicsSolver(model_path=str(EVA_XML_PATH)) + + if arm == "both": + joint_start = 0 + joint_end = 14 + joint_left_start = 0 + joint_left_end = 7 + joint_right_start = 7 + joint_right_end = 14 + else: + if arm == "left": + joint_start = 0 + joint_end = 7 + elif arm == "right": + joint_start = 7 + joint_end = 14 + + if no_rot: + if arm == "both": + fk_left_positions = fk_xyz( + pose[:, joint_left_start : joint_left_end - 1], eva_fk + ) + fk_right_positions = fk_xyz( + pose[:, joint_right_start : joint_right_end - 1], eva_fk + ) + + fk_left_positions = _to_numpy(fk_left_positions) + fk_right_positions = _to_numpy(fk_right_positions) + + base_fk_positions = np.concatenate([fk_left_positions, fk_right_positions], axis=1) + + fk_left_positions = ee_pose_to_cam_frame(fk_left_positions, left_extrinsics) + fk_right_positions = ee_pose_to_cam_frame( + fk_right_positions, right_extrinsics + ) + fk_positions = np.concatenate( + [fk_left_positions, fk_right_positions], axis=1 + ) + else: + fk_positions = fk_xyz(pose[:, joint_start : joint_end - 1], eva_fk) + extrinsics = left_extrinsics if arm == "left" else right_extrinsics + + base_fk_positions = fk_positions + + fk_positions = ee_pose_to_cam_frame(fk_positions, extrinsics) + + else: + if arm == "both": + fk_left = fk_SE3(pose[:, joint_left_start : joint_left_end - 1], eva_fk) + fk_right = fk_SE3(pose[:, joint_right_start : joint_right_end - 1], eva_fk) + + fk_left_positions = fk_left[:, :3, 3] + fk_left_orientations = fk_left[:, :3, :3] + fk_right_positions = fk_right[:, :3, 3] + fk_right_orientations = fk_right[:, :3, :3] + + left_gripper = pose[:, joint_left_end - 1].reshape(-1, 1) + right_gripper = pose[:, joint_right_end - 1].reshape(-1, 1) + + + left_ypr_base = R.from_matrix(fk_left_orientations).as_euler("ZYX", degrees=False) + right_ypr_base = R.from_matrix(fk_right_orientations).as_euler("ZYX", degrees=False) + + base_fk_positions = np.concatenate( + [ + fk_left_positions, + left_ypr_base, + left_gripper, + fk_right_positions, + right_ypr_base, + right_gripper, + ], + axis=1, + ) + + fk_left_positions = ee_pose_to_cam_frame(fk_left_positions, left_extrinsics) + fk_right_positions = ee_pose_to_cam_frame( + fk_right_positions, right_extrinsics + ) + + fk_left_orientations, fk_left_ypr = ee_orientation_to_cam_frame( + fk_left_orientations, left_extrinsics + ) + fk_right_orientations, fk_right_ypr = ee_orientation_to_cam_frame( + fk_right_orientations, right_extrinsics + ) + + fk_positions = np.concatenate( + [ + fk_left_positions, + fk_left_ypr, + left_gripper, + fk_right_positions, + fk_right_ypr, + right_gripper, + ], + axis=1, + ) + + else: + fk = fk_SE3(pose[:, joint_start : joint_end - 1], eva_fk) + + fk_positions = fk[:, :3, 3] + fk_orientations = fk[:, :3, :3] + + gripper = pose[:, joint_end - 1].reshape(-1, 1) + + ypr_base = R.from_matrix(fk_orientations).as_euler("ZYX", degrees=False) + base_fk_positions = np.concatenate([fk_positions, ypr_base, gripper], axis=1) + + extrinsics = left_extrinsics if arm == "left" else right_extrinsics + fk_positions = ee_pose_to_cam_frame(fk_positions, extrinsics) + fk_orientations, fk_ypr = ee_orientation_to_cam_frame( + fk_orientations, extrinsics + ) + + fk_positions = np.concatenate([fk_positions, fk_ypr, gripper], axis=1) + + return fk_positions, base_fk_positions + + +class EvaHD5Extractor: + TAGS = ["eva", "robotics", "hdf5"] + + @staticmethod + def process_episode( + episode_path, arm, extrinsics, prestack=False, low_res=False, no_rot=False + ): + """ + Extracts all feature keys from a given episode and returns as a dictionary + Parameters + ---------- + episode_path : str or Path + Path to the HDF5 file containing the episode data. + arm : str + String for which arm to add data for + extrinsics : np.array + camera extrinsic, It is a tuple of (left_extrinsics, right_extrinsics) if arm is both + prestack : bool + prestack the future actions or not + Returns + ------- + episode_feats : dict + dictionary mapping keys in the episode to episode features + { + {action_key} : + observations : + images.{camera_key} : + state.{state_key} : + } + + #TODO: Add metadata to be a nested dict + + """ + left_extrinsics = None + right_extrinsics = None + + if arm == "both": + if not isinstance(extrinsics, dict): + logging.info( + "Error: Both arms selected. Expected extrinsics for both arms." + ) + left_extrinsics = extrinsics["left"] + right_extrinsics = extrinsics["right"] + elif arm == "left": + extrinsics = extrinsics["left"] + left_extrinsics = extrinsics + elif arm == "right": + extrinsics = extrinsics["right"] + right_extrinsics = extrinsics + + if arm == "left": + joint_start = 0 + joint_end = 7 + elif arm == "right": + joint_start = 7 + joint_end = 14 + elif arm == "both": + joint_start = 0 + joint_end = 14 + + episode_feats = dict() + + # TODO: benchmarking only, remove for release + t0 = time.time() + + with h5py.File(episode_path, "r") as episode: + # rgb camera + logging.info(f"[EvaHD5Extractor] Reading HDF5 file: {episode_path}") + + episode_feats["observations"] = dict() + + for camera in EvaHD5Extractor.get_cameras(episode): + images = ( + torch.from_numpy(episode["observations"]["images"][camera][:]) + .permute(0, 3, 1, 2) + .float() + ) + + if low_res: + images = F.interpolate( + images, size=(240, 320), mode="bilinear", align_corners=False + ) + + images = images.byte().numpy() + + mapped_key = DATASET_KEY_MAPPINGS.get(camera, camera) + episode_feats["observations"][f"images.{mapped_key}"] = images + + # state + for state in EvaHD5Extractor.get_state(episode): + mapped_key = DATASET_KEY_MAPPINGS.get(state, state) + episode_feats["observations"][f"state.{mapped_key}"] = episode[ + "observations" + ][state][:] + + # ee_pose + episode_feats["observations"][f"state.ee_pose"] = ( + EvaHD5Extractor.get_ee_pose( + episode_feats["observations"][f"state.joint_positions"], + arm, + left_extrinsics=left_extrinsics, + right_extrinsics=right_extrinsics, + no_rot=no_rot, + ) + ) + + # actions + joint_actions, cartesian_actions, base_cartesian_actions = EvaHD5Extractor.get_action( + episode["action"][:], + arm=arm, + prestack=prestack, + HORIZON=HORIZON_BASE, + CHUNK_LENGTH=CHUNK_LENGTH_BASE, + left_extrinsics=left_extrinsics, + right_extrinsics=right_extrinsics, + no_rot=no_rot, + ) + # dbg = print_fk_eepose_diffs( + # base_cartesian_actions, + # episode["actions"]["eepose"][:], + # atol=2e-4, + # rtol=0.0, + # skip_first=1, + # max_rows=500, # set huge if you truly want "all" + # ) + if "actions" in episode and "eepose" in episode["actions"]: + assert_fk_matches_eepose(base_cartesian_actions, episode["actions"]["eepose"][:], arm=arm) + + episode_feats["actions_joints"] = joint_actions + episode_feats["actions_cartesian"] = cartesian_actions + episode_feats["actions_base_cartesian"] = base_cartesian_actions + + episode_feats["actions_eef_cartesian"] = EvaHD5Extractor.get_eef_action( + actions_cartesian_base=base_cartesian_actions, + arm=arm, + ref_index=0, + ) + + episode_feats["observations"][f"state.joint_positions"] = episode_feats[ + "observations" + ][f"state.joint_positions"][:, joint_start:joint_end] + + num_timesteps = episode_feats["observations"][f"state.ee_pose"].shape[0] + if arm == "right": + value = EMBODIMENT.EVA_RIGHT_ARM.value + elif arm == "left": + value = EMBODIMENT.EVA_LEFT_ARM.value + else: + value = EMBODIMENT.EVA_BIMANUAL.value + + episode_feats["metadata.embodiment"] = np.full( + (num_timesteps, 1), value, dtype=np.int32 + ) + + # TODO: benchmarking only, remove for release + elapsed_time = time.time() - t0 + logging.info( + f"[EvaHD5Extractor] Finished processing episode at {episode_path} in {elapsed_time:.2f} sec" + ) + + return episode_feats + + @staticmethod + def get_action( + actions: np.array, + arm: str, + prestack: bool = False, + HORIZON: int = HORIZON_BASE, + CHUNK_LENGTH: int = CHUNK_LENGTH_BASE, + left_extrinsics=None, + right_extrinsics=None, + no_rot: bool = False, + ): + joint_actions = actions + + if arm == "left": + joint_start = 0 + joint_end = 7 + elif arm == "right": + joint_start = 7 + joint_end = 14 + elif arm == "both": + joint_start = 0 + joint_end = 14 + + cartesian_actions, base_cartesian_actions = joint_to_pose( + pose=joint_actions, + arm=arm, + left_extrinsics=left_extrinsics, + right_extrinsics=right_extrinsics, + no_rot=no_rot, + ) + + joint_actions = joint_actions[:, joint_start:joint_end] + + if prestack: + horizon = HORIZON + + joint_actions = prestack_with_mode( + np.asarray(joint_actions), + horizon=horizon, + chunk_length=CHUNK_LENGTH, + mode="linear", + ) + + cart_np = np.asarray(cartesian_actions) + base_np = np.asarray(base_cartesian_actions) + + if arm == "both": + left_base = base_np[:, :7] + right_base = base_np[:, 7:14] + left_cam = cart_np[:, :7] + right_cam = cart_np[:, 7:14] + + left_base = prestack_with_mode( + left_base, + horizon=horizon, + chunk_length=CHUNK_LENGTH, + mode="euler", + ) + right_base = prestack_with_mode( + right_base, + horizon=horizon, + chunk_length=CHUNK_LENGTH, + mode="euler", + ) + left_cam = prestack_with_mode( + left_cam, + horizon=horizon, + chunk_length=CHUNK_LENGTH, + mode="euler", + ) + right_cam = prestack_with_mode( + right_cam, + horizon=horizon, + chunk_length=CHUNK_LENGTH, + mode="euler", + ) + + base_cartesian_actions = np.concatenate( + [left_base, right_base], axis=-1 + ) + cartesian_actions = np.concatenate( + [left_cam, right_cam], axis=-1 + ) + else: + base_cartesian_actions = prestack_with_mode( + base_np, + horizon=horizon, + chunk_length=CHUNK_LENGTH, + mode="euler", + ) + cartesian_actions = prestack_with_mode( + cart_np, + horizon=horizon, + chunk_length=CHUNK_LENGTH, + mode="euler", + ) + + return (joint_actions, cartesian_actions, base_cartesian_actions) + + @staticmethod + def get_eef_action( + actions_cartesian_base: np.ndarray, + arm: str, + ref_index: int = 0, + ) -> np.ndarray: + """Compute relative EEF actions from base-frame Cartesian actions. + + Supports both prestacked (N, S, D) and non-prestacked (N, D) inputs. + For prestacked: each row has S future actions, relative to ref_index action. + For non-prestacked: computes relative pose from previous frame (or identity for first). + + Args: + actions_cartesian_base: Shape (N, S, D) or (N, D) where D=7 per arm (xyz + ypr + gripper) + arm: "left", "right", or "both" + ref_index: Reference index for relative transform (only used for prestacked) + + Returns: + Relative actions with same shape as input + """ + if arm == "both": + left_base = actions_cartesian_base[..., :7] + right_base = actions_cartesian_base[..., 7:14] + + left_rel = EvaHD5Extractor.get_eef_action( + left_base, arm="left", ref_index=ref_index + ) + right_rel = EvaHD5Extractor.get_eef_action( + right_base, arm="right", ref_index=ref_index + ) + return np.concatenate([left_rel, right_rel], axis=-1) + + # Handle both 2D (N, D) and 3D (N, S, D) inputs + is_2d = actions_cartesian_base.ndim == 2 + if is_2d: + # Add sequence dimension: (N, D) -> (N, 1, D) + actions_cartesian_base = actions_cartesian_base[:, np.newaxis, :] + + N, S, D = actions_cartesian_base.shape + + p = actions_cartesian_base[..., :3] # (N, S, 3) + ypr = actions_cartesian_base[..., 3:6] # (N, S, 3) + g = actions_cartesian_base[..., 6:7] # (N, S, 1) + + ypr_flat = ypr.reshape(-1, 3) # (N*S, 3) + R_flat = R.from_euler("ZYX", ypr_flat, degrees=False).as_matrix() # (N*S, 3, 3) + R_seq = R_flat.reshape(N, S, 3, 3) # (N, S, 3, 3) + + T_seq = np.zeros((N, S, 4, 4), dtype=np.float32) + T_seq[..., :3, :3] = R_seq + T_seq[..., :3, 3] = p + T_seq[..., 3, 3] = 1.0 + + T0 = T_seq[:, ref_index, :, :] # (N, 4, 4) + T0_inv = np.linalg.inv(T0) # (N, 4, 4) + + T_rel = T0_inv[:, None, :, :] @ T_seq # (N, S, 4, 4) + + p_rel = T_rel[..., :3, 3] # (N, S, 3) + R_rel = T_rel[..., :3, :3] # (N, S, 3, 3) + + R_rel_flat = R_rel.reshape(-1, 3, 3) # (N*S, 3, 3) + ypr_rel_flat = R.from_matrix(R_rel_flat).as_euler("ZYX", degrees=False) # (N*S, 3) + ypr_rel = ypr_rel_flat.reshape(N, S, 3) # (N, S, 3) + + actions_rel = np.empty_like(actions_cartesian_base) + actions_rel[..., :3] = p_rel + actions_rel[..., 3:6] = ypr_rel + actions_rel[..., 6:7] = g # keep gripper as-is + + # Remove sequence dimension if input was 2D + if is_2d: + actions_rel = actions_rel[:, 0, :] # (N, 1, D) -> (N, D) + + return actions_rel + + @staticmethod + def get_ee_pose( + qpos: np.array, + arm: str, + left_extrinsics=None, + right_extrinsics=None, + no_rot=False, + ): + """ + Uses FK to calculate ee pose from joints + Parameters + ---------- + qpos : np.array + array containing joint positions + arm : str + arm to convert data for + left_extrinsics : + camera extrinsics + right_extrinsics : + camera_extrinsics + no_rot : bool + calculate full 6dof pose or not + Returns + ------- + ee_pose : np.array + ee_pose SE{3} + """ + + ee_pose, _ = joint_to_pose( + qpos, arm, left_extrinsics, right_extrinsics, no_rot=no_rot + ) + + return ee_pose + + @staticmethod + def get_cameras(hdf5_data: h5py.File): + """ + Extracts the list of RGB camera keys from the given HDF5 data. + Parameters + ---------- + hdf5_data : h5py.File + The HDF5 file object containing the dataset. + Returns + ------- + list of str + A list of keys corresponding to RGB cameras in the dataset. + """ + + rgb_cameras = [ + key for key in hdf5_data["/observations/images"] if "depth" not in key + ] + return rgb_cameras + + @staticmethod + def get_state(hdf5_data: h5py.File): + """ + Extracts the list of RGB camera keys from the given HDF5 data. + Parameters + ---------- + hdf5_data : h5py.File + The HDF5 file object containing the dataset. + Returns + ------- + states : list of str + A list of keys corresponding to states in the dataset. + """ + + states = [key for key in hdf5_data["/observations"] if "images" not in key] + return states + + @staticmethod + def check_format( + episode_list: list[str] | list[Path], image_compressed: bool = True + ): + """ + Check the format of the given list of HDF5 files. + Parameters + ---------- + episode_list : list of str or list of Path + List of paths to the HDF5 files to be checked. + image_compressed : bool, optional + Flag indicating whether the images are compressed (default is True). + Raises + ------ + ValueError + If the episode_list is empty. + If any HDF5 file is missing required keys '/action' or '/observations/joint_positions'. + If the '/action' or '/observations/joint_positions' keys do not have 2 dimensions. + If the number of frames in '/action' and '/observations/joint_positions' keys do not match. + If the number of frames in '/observations/images/{camera}' does not match the number of frames in '/action' and '/observations/joint_positions'. + If the dimensions of images do not match the expected dimensions based on the image_compressed flag. + If uncompressed images do not have the expected (h, w, c) format. + """ + + if not episode_list: + raise ValueError( + "No hdf5 files found in the raw directory. Make sure they are named '*.hdf5'" + ) + for episode_path in episode_list: + with h5py.File(episode_path, "r") as data: + # Check for required keys - h5py requires checking without leading slash or using get() + if "action" not in data or "observations" not in data or "joint_positions" not in data["observations"]: + raise ValueError( + "Missing required keys in the hdf5 file. Make sure the keys '/action' and '/observations/joint_positions' are present." + ) + + if ( + not data["/action"].ndim + == data["/observations/joint_positions"].ndim + == 2 + ): + raise ValueError( + "The '/action' and '/observations/joint_positions' keys should have both 2 dimensions." + ) + + if (num_frames := data["/action"].shape[0]) != data[ + "/observations/joint_positions" + ].shape[0]: + raise ValueError( + "The '/action' and '/observations/joint_positions' keys should have the same number of frames." + ) + + for camera in EvaHD5Extractor.get_cameras(data): + if num_frames != data[f"/observations/images/{camera}"].shape[0]: + raise ValueError( + f"The number of frames in '/observations/images/{camera}' should be the same as in '/action' and '/observations/joint_positions' keys." + ) + + expected_dims = 2 if image_compressed else 4 + if data[f"/observations/images/{camera}"].ndim != expected_dims: + raise ValueError( + f"Expect {expected_dims} dimensions for {'compressed' if image_compressed else 'uncompressed'} images but {data[f'/observations/images/{camera}'].ndim} provided." + ) + if not image_compressed: + b, h, w, c = data[f"/observations/images/{camera}"].shape + if not c < h and c < w: + raise ValueError( + f"Expect (h,w,c) image format but ({h=},{w=},{c=}) provided." + ) + + @staticmethod + def extract_episode_frames( + episode_path: str | Path, + features: dict[str, dict], + image_compressed: bool, + arm: str, + extrinsics: dict, + prestack: bool = False, + ) -> list[dict[str, torch.Tensor]]: + """ + Extract frames from an episode by processing it and using the feature dictionary. + + Parameters + ---------- + episode_path : str or Path + Path to the HDF5 file containing the episode data. + features : dict of str to dict + Dictionary where keys are feature identifiers and values are dictionaries with feature details. + image_compressed : bool + Flag indicating whether the images are stored in a compressed format. + arm : str + The arm to process (e.g., 'left', 'right', or 'both'). + extrinsics : dict + Camera extrinsics for the episode. + prestack : bool, optional + Whether to precompute action chunks, by default False. + + Returns + ------- + list[dict[str, torch.Tensor]] + List of frames, where each frame is a dictionary mapping feature identifiers to tensors. + """ + frames = [] + episode_feats = EvaHD5Extractor.process_episode( + episode_path, arm=arm, extrinsics=extrinsics, prestack=prestack + ) + num_frames = next(iter(episode_feats["observations"].values())).shape[0] + for frame_idx in range(num_frames): + frame = {} + for feature_id, feature_info in features.items(): + if "observations" in feature_id: + value = episode_feats["observations"][feature_id.split(".", 1)[-1]] + else: + value = episode_feats.get(feature_id, None) + if value is None: + break + if value is not None: + if isinstance(value, np.ndarray): + if "images" in feature_id and image_compressed: + decompressed_image = cv2.imdecode(value[frame_idx], 1) + frame[feature_id] = torch.from_numpy( + decompressed_image.transpose(2, 0, 1) + ) + else: + frame[feature_id] = torch.from_numpy(value[frame_idx]) + elif isinstance(value, torch.Tensor): + frame[feature_id] = value[frame_idx] + else: + logging.warning( + f"[EvaHD5Extractor] Could not add dataset key at {feature_id} due to unsupported type. Skipping ..." + ) + continue + + frames.append(frame) + return frames + + @staticmethod + def define_features( + episode_feats: dict, image_compressed: bool = True, encode_as_video: bool = True + ) -> tuple: + """ + Define features from episode_feats (output of process_episode), including a metadata section. + + Parameters + ---------- + episode_feats : dict + The output of the process_episode method, containing feature data. + image_compressed : bool, optional + Whether the images are compressed, by default True. + encode_as_video : bool, optional + Whether to encode images as video or as images, by default True. + + Returns + ------- + tuple of dict[str, dict] + A dictionary where keys are feature names and values are dictionaries + containing feature information such as dtype, shape, and dimension names, + and a separate dictionary for metadata (unused for now) + """ + features = {} + metadata = {} + + for key, value in episode_feats.items(): + if isinstance(value, dict): # Handle nested dictionaries recursively + nested_features, nested_metadata = EvaHD5Extractor.define_features( + value, image_compressed, encode_as_video + ) + features.update( + { + f"{key}.{nested_key}": nested_value + for nested_key, nested_value in nested_features.items() + } + ) + features.update( + { + f"{key}.{nested_key}": nested_value + for nested_key, nested_value in nested_metadata.items() + } + ) + elif isinstance(value, np.ndarray): + dtype = str(value.dtype) + if "images" in key: + dtype = "video" if encode_as_video else "image" + if image_compressed: + decompressed_sample = cv2.imdecode(value[0], 1) + shape = ( + decompressed_sample.shape[1], + decompressed_sample.shape[0], + decompressed_sample.shape[2], + ) + else: + shape = value.shape[1:] # Skip the frame count dimension + dim_names = ["channel", "height", "width"] + elif "actions" in key and len(value[0].shape) > 1: + shape = value[0].shape + dim_names = ["chunk_length", "action_dim"] + dtype = f"prestacked_{str(value.dtype)}" + else: + shape = value[0].shape + dim_names = [f"dim_{i}" for i in range(len(shape))] + features[key] = { + "dtype": dtype, + "shape": shape, + "names": dim_names, + } + elif isinstance(value, torch.Tensor): + dtype = str(value.dtype) + shape = tuple(value[0].size()) + if "actions" in key and len(tuple(value[0].size())) > 1: + dim_names = ["chunk_length", "action_dim"] + dtype = f"prestacked_{str(value.dtype)}" + else: + dim_names = [f"dim_{i}" for i in range(len(shape))] + dim_names = [f"dim_{i}" for i in range(len(shape))] + features[key] = { + "dtype": dtype, + "shape": shape, + "names": dim_names, + } + else: + metadata[key] = { + "dtype": "metadata", + "value": value, + } + + return features, metadata \ No newline at end of file diff --git a/egomimic/scripts/zarr_data_viz.ipynb b/egomimic/scripts/zarr_data_viz.ipynb index 5df1d6f6..822580fb 100644 --- a/egomimic/scripts/zarr_data_viz.ipynb +++ b/egomimic/scripts/zarr_data_viz.ipynb @@ -5,7 +5,7 @@ "id": "29aeeb40", "metadata": {}, "source": [ - "# Zarr batch viz (single episode in MultiDataset)\n", + "# Eva Data\n", "\n", "This notebook builds a `MultiDataset` containing exactly one `ZarrDataset`, loads one batch, visualizes one image with `mediapy`, and prints the rest of the batch." ] @@ -20,17 +20,23 @@ "from pathlib import Path\n", "import torch\n", "import mediapy as mpy\n", + "import imageio_ffmpeg\n", + "import cv2\n", + "from scipy.spatial.transform import Rotation as R\n", "\n", "from egomimic.rldb.zarr.zarr_dataset_multi import ZarrDataset, MultiDataset\n", "from egomimic.utils.egomimicUtils import EXTRINSICS\n", "from egomimic.rldb.zarr.action_chunk_transforms import (\n", - " _matrix_to_xyzypr,\n", + " _matrix_to_xyzwxyz,\n", " build_aria_bimanual_transform_list,\n", " build_eva_bimanual_transform_list,\n", ")\n", "\n", "import numpy as np\n", - "from egomimic.utils.egomimicUtils import INTRINSICS, draw_actions\n" + "from egomimic.utils.egomimicUtils import INTRINSICS, draw_actions, cam_frame_to_cam_pixels, nds\n", + "\n", + "# Ensure mediapy can find an ffmpeg executable in this environment\n", + "mpy.set_ffmpeg(imageio_ffmpeg.get_ffmpeg_exe())" ] }, { @@ -41,7 +47,7 @@ "outputs": [], "source": [ "# Point this at a single episode directory, e.g. /path/to/episode_hash.zarr\n", - "EPISODE_PATH = Path(\"/coc/flash7/rco3/EgoVerse/egomimic/rldb/zarr/zarr/new/1769460905119.zarr\")\n", + "EPISODE_PATH = Path(\"/coc/flash7/scratch/egoverseDebugDatasets/1767495035712.zarr\")\n", "\n", "key_map = {\n", " \"images.front_1\": {\"zarr_key\": \"images.front_1\"},\n", @@ -61,14 +67,14 @@ "ACTION_STRIDE = 1 # set to 3 for Aria-style anchor sampling\n", "\n", "extrinsics = EXTRINSICS[\"x5Dec13_2\"]\n", - "left_extrinsics_pose = _matrix_to_xyzypr(extrinsics[\"left\"][None, :])[0]\n", - "right_extrinsics_pose = _matrix_to_xyzypr(extrinsics[\"right\"][None, :])[0]\n", + "left_extrinsics_pose = _matrix_to_xyzwxyz(extrinsics[\"left\"][None, :])[0]\n", + "right_extrinsics_pose = _matrix_to_xyzwxyz(extrinsics[\"right\"][None, :])[0]\n", "\n", "transform_list = build_eva_bimanual_transform_list(\n", " chunk_length=ACTION_CHUNK_LENGTH,\n", " stride=ACTION_STRIDE,\n", - " left_extra_batch_key={\"left_extrinsics_pose\": left_extrinsics_pose},\n", - " right_extra_batch_key={\"right_extrinsics_pose\": right_extrinsics_pose},\n", + " # left_extra_batch_key={\"left_extrinsics_pose\": left_extrinsics_pose},\n", + " # right_extra_batch_key={\"right_extrinsics_pose\": right_extrinsics_pose},\n", ")\n" ] }, @@ -90,6 +96,17 @@ "loader = torch.utils.data.DataLoader(multi_ds, batch_size=1, shuffle=False)\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "86338e96", + "metadata": {}, + "outputs": [], + "source": [ + "batch = next(iter(loader))\n", + "nds(batch)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -97,14 +114,31 @@ "metadata": {}, "outputs": [], "source": [ - "def viz_batch(batch, image_key, action_key):\n", + "def _split_action_pose(actions):\n", + " # 14D layout: [L xyz ypr g, R xyz ypr g]\n", + " # 12D layout: [L xyz ypr, R xyz ypr]\n", + " if actions.shape[-1] == 14:\n", + " left_xyz = actions[:, :3]\n", + " left_ypr = actions[:, 3:6]\n", + " right_xyz = actions[:, 7:10]\n", + " right_ypr = actions[:, 10:13]\n", + " elif actions.shape[-1] == 12:\n", + " left_xyz = actions[:, :3]\n", + " left_ypr = actions[:, 3:6]\n", + " right_xyz = actions[:, 6:9]\n", + " right_ypr = actions[:, 9:12]\n", + " else:\n", + " raise ValueError(f\"Unsupported action dim {actions.shape[-1]}\")\n", + " return left_xyz, left_ypr, right_xyz, right_ypr\n", + "\n", + "\n", + "def viz_batch(batch, image_key, action_key, intrinsics_key):\n", " # Image: (C,H,W) -> (H,W,C)\n", " img = batch[image_key][0].detach().cpu()\n", " if img.shape[0] in (1, 3):\n", " img = img.permute(1, 2, 0)\n", " img_np = img.numpy()\n", "\n", - " # Make image drawable uint8\n", " if img_np.dtype != np.uint8:\n", " if img_np.max() <= 1.0:\n", " img_np = (img_np * 255.0).clip(0, 255).astype(np.uint8)\n", @@ -113,19 +147,9 @@ " if img_np.shape[-1] == 1:\n", " img_np = np.repeat(img_np, 3, axis=-1)\n", "\n", - " intrinsics = INTRINSICS[\"base\"]\n", + " intrinsics = INTRINSICS[intrinsics_key]\n", " actions = batch[action_key][0].detach().cpu().numpy()\n", - "\n", - " # 14D layout: [L xyz ypr g, R xyz ypr g]\n", - " # 12D layout: [L xyz ypr, R xyz ypr]\n", - " if actions.shape[-1] == 14:\n", - " left_xyz = actions[:, :3]\n", - " right_xyz = actions[:, 7:10]\n", - " elif actions.shape[-1] == 12:\n", - " left_xyz = actions[:, :3]\n", - " right_xyz = actions[:, 6:9]\n", - " else:\n", - " raise ValueError(f\"Unsupported action dim {actions.shape[-1]} for key {action_key}\")\n", + " left_xyz, _, right_xyz, _ = _split_action_pose(actions)\n", "\n", " vis = draw_actions(\n", " img_np.copy(), type=\"xyz\", color=\"Blues\",\n", @@ -135,48 +159,141 @@ " vis, type=\"xyz\", color=\"Reds\",\n", " actions=right_xyz, extrinsics=None, intrinsics=intrinsics, arm=\"right\"\n", " )\n", - "\n", - " return vis\n", - "\n" + " return vis" ] }, { "cell_type": "code", "execution_count": null, - "id": "8eef8507", + "id": "89be6d5b", "metadata": {}, "outputs": [], "source": [ - "image_key = \"images.front_1\"\n", - "action_key = \"actions_cartesian\"\n", + "def viz_batch_ypr(batch, image_key, action_key, intrinsics_key, axis_len_m=0.04):\n", + " img = batch[image_key][0].detach().cpu()\n", + " if img.shape[0] in (1, 3):\n", + " img = img.permute(1, 2, 0)\n", + " img_np = img.numpy()\n", "\n", - "for batch in loader:\n", - " for k, v in batch.items():\n", - " print(f\"{k}: {tuple(v.shape)}\")\n", + " if img_np.dtype != np.uint8:\n", + " if img_np.max() <= 1.0:\n", + " img_np = (img_np * 255.0).clip(0, 255).astype(np.uint8)\n", + " else:\n", + " img_np = img_np.clip(0, 255).astype(np.uint8)\n", + " if img_np.shape[-1] == 1:\n", + " img_np = np.repeat(img_np, 3, axis=-1)\n", + "\n", + " intrinsics = INTRINSICS[intrinsics_key]\n", + " actions = batch[action_key][0].detach().cpu().numpy()\n", + " left_xyz, left_ypr, right_xyz, right_ypr = _split_action_pose(actions)\n", + "\n", + " vis = img_np.copy()\n", + "\n", + " def _draw_axis_color_legend(frame):\n", + " h, w = frame.shape[:2]\n", + " x_right = w - 12\n", + " y_start = 14\n", + " y_step = 12\n", + " line_len = 24\n", + " axis_legend = [\n", + " (\"x\", (255, 0, 0)),\n", + " (\"y\", (0, 255, 0)),\n", + " (\"z\", (0, 0, 255)),\n", + " ]\n", + " for i, (name, color) in enumerate(axis_legend):\n", + " y = y_start + i * y_step\n", + " x0 = x_right - line_len\n", + " x1 = x_right\n", + " cv2.line(frame, (x0, y), (x1, y), color, 3)\n", + " cv2.putText(\n", + " frame, name, (x0 - 12, y + 4),\n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1, cv2.LINE_AA,\n", + " )\n", + " return frame\n", + "\n", + " def _draw_rotation_at_palm(frame, xyz_seq, ypr_seq, label, anchor_color):\n", + " if len(xyz_seq) == 0 or len(ypr_seq) == 0:\n", + " return frame\n", + "\n", + " palm_xyz = xyz_seq[0]\n", + " palm_ypr = ypr_seq[0]\n", + " rot = R.from_euler(\"ZYX\", palm_ypr, degrees=False).as_matrix()\n", + " # print(np.linalg.det(rot))\n", + "\n", + " axis_points_cam = np.vstack([\n", + " palm_xyz,\n", + " palm_xyz + rot[:, 0] * axis_len_m,\n", + " palm_xyz + rot[:, 1] * axis_len_m,\n", + " palm_xyz + rot[:, 2] * axis_len_m,\n", + " ])\n", + "\n", + " px = cam_frame_to_cam_pixels(axis_points_cam, intrinsics)[:, :2]\n", + " if not np.isfinite(px).all():\n", + " return frame\n", "\n", - " vis = viz_batch(batch, image_key=image_key, action_key=action_key)\n", - " mpy.show_image(vis)\n", - " break\n" + " pts = np.round(px).astype(np.int32)\n", + "\n", + " h, w = frame.shape[:2]\n", + " x0, y0 = pts[0]\n", + " if not (0 <= x0 < w and 0 <= y0 < h):\n", + " return frame\n", + "\n", + " cv2.circle(frame, (x0, y0), 4, anchor_color, -1)\n", + " axis_colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)] # x,y,z as RGB\n", + "\n", + " for i, color in enumerate(axis_colors, start=1):\n", + " x1, y1 = pts[i]\n", + " if 0 <= x1 < w and 0 <= y1 < h:\n", + " cv2.line(frame, (x0, y0), (x1, y1), color, 2)\n", + " cv2.circle(frame, (x1, y1), 2, color, -1)\n", + "\n", + " cv2.putText(\n", + " frame, label, (x0 + 6, max(12, y0 - 8)),\n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.4, anchor_color, 1, cv2.LINE_AA,\n", + " )\n", + " return frame\n", + "\n", + " vis = _draw_rotation_at_palm(vis, left_xyz, left_ypr, \"L rot\", (255, 180, 80))\n", + " vis = _draw_rotation_at_palm(vis, right_xyz, right_ypr, \"R rot\", (80, 180, 255))\n", + " vis = _draw_axis_color_legend(vis)\n", + " return vis" ] }, { "cell_type": "code", "execution_count": null, - "id": "b94b8c83", + "id": "4b72f3bb", "metadata": {}, "outputs": [], "source": [ - "batch[\"actions_cartesian\"][0, 0]\n" + "# Separate YPR visualization preview\n", + "image_key = \"images.front_1\"\n", + "action_key = \"actions_cartesian\"\n", + "\n", + "for batch in loader:\n", + " vis_ypr = viz_batch_ypr(batch, image_key=image_key, action_key=action_key, intrinsics_key=\"base\")\n", + " mpy.show_image(vis_ypr)\n", + " break" ] }, { "cell_type": "code", "execution_count": null, - "id": "4b818cad", + "id": "0d8c3da2", "metadata": {}, "outputs": [], "source": [ - "batch[\"observations.state.ee_pose\"][0]\n" + "image_key = \"images.front_1\"\n", + "action_key = \"actions_cartesian\"\n", + "\n", + "images = []\n", + "for i, batch in enumerate(loader):\n", + " vis = viz_batch(batch, image_key=image_key, action_key=action_key, intrinsics_key=\"base\")\n", + " images.append(vis)\n", + " if i > 100:\n", + " break\n", + "\n", + "mpy.show_video(images, fps=30)" ] }, { @@ -184,7 +301,8 @@ "id": "1a3382f1", "metadata": {}, "source": [ - "## Aria Datasets" + "## Human Datasets\n", + "Mecka, Scale and Aria should all run exactly the same" ] }, { @@ -206,7 +324,13 @@ "outputs": [], "source": [ "# Aria-style chunking example: horizon=30 contiguous frames, sample anchors every 3 -> 10 points, then interpolate to 100.\n", - "EPISODE_PATH = Path(\"/coc/flash7/scratch/egoverseDebugDatasets/proc_zarr/1764285211791.zarr/\")\n", + "\n", + "# EPISODE_PATH = Path(\"/coc/flash7/scratch/egoverseDebugDatasets/scale/697a9070da7b91acaf3f2d88_episode_000000.zarr\") # Scale\n", + "# intrinsics_key = \"scale\"\n", + "\n", + "EPISODE_PATH = Path(\"/coc/flash7/scratch/egoverseDebugDatasets/1767671007927.zarr/\") # Aria\n", + "intrinsics_key = \"base\"\n", + "\n", "\n", "key_map = {\n", " \"images.front_1\": {\"zarr_key\": \"images.front_1\"},\n", @@ -223,8 +347,6 @@ "transform_list = build_aria_bimanual_transform_list(\n", " chunk_length=ACTION_CHUNK_LENGTH,\n", " stride=ACTION_STRIDE,\n", - " left_action_world=\"left.action_ee_pose\",\n", - " right_action_world=\"right.action_ee_pose\",\n", ")\n" ] }, @@ -236,8 +358,8 @@ "outputs": [], "source": [ "# Build a MultiDataset with exactly one ZarrDataset inside\n", - "# single_ds = ZarrDataset(Episode_path=EPISODE_PATH, key_map=key_map, transform_list=transform_list)\n", - "single_ds = ZarrDataset(Episode_path=EPISODE_PATH, key_map=key_map)\n", + "single_ds = ZarrDataset(Episode_path=EPISODE_PATH, key_map=key_map, transform_list=transform_list)\n", + "#single_ds = ZarrDataset(Episode_path=EPISODE_PATH, key_map=key_map)\n", "multi_ds = MultiDataset(datasets={\"single_episode\": single_ds}, mode=\"total\")\n", "\n", "print(\"len(single_ds):\", len(single_ds))\n", @@ -257,10 +379,7 @@ "outputs": [], "source": [ "batch = next(iter(loader))\n", - "print(\"Batch keys:\", list(batch.keys()))\n", - "print(batch[\"right.action_ee_pose\"][0, 0])\n", - "print(batch[\"left.action_ee_pose\"][0, 0])\n", - "print(batch[\"obs_head_pose\"][0])" + "nds(batch)" ] }, { @@ -278,7 +397,7 @@ " first_img = batch[image_key][0].detach().cpu().permute(1, 2, 0).numpy()\n", " first_img = (first_img * 255.0).clip(0, 255).astype(np.uint8)\n", "\n", - " vis = viz_batch(batch, image_key=image_key, action_key=action_key)\n", + " vis = viz_batch(batch, image_key=image_key, action_key=action_key, intrinsics_key=intrinsics_key)\n", " ims.append(vis)\n", " # mpy.show_image(vis)\n", "\n", @@ -291,6 +410,27 @@ "mpy.show_video(ims, fps=30)\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6d8d872", + "metadata": {}, + "outputs": [], + "source": [ + "# Aria YPR video (same data loop, YPR overlay)\n", + "image_key = \"images.front_1\"\n", + "action_key = \"actions_cartesian\"\n", + "\n", + "ims_ypr = []\n", + "for i, batch in enumerate(loader):\n", + " vis_ypr = viz_batch_ypr(batch, image_key=image_key, action_key=action_key, intrinsics_key=\"base\")\n", + " ims_ypr.append(vis_ypr)\n", + " if i > 200:\n", + " break\n", + "\n", + "mpy.show_video(ims_ypr, fps=30)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -301,28 +441,168 @@ "batch[\"actions_cartesian\"][0, 0]\n" ] }, + { + "cell_type": "markdown", + "id": "efecaba7", + "metadata": {}, + "source": [ + "## Keypoint Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e39bca03", + "metadata": {}, + "outputs": [], + "source": [ + "# Load Scale episode with raw keypoints (no action chunking needed)\n", + "from egomimic.rldb.zarr.action_chunk_transforms import _xyzwxyz_to_matrix\n", + "from egomimic.utils.egomimicUtils import cam_frame_to_cam_pixels, draw_dot_on_frame\n", + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "\n", + "EPISODE_PATH_KP = EPISODE_PATH\n", + "\n", + "key_map_kp = {\n", + " \"images.front_1\": {\"zarr_key\": \"images.front_1\"},\n", + " \"left.obs_keypoints\": {\"zarr_key\": \"left.obs_keypoints\"},\n", + " \"right.obs_keypoints\": {\"zarr_key\": \"right.obs_keypoints\"},\n", + " \"obs_head_pose\": {\"zarr_key\": \"obs_head_pose\"},\n", + "}\n", + "\n", + "single_ds_kp = ZarrDataset(Episode_path=EPISODE_PATH_KP, key_map=key_map_kp)\n", + "multi_ds_kp = MultiDataset(datasets={\"single_episode\": single_ds_kp}, mode=\"total\")\n", + "loader_kp = torch.utils.data.DataLoader(multi_ds_kp, batch_size=1, shuffle=False)\n", + "print(f\"Keypoint dataset: {len(single_ds_kp)} frames\")" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "5bd2e1fc", + "id": "848c6d74", "metadata": {}, "outputs": [], "source": [ - "batch[\"\"]" + "# MANO skeleton edges: (parent, child) for drawing bones\n", + "MANO_EDGES = [\n", + " (0, 1), (1, 2), (2, 3), (3, 4), # thumb\n", + " (0, 5), (5, 6), (6, 7), (7, 8), # index\n", + " (0, 9), (9, 10), (10, 11), (11, 12), # middle\n", + " (0, 13), (13, 14), (14, 15), (15, 16), # ring\n", + " (0, 17), (17, 18), (18, 19), (19, 20), # pinky\n", + "]\n", + "\n", + "FINGER_COLORS = {\n", + " \"thumb\": (255, 100, 100), # red\n", + " \"index\": (100, 255, 100), # green\n", + " \"middle\": (100, 100, 255), # blue\n", + " \"ring\": (255, 255, 100), # yellow\n", + " \"pinky\": (255, 100, 255), # magenta\n", + "}\n", + "FINGER_EDGE_RANGES = [\n", + " (\"thumb\", 0, 4), (\"index\", 4, 8), (\"middle\", 8, 12),\n", + " (\"ring\", 12, 16), (\"pinky\", 16, 20),\n", + "]\n", + "\n", + "\n", + "def viz_keypoints(batch, image_key=\"images.front_1\"):\n", + " \"\"\"Visualize all 21 MANO keypoints per hand, projected onto the image.\"\"\"\n", + " # Prepare image\n", + " img = batch[image_key][0].detach().cpu()\n", + " if img.shape[0] in (1, 3):\n", + " img = img.permute(1, 2, 0)\n", + " img_np = img.numpy()\n", + " if img_np.dtype != np.uint8:\n", + " if img_np.max() <= 1.0:\n", + " img_np = (img_np * 255.0).clip(0, 255).astype(np.uint8)\n", + " else:\n", + " img_np = img_np.clip(0, 255).astype(np.uint8)\n", + " if img_np.shape[-1] == 1:\n", + " img_np = np.repeat(img_np, 3, axis=-1)\n", + "\n", + " intrinsics = INTRINSICS[\"scale\"]\n", + " head_pose = batch[\"obs_head_pose\"][0].detach().cpu().numpy() # (6,)\n", + "\n", + " # T_head_world: camera pose in world (camera-to-world)\n", + " # We need world-to-camera = inv(T_head_world)\n", + " T_head_world = _xyzwxyz_to_matrix(head_pose[None, :])[0] # (4, 4)\n", + " T_world_to_cam = np.linalg.inv(T_head_world)\n", + "\n", + " vis = img_np.copy()\n", + " h, w = vis.shape[:2]\n", + "\n", + " for hand, dot_color in [(\"left\", (0, 120, 255)), (\"right\", (255, 80, 0))]:\n", + " kps_key = f\"{hand}.obs_keypoints\"\n", + " if kps_key not in batch:\n", + " continue\n", + " kps_flat = batch[kps_key][0].detach().cpu().numpy() # (63,)\n", + " kps_world = kps_flat.reshape(21, 3)\n", + "\n", + " # Skip if keypoints are all zero (invalid, clamped from 1e9)\n", + " if np.allclose(kps_world, 0.0, atol=1e-3):\n", + " continue\n", + "\n", + " # World -> camera frame\n", + " kps_h = np.concatenate([kps_world, np.ones((21, 1))], axis=1) # (21, 4)\n", + " kps_cam = (T_world_to_cam @ kps_h.T).T[:, :3] # (21, 3)\n", + "\n", + " # Camera frame -> pixels\n", + " kps_px = cam_frame_to_cam_pixels(kps_cam, intrinsics) # (21, 3+)\n", + "\n", + " # Identify valid keypoints (z > 0 and in image bounds)\n", + " valid = (kps_cam[:, 2] > 0.01)\n", + " valid &= (kps_px[:, 0] >= 0) & (kps_px[:, 0] < w)\n", + " valid &= (kps_px[:, 1] >= 0) & (kps_px[:, 1] < h)\n", + "\n", + " # Draw skeleton edges (colored by finger)\n", + " for finger, start, end in FINGER_EDGE_RANGES:\n", + " color = FINGER_COLORS[finger]\n", + " for edge_idx in range(start, end):\n", + " i, j = MANO_EDGES[edge_idx]\n", + " if valid[i] and valid[j]:\n", + " p1 = (int(kps_px[i, 0]), int(kps_px[i, 1]))\n", + " p2 = (int(kps_px[j, 0]), int(kps_px[j, 1]))\n", + " cv2.line(vis, p1, p2, color, 2)\n", + "\n", + " # Draw keypoint dots on top\n", + " for k in range(21):\n", + " if valid[k]:\n", + " center = (int(kps_px[k, 0]), int(kps_px[k, 1]))\n", + " cv2.circle(vis, center, 4, dot_color, -1)\n", + " cv2.circle(vis, center, 4, (255, 255, 255), 1) # white border\n", + "\n", + " # Label wrist\n", + " if valid[0]:\n", + " wrist_px = (int(kps_px[0, 0]) + 6, int(kps_px[0, 1]) - 6)\n", + " cv2.putText(vis, f\"{hand[0].upper()}\", wrist_px,\n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.5, dot_color, 2)\n", + "\n", + " return vis" ] }, { "cell_type": "code", "execution_count": null, - "id": "cb4a930c", + "id": "75dbfa95", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Render keypoint video\n", + "ims_kp = []\n", + "for i, batch_kp in enumerate(loader_kp):\n", + " vis = viz_keypoints(batch_kp)\n", + " ims_kp.append(vis)\n", + " if i > 200:\n", + " break\n", + "\n", + "mpy.show_video(ims_kp, fps=30)" + ] } ], "metadata": { "kernelspec": { - "display_name": "emimic", + "display_name": "emimic2 (3.11.14)", "language": "python", "name": "python3" }, diff --git a/egomimic/trainHydra.py b/egomimic/trainHydra.py index b0aae90c..d28ebfcb 100644 --- a/egomimic/trainHydra.py +++ b/egomimic/trainHydra.py @@ -7,7 +7,7 @@ from lightning.pytorch.loggers import Logger from lightning.pytorch.plugins.environments import SLURMEnvironment import signal -from omegaconf import DictConfig, OmegaConf +from omegaconf import DictConfig, OmegaConf, ListConfig OmegaConf.register_new_resolver("eval", eval) @@ -22,13 +22,54 @@ log = RankedLogger(__name__, rank_zero_only=True) -from egomimic.rldb.utils import DataSchematic +from egomimic.rldb.zarr.utils import DataSchematic import os # DEBUG # os.environ["HYDRA_FULL_ERROR"] = '1' +def create_data_schematic(zarr_data_cfg: DictConfig) -> DataSchematic: + schematic_dict = {} + + def populate_key_map(cfg, target_key="key_map", key_map={}): + """ + Populate key_map with the key_map configuration. + """ + if isinstance(cfg, DictConfig): + if target_key in cfg: + for k, v in cfg[target_key].items(): + key_map[k] = v + return + + for k in cfg.keys(): + v = cfg.get(k) + populate_key_map(v, target_key, key_map) + + elif isinstance(cfg, ListConfig): + for i, v in enumerate(cfg): + populate_key_map(v, target_key, key_map) + + for dataset_name in zarr_data_cfg.train_datasets: + dataset_cfg = zarr_data_cfg.train_datasets[dataset_name] + dataset_key_map = {} + populate_key_map(dataset_cfg, "key_map", dataset_key_map) + schematic_dict[dataset_name] = { + key: { + "key_type": value["key_type"], + "zarr_key": value["zarr_key"], + } + for key, value in dataset_key_map.items() + } + + viz_img_key = { + "eva_bimanual": "front_img_1", + "aria_bimanual": "front_img_1", + "mecka_bimanual": "front_img_1", + "scale_bimanual": "front_img_1", + } # TODO: figure out where to put viz keys + return DataSchematic(schematic_dict, viz_img_key, norm_mode="quantile") + @task_wrapper def train(cfg: DictConfig) -> Tuple[Dict[str, Any], Dict[str, Any]]: @@ -45,8 +86,9 @@ def train(cfg: DictConfig) -> Tuple[Dict[str, Any], Dict[str, Any]]: if cfg.get("seed"): L.seed_everything(cfg.seed, workers=True) - log.info(f"Instantiating data schematic <{cfg.data_schematic._target_}>") - data_schematic: DataSchematic = hydra.utils.instantiate(cfg.data_schematic) + # log.info(f"Instantiating data schematic <{cfg.data_schematic._target_}>") + + data_schematic: DataSchematic = create_data_schematic(cfg.data) # Modify dataset configs to include `data_schematic` dynamically at runtime train_datasets = {} @@ -75,7 +117,7 @@ def train(cfg: DictConfig) -> Tuple[Dict[str, Any], Dict[str, Any]]: for dataset_name, dataset in datamodule.train_datasets.items(): log.info(f"Inferring shapes for dataset <{dataset_name}>") data_schematic.infer_shapes_from_batch(dataset[0]) - data_schematic.infer_norm_from_dataset(dataset) + data_schematic.infer_norm_from_dataset_zarr(dataset, dataset_name) # NOTE: We also pass the data_schematic_dict into the robomimic model's instatiation now that we've initialzied the shapes and norm stats. In theory, upon loading the PL checkpoint, it will remember this, but let's see. log.info(f"Instantiating model <{cfg.model._target_}>") diff --git a/egomimic/utils/egomimicUtils.py b/egomimic/utils/egomimicUtils.py index 90d9a162..a6bc20b9 100644 --- a/egomimic/utils/egomimicUtils.py +++ b/egomimic/utils/egomimicUtils.py @@ -38,6 +38,12 @@ ] ) +SCALE_INTRINSICS = np.array([ + [214.134, 0.0, 324.593, 0], + [0.0, 256.968, 260.146, 0], + [0.0, 0.0, 1.0, 0] +]) + w0, h0 = float(1920), float(1080) fx0, fy0 = float(752.4707352849115), float(753.0015979987369) cx0, cy0 = float(961.8249427694457), float(553.245895705989) @@ -218,16 +224,20 @@ [-0.9983006 , 0.05811952, -0.00424732, 0.32539554], [-0.0339837 , -0.63983444, -0.76776103, 0.64809634], [ 0. , 0. , 0. , 1. ]]) + }, + "scale": { + "left": np.eye(4), + "right": np.eye(4), } } -INTRINSICS = {"base": ARIA_INTRINSICS, "base_half": ARIA_INTRINSICS_HALF, "mecka": MECKA_INTRINSICS} +INTRINSICS = {"base": ARIA_INTRINSICS, "base_half": ARIA_INTRINSICS_HALF, "mecka": MECKA_INTRINSICS, "scale": SCALE_INTRINSICS} class CameraTransforms: def __init__(self, intrinsics_key, extrinsics_key): self.intrinsics = INTRINSICS[intrinsics_key] - self.extrinsics = EXTRINSICS.get(extrinsics_key, None) + self.extrinsics = EXTRINSICS[extrinsics_key] ## HPT Utils @@ -512,7 +522,7 @@ def draw_rotation_text( def draw_actions(im, type, color, actions, extrinsics, intrinsics, arm="both", kinematics_solver=None): """ args: - im: (H, W, C) in [0, 255] + im: (H, W, C) type: "joints" or "xyz" color: ex) "Purples", "Blues", "Greens" actions: (N, 6) or (N, 3) if type is "xyz" or (N, 7) or (N, 14) if type is "joints" @@ -614,9 +624,11 @@ def nds(nested_ds, tab_level=0): print("None") elif isinstance(nested_ds, Number): print("Number: ", nested_ds) - else: + elif isinstance(nested_ds, np.ndarray) or isinstance(nested_ds, torch.Tensor): # print('\t' * (tab_level), end='') print(nested_ds.shape) + else: + print("Type: ", type(nested_ds)) if is_key(nested_ds): for key, value in nested_ds.items(): diff --git a/external/scale/scripts/sfsEgoverseUtils.py b/external/scale/scripts/sfsEgoverseUtils.py new file mode 100644 index 00000000..e3018f26 --- /dev/null +++ b/external/scale/scripts/sfsEgoverseUtils.py @@ -0,0 +1,316 @@ +""" +SFS to Egoverse Utilities + +Scale API interactions, file downloading, and SFS data loading. +""" + +import json +import os +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Dict, Any, Optional +from urllib.parse import urlparse + +import boto3 +import numpy as np +import requests +import scipy.interpolate +from requests.auth import HTTPBasicAuth +from scaleapi import ScaleClient +from scale_sensor_fusion_io.loaders import SFSLoader +from sqlalchemy import MetaData, Table, create_engine, insert, inspect +from sqlalchemy.exc import IntegrityError + + +# Scale API Configuration +API_KEY = os.environ.get("SCALE_API_KEY", "") +if not API_KEY: + raise ValueError("SCALE_API_KEY environment variable must be set") + +client = ScaleClient(API_KEY) +auth = HTTPBasicAuth(API_KEY, '') + + +@dataclass +class TableRow: + episode_hash: str + operator: str + lab: str + task: str + embodiment: str + robot_name: str + num_frames: int = -1 # Updateable + task_description: str = "" + scene: str = "" + objects: str = "" + processed_path: str = "" # Updateable + processing_error: str = "" # Updateable + mp4_path: str = "" # Updateable + is_deleted: bool = False + is_eval: bool = False + eval_score: float = -1 + eval_success: bool = True + + +def interpolate_arr(v, seq_length): + """ + v: (B, T, D) + seq_length: int + """ + assert len(v.shape) == 3 + if v.shape[1] == seq_length: + return + + interpolated = [] + for i in range(v.shape[0]): + index = v[i] + + interp = scipy.interpolate.interp1d( + np.linspace(0, 1, index.shape[0]), index, axis=0 + ) + interpolated.append(interp(np.linspace(0, 1, seq_length))) + + return np.array(interpolated) + + +def interpolate_arr_euler(v: np.ndarray, seq_length: int) -> np.ndarray: + """ + Interpolate 6DoF poses (translation + Euler angles in radians), + optionally with a 7th gripper dimension, along the time axis. + + v: (B, T, 6) or (B, T, 7) + [x, y, z, yaw, pitch, roll, (optional) gripper] + """ + assert ( + v.ndim == 3 and v.shape[2] in (6, 7) + ), "Input v must be of shape (B, T, 6) or (B, T, 7)" + B, T, D = v.shape + + new_time = np.linspace(0, 1, seq_length) + old_time = np.linspace(0, 1, T) + + outputs = [] + + for i in range(B): + seq = v[i] # (T, D) + + if np.any(seq >= 1e8): + outputs.append(np.full((seq_length, D), 1e9)) + continue + + trans_seq = seq[:, :3] # x, y, z + rot_seq = seq[:, 3:6] # yaw, pitch, roll + + # Avoid discontinuities in angle interpolation + rot_seq_unwrapped = np.unwrap(rot_seq, axis=0) + + trans_interp_func = scipy.interpolate.interp1d( + old_time, trans_seq, axis=0, kind="linear" + ) + rot_interp_func = scipy.interpolate.interp1d( + old_time, rot_seq_unwrapped, axis=0, kind="linear" + ) + + trans_interp = trans_interp_func(new_time) # (seq_length, 3) + rot_interp = rot_interp_func(new_time) # (seq_length, 3) + + # Wrap back to [-pi, pi) + rot_interp = (rot_interp + np.pi) % (2 * np.pi) - np.pi + + if D == 6: + out_seq = np.concatenate([trans_interp, rot_interp], axis=-1) + else: + grip_seq = seq[:, 6:7] # (T, 1) + grip_interp_func = scipy.interpolate.interp1d( + old_time, grip_seq, axis=0, kind="linear" + ) + grip_interp = grip_interp_func(new_time) # (seq_length, 1) + out_seq = np.concatenate( + [trans_interp, rot_interp, grip_interp], axis=-1 + ) + + outputs.append(out_seq) + + return np.stack(outputs, axis=0) # (B, seq_length, D) + + + +def create_default_engine(): + # Try to get credentials from Secrets Manager if SECRETS_ARN is set + SECRETS_ARN = os.environ.get("SECRETS_ARN") + if SECRETS_ARN: + secrets = boto3.client("secretsmanager") + sec = secrets.get_secret_value(SecretId=SECRETS_ARN)["SecretString"] + cfg = json.loads(sec) + HOST = cfg.get("host", cfg.get("HOST")) + DBNAME = cfg.get("dbname", cfg.get("DBNAME", "appdb")) + USER = cfg.get("username", cfg.get("user", cfg.get("USER"))) + PASSWORD = cfg.get("password", cfg.get("PASSWORD")) + PORT = cfg.get("port", 5432) + else: + # Fallback to hardcoded values for local testing + HOST = "lowuse-pg-east2.claua8sacyu5.us-east-2.rds.amazonaws.com" + DBNAME = "appdb" + USER = "appuser" + PASSWORD = "APPUSER_STRONG_PW" + PORT = 5432 + + # --- 1) connect via SQLAlchemy --- + engine = create_engine( + f"postgresql+psycopg://{USER}:{PASSWORD}@{HOST}:{PORT}/{DBNAME}?sslmode=require", + pool_pre_ping=True, + ) + + # --- 2) list tables in the schema 'app' --- + insp = inspect(engine) + print("Tables in schema 'app':", insp.get_table_names(schema="app")) + + return engine + + +def add_episode(engine, episode) -> bool: + """ + Insert one row into app.episodes. + Raises sqlalchemy.exc.IntegrityError if the row violates a unique/PK constraint. + """ + episodes_tbl = _episodes_table(engine) + row = asdict(episode) + + try: + with engine.begin() as conn: + conn.execute(insert(episodes_tbl).values(**row)) + return True + except IntegrityError as e: + # Duplicate (or other constraint) → surface a clear error + raise RuntimeError(f"Insert failed (likely duplicate episode_hash): {e}") from e + + +def get_simple_response_dict_egocentric(task_id: str) -> Optional[Dict[str, Any]]: + """Get URLs for annotations, SFS, and video streams from a Scale task. + + Also returns task metadata like customerId for SQL registration. + """ + try: + task = client.get_task(task_id) + resp = task.response + + # Get task dict for metadata + if hasattr(task, 'as_dict'): + task_data = task.as_dict() + else: + task_data = task.__dict__ + + response_dict = { + "annotations_url": resp["annotations"]["url"], + "sfs_url": resp["full_recording"]["sfs_url"], + # Task metadata for SQL + "customer_id": task_data.get("customerId", ""), + "project": task_data.get("project", ""), + "batch_id": task_data.get("batchId", ""), + } + + for video in resp["full_recording"]["video_urls"]: + if video["sensor_id"] == "left": + response_dict["left_rectified"] = video["rgb_url"] + else: + response_dict["right_rectified"] = video["rgb_url"] + + return response_dict + + except Exception as e: + print(f"Error retrieving task {task_id}: {e}") + return None + + +def _episodes_table(engine): + md = MetaData() + return Table("episodes", md, autoload_with=engine, schema="app") + + +def download_file_in_chunks(url: str, output_path: str, chunk_size: int = 8192) -> str: + """Download a file in chunks.""" + response = requests.get(url, stream=True) + response.raise_for_status() + + with open(output_path, 'wb') as f: + for chunk in response.iter_content(chunk_size=chunk_size): + f.write(chunk) + + return output_path + + +def download_from_simple_response_dict( + task_output_path: str, + simple_response_dict: Dict[str, str], + verbose: bool = False +) -> Dict[str, str]: + """Download all files from a response dictionary. Returns local paths. + + Only processes keys ending with '_url' or 'rectified' (actual download URLs). + Skips metadata fields like customer_id, project, batch_id. + """ + local_path_dict = {} + + # Keys that are actual URLs to download + url_keys = {'annotations_url', 'sfs_url', 'left_rectified', 'right_rectified'} + + for key, url in simple_response_dict.items(): + # Skip non-URL metadata fields + if key not in url_keys: + continue + + parsed = urlparse(url) + file_extension = Path(parsed.path).suffix + key_cleaned = key.replace('_url', '') + local_file_path = os.path.join(task_output_path, key_cleaned + file_extension) + local_path_dict[key_cleaned] = local_file_path + + if os.path.exists(local_file_path): + continue + + if verbose: + print(f"Downloading: {key_cleaned}") + try: + download_file_in_chunks(url, local_file_path) + except Exception as e: + print(f"Error downloading {key}: {e}") + + return local_path_dict + + +def load_scene(file_path: str) -> Optional[Dict[str, Any]]: + """Load an SFS file.""" + if not os.path.exists(file_path): + return None + + try: + loader = SFSLoader(file_path) + return loader.load_unsafe() + except Exception: + return None + + +def load_annotation_file(file_path: str) -> Optional[Dict[str, Any]]: + """Load an annotation JSON file.""" + try: + with open(file_path, 'r') as f: + data = f.read().rstrip('\x00') + return json.loads(data) + except Exception: + return None + + +def get_posepath(sfs_data: Dict[str, Any], sensor_id: str) -> Optional[Dict[str, Any]]: + """Get pose path for a sensor.""" + for sensor in sfs_data.get("sensors", []): + if sensor.get("id") == sensor_id: + return sensor.get("poses") + return None + + +def get_intrinsics(sfs_data: Dict[str, Any], sensor_id: str) -> Optional[Dict[str, float]]: + """Get camera intrinsics for a sensor.""" + for sensor in sfs_data.get("sensors", []): + if sensor.get("id") == sensor_id: + return sensor.get("intrinsics") + return None diff --git a/external/scale/scripts/sfs_to_egoverse_zarr.py b/external/scale/scripts/sfs_to_egoverse_zarr.py new file mode 100644 index 00000000..113200e6 --- /dev/null +++ b/external/scale/scripts/sfs_to_egoverse_zarr.py @@ -0,0 +1,636 @@ +#!/usr/bin/env python3 +""" +Scale SFS -> EgoVerse Zarr converter. + +Output keys per episode: + left.obs_ee_pose (T, 6) xyzypr + right.obs_ee_pose (T, 6) xyzypr + left.obs_keypoints (T, 63) 21 keypoints * 3 (xyz) + right.obs_keypoints (T, 63) 21 keypoints * 3 (xyz) + left.obs_wrist_pose (T, 6) xyzypr + right.obs_wrist_pose (T, 6) xyzypr + obs_head_pose (T, 6) xyzypr + images.front_1 (T, H, W, 3) JPEG-compressed by ZarrWriter + +Usage: + python sfs_to_egoverse_zarr.py --task-ids TASK1 TASK2 --output-dir ./zarr_out +""" + +from __future__ import annotations + +import argparse +import os +import shutil +import time +import traceback +from dataclasses import dataclass, field +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import cv2 +import numpy as np +from scipy.interpolate import interp1d +from scipy.spatial.transform import Rotation as R + +from egomimic.rldb.zarr.zarr_writer import ZarrWriter + +from sfsEgoverseUtils import ( + download_from_simple_response_dict, + get_intrinsics, + get_posepath, + get_simple_response_dict_egocentric, + load_annotation_file, + load_scene, +) + + +MANO_LABELS = [ + "hand_wrist", + "hand_thumb1", "hand_thumb2", "hand_thumb3", "hand_thumb4", + "hand_index1", "hand_index2", "hand_index3", "hand_index4", + "hand_middle1", "hand_middle2", "hand_middle3", "hand_middle4", + "hand_ring1", "hand_ring2", "hand_ring3", "hand_ring4", + "hand_pinky1", "hand_pinky2", "hand_pinky3", "hand_pinky4", +] +PALM_INDICES = [0, 5, 9, 13, 17] +NUM_KEYPOINTS = 21 + +INVALID_VALUE = 1e9 +ACTION_WINDOW = 30 +SUB_EPISODE_LENGTH = 300 +IMAGE_SIZE = (640, 480) # (W, H) for cv2.resize + + + + +# --------------------------------------------------------------------------- +# Data structures & extraction (unchanged from original) +# --------------------------------------------------------------------------- + +@dataclass +class HandKeypoints: + left: np.ndarray | None = None + right: np.ndarray | None = None + + +@dataclass +class CameraPose: + position: np.ndarray + quaternion: np.ndarray + rotation_matrix: np.ndarray + + @classmethod + def from_pose_array(cls, pose: list[float]) -> CameraPose: + position = np.array(pose[:3], dtype=np.float64) + quaternion = np.array(pose[3:7], dtype=np.float64) + rotation = R.from_quat(quaternion).as_matrix() + return cls(position=position, quaternion=quaternion, rotation_matrix=rotation) + + def get_transform_matrix(self) -> np.ndarray: + t = np.eye(4, dtype=np.float64) + t[:3, :3] = self.rotation_matrix + t[:3, 3] = self.position + return t + + +@dataclass +class FrameData: + frame_index: int + timestamp_us: int + camera_pose: CameraPose + hand_keypoints: HandKeypoints + text_annotations: list[dict[str, Any]] = field(default_factory=list) + subgoal: dict[str, Any] | None = None + collector_issue: dict[str, Any] | None = None + + +class SFSDataExtractor: + """Extracts per-frame metadata from SFS + annotation files.""" + + def __init__(self, sfs_path: str, annotation_path: str, video_path: str): + self.video_path = video_path + self.sfs_data = load_scene(sfs_path) + self.annotation_data = load_annotation_file(annotation_path) + + if self.sfs_data is None or self.annotation_data is None: + raise ValueError("Failed to load SFS or annotation data") + + self.camera_sensor_id = "left_rectified" + self.intrinsics = get_intrinsics(self.sfs_data, self.camera_sensor_id) + self.posepath = get_posepath(self.sfs_data, self.camera_sensor_id) + if self.intrinsics is None or self.posepath is None: + raise ValueError(f"Missing camera data for {self.camera_sensor_id}") + + self.timestamps = self.posepath.get("timestamps", []) + self.pose_values = self.posepath.get("values", []) + + self._build_keypoint_lookup() + self._build_annotation_lookup() + + # -- keypoint lookup (unchanged) -- + def _build_keypoint_lookup(self) -> None: + self.keypoint_paths: dict[str, dict[int, dict[int, Any]]] = {"left": {}, "right": {}} + for annotation in self.annotation_data.get("annotations", []): + if annotation.get("type") != "points": + continue + labels = annotation.get("labels", []) + paths = annotation.get("paths", []) + for i, label in enumerate(labels): + if i >= len(paths): + continue + hand_type = "left" if label.startswith("left_") else "right" if label.startswith("right_") else None + if hand_type is None: + continue + prefix_len = 5 if hand_type == "left" else 6 + keypoint_name = label[prefix_len:] + kp_idx = next((idx for idx, v in enumerate(MANO_LABELS) if v == keypoint_name), None) + if kp_idx is None: + continue + path = paths[i] + values = path.get("values", []) + for ts_idx, ts in enumerate(path.get("timestamps", [])): + self.keypoint_paths[hand_type].setdefault(ts, {}) + if ts_idx < len(values): + self.keypoint_paths[hand_type][ts][kp_idx] = values[ts_idx] + + def _build_annotation_lookup(self) -> None: + self.text_annotations: list[dict] = [] + self.subgoal_annotations: list[dict] = [] + self.collector_issues: list[dict] = [] + self.demonstration_metadata: dict[str, Any] = {} + + for attr in self.annotation_data.get("attributes", []): + values = attr.get("values", []) + if values: + self.demonstration_metadata[attr.get("name", "")] = values[0] + + for annotation in self.annotation_data.get("annotations", []): + if annotation.get("type") != "text_annotation": + continue + label = annotation.get("label", "") + for clip in annotation.get("clips", []): + start_ts = clip.get("timestamp", 0) + end_ts = start_ts + clip.get("duration", 0) + text = clip.get("text", "") + attr_dict = {} + for attr in clip.get("attributes", []): + vals = attr.get("values", []) + if vals: + attr_dict[attr.get("name", "")] = vals[0] + + if label == "Sub-goal": + self.subgoal_annotations.append( + {"start_ts": start_ts, "end_ts": end_ts, "text": text} + ) + elif label == "Collector Issue": + self.collector_issues.append( + {"start_ts": start_ts, "end_ts": end_ts, + "issue_type": attr_dict.get("Collector Quality Issue", "")} + ) + self.text_annotations.append( + {"label": label, "text": text, "start_ts": start_ts, + "end_ts": end_ts, "attributes": attr_dict} + ) + + def get_hand_keypoints_at_timestamp(self, timestamp: int) -> HandKeypoints: + result = HandKeypoints() + for hand_type in ("left", "right"): + if timestamp not in self.keypoint_paths[hand_type]: + continue + kp_dict = self.keypoint_paths[hand_type][timestamp] + if len(kp_dict) < NUM_KEYPOINTS // 2: + continue + keypoints = np.full((NUM_KEYPOINTS, 3), INVALID_VALUE, dtype=np.float32) + for kp_idx, xyz in kp_dict.items(): + keypoints[kp_idx] = xyz + if hand_type == "left": + result.left = keypoints + else: + result.right = keypoints + return result + + def get_subgoal_at_timestamp(self, timestamp: int) -> dict[str, Any] | None: + for item in self.subgoal_annotations: + if item["start_ts"] <= timestamp <= item["end_ts"]: + return item + return None + + def get_collector_issue_at_timestamp(self, timestamp: int) -> dict[str, Any] | None: + for item in self.collector_issues: + if item["start_ts"] <= timestamp <= item["end_ts"]: + return item + return None + + def get_text_annotations_at_timestamp(self, timestamp: int) -> list[dict[str, Any]]: + return [ + ann for ann in self.text_annotations + if ann["start_ts"] <= timestamp <= ann["end_ts"] + ] + + def extract_all_frames_metadata(self) -> list[FrameData]: + frames = [] + for i, ts in enumerate(self.timestamps): + pose = self.pose_values[i] + frames.append( + FrameData( + frame_index=i, + timestamp_us=ts, + camera_pose=CameraPose.from_pose_array(pose), + hand_keypoints=self.get_hand_keypoints_at_timestamp(ts), + text_annotations=self.get_text_annotations_at_timestamp(ts), + subgoal=self.get_subgoal_at_timestamp(ts), + collector_issue=self.get_collector_issue_at_timestamp(ts), + ) + ) + return frames + + def load_images_for_range(self, start_idx: int, end_idx: int) -> list[np.ndarray | None]: + cap = cv2.VideoCapture(self.video_path) + if not cap.isOpened(): + return [None] * (end_idx - start_idx) + cap.set(cv2.CAP_PROP_POS_FRAMES, start_idx) + images: list[np.ndarray | None] = [] + for _ in range(end_idx - start_idx): + ret, frame = cap.read() + if not ret: + images.append(None) + continue + images.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) + cap.release() + return images + + +# --------------------------------------------------------------------------- +# Palm pose computation (vectorised where possible) +# --------------------------------------------------------------------------- + +def _compute_palm_centroid(keypoints: np.ndarray) -> np.ndarray: + palm_kps = keypoints[PALM_INDICES] + valid_mask = ~np.any(palm_kps >= INVALID_VALUE - 1, axis=1) + if not np.any(valid_mask): + return np.full(3, INVALID_VALUE, dtype=np.float32) + return np.mean(palm_kps[valid_mask], axis=0).astype(np.float32) + + +def _compute_palm_orientation(keypoints: np.ndarray, mirror_y: bool = False) -> np.ndarray: + wrist, index1, middle1, pinky1 = keypoints[0], keypoints[5], keypoints[9], keypoints[17] + if any(np.any(kp >= INVALID_VALUE - 1) for kp in (wrist, index1, pinky1)): + return np.zeros(3, dtype=np.float32) + x_axis = middle1 - wrist + x_axis /= np.linalg.norm(x_axis) + 1e-8 + temp_y = pinky1 - wrist + z_axis = np.cross(x_axis, temp_y) + z_axis /= np.linalg.norm(z_axis) + 1e-8 + y_axis = np.cross(z_axis, x_axis) + y_axis /= np.linalg.norm(y_axis) + 1e-8 + if mirror_y: + y_axis = -y_axis + z_axis = np.cross(x_axis, y_axis) + z_axis /= np.linalg.norm(z_axis) + 1e-8 + rot = np.column_stack([x_axis, y_axis, z_axis]) + try: + return R.from_matrix(rot).as_euler("ZYX", degrees=False).astype(np.float32) + except Exception: + return np.zeros(3, dtype=np.float32) + + +def _compute_palm_6dof(keypoints: np.ndarray, mirror_y: bool = False) -> np.ndarray: + centroid = _compute_palm_centroid(keypoints) + if np.any(centroid >= INVALID_VALUE - 1): + return np.full(6, INVALID_VALUE, dtype=np.float32) + ypr = _compute_palm_orientation(keypoints, mirror_y=mirror_y) + return np.concatenate([centroid, ypr]).astype(np.float32) + + +def _compute_wrist_position(keypoints: np.ndarray) -> np.ndarray: + wrist = keypoints[0] + if np.any(wrist >= INVALID_VALUE - 1): + return np.full(3, INVALID_VALUE, dtype=np.float32) + return wrist.astype(np.float32) + + +def _compute_wrist_orientation(keypoints: np.ndarray, mirror_y: bool = False) -> np.ndarray: + wrist, index1, middle1, pinky1 = keypoints[0], keypoints[5], keypoints[9], keypoints[17] + if any(np.any(kp >= INVALID_VALUE - 1) for kp in (wrist, index1, pinky1)): + return np.zeros(3, dtype=np.float32) + + x_axis = middle1 - wrist + x_axis /= np.linalg.norm(x_axis) + 1e-8 + temp_y = pinky1 - wrist + z_axis = np.cross(x_axis, temp_y) + z_axis /= np.linalg.norm(z_axis) + 1e-8 + y_axis = np.cross(z_axis, x_axis) + y_axis /= np.linalg.norm(y_axis) + 1e-8 + if mirror_y: + y_axis = -y_axis + z_axis = np.cross(x_axis, y_axis) + z_axis /= np.linalg.norm(z_axis) + 1e-8 + rot = np.column_stack([x_axis, y_axis, z_axis]) + try: + return R.from_matrix(rot).as_euler("ZYX", degrees=False).astype(np.float32) + except Exception: + return np.zeros(3, dtype=np.float32) + + +def _compute_wrist_6dof(keypoints: np.ndarray, mirror_y: bool = False) -> np.ndarray: + wrist_xyz = _compute_wrist_position(keypoints) + if np.any(wrist_xyz >= INVALID_VALUE - 1): + return np.full(6, INVALID_VALUE, dtype=np.float32) + wrist_ypr = _compute_wrist_orientation(keypoints, mirror_y=mirror_y) + return np.concatenate([wrist_xyz, wrist_ypr]).astype(np.float32) + + +# --------------------------------------------------------------------------- +# Language annotations +# --------------------------------------------------------------------------- + +def _build_language_annotations(sub_frames: list[FrameData]) -> list[tuple[str, int, int]]: + rows: list[tuple[str, int, int]] = [] + current_text: str | None = None + start_idx: int | None = None + for idx, frame in enumerate(sub_frames): + label = frame.subgoal.get("text", "").strip() if frame.subgoal else "" + text = label if label else None + if text != current_text: + if current_text is not None and start_idx is not None: + rows.append((current_text, start_idx, idx - 1)) + current_text = text + start_idx = idx if text is not None else None + if current_text is not None and start_idx is not None: + rows.append((current_text, start_idx, len(sub_frames) - 1)) + return rows + + +def _task_description(frames: list[FrameData], demo_meta: dict[str, Any]) -> str: + candidate = str(demo_meta.get("Demonstration", "")).strip() + if candidate: + return candidate + skip = {"Inactive Time", "Collector Issue", "inactive time", "collector issue"} + for frame in frames: + for ann in frame.text_annotations: + text = str(ann.get("text", "")).strip() + label = str(ann.get("label", "")).strip() + if text and text not in skip and label not in skip: + return text + return "Unknown task" + + +# --------------------------------------------------------------------------- +# Core conversion +# --------------------------------------------------------------------------- + +def convert_task_to_zarr( + task_id: str, + output_dir: str, + download_dir: str, + robot_type: str = "scale_bimanual", + fps: int = 30, +) -> int: + """Convert one Scale task to one or more Zarr episodes. Returns count.""" + t_start = time.perf_counter() + + print(f"[{task_id}] Fetching task metadata...") + task_download_path = os.path.join(download_dir, task_id) + os.makedirs(task_download_path, exist_ok=True) + + response = get_simple_response_dict_egocentric(task_id) + if response is None: + raise ValueError(f"Task {task_id} not found or Scale API failed") + + print(f"[{task_id}] Downloading files...") + t_dl = time.perf_counter() + local_paths = download_from_simple_response_dict(task_download_path, response) + sfs_path = local_paths.get("sfs") + annotations_path = local_paths.get("annotations") + video_path = local_paths.get("left_rectified") or local_paths.get("left_rgb") + if not all([sfs_path, annotations_path, video_path]): + raise ValueError(f"Missing SFS/annotation/video files for task {task_id}") + + def _nonempty(p: str | None) -> bool: + return bool(p) and os.path.exists(p) and os.path.getsize(p) > 0 + + if not (_nonempty(sfs_path) and _nonempty(annotations_path)): + raise ValueError(f"Downloaded SFS/annotation files are empty for task {task_id}") + print(f"[{task_id}] Downloaded in {time.perf_counter() - t_dl:.1f}s") + + print(f"[{task_id}] Loading SFS metadata...") + try: + extractor = SFSDataExtractor(sfs_path, annotations_path, video_path) + except ValueError: + print(f"[{task_id}] Load failed — re-downloading SFS + annotations...") + for p in (sfs_path, annotations_path): + if p and os.path.exists(p): + os.remove(p) + local_paths = download_from_simple_response_dict(task_download_path, response) + sfs_path = local_paths.get("sfs") + annotations_path = local_paths.get("annotations") + video_path = local_paths.get("left_rectified") or local_paths.get("left_rgb") + extractor = SFSDataExtractor(sfs_path, annotations_path, video_path) + frames = extractor.extract_all_frames_metadata() + n_frames = len(frames) + if n_frames <= ACTION_WINDOW: + raise ValueError(f"Task {task_id} has too few frames ({n_frames})") + + task_desc = _task_description(frames, extractor.demonstration_metadata) + valid_frame_count = n_frames - ACTION_WINDOW + + # ------------------------------------------------------------------ + # Precompute all per-frame data into dense arrays (once) + # ------------------------------------------------------------------ + left_world = np.full((n_frames, 6), INVALID_VALUE, dtype=np.float32) + right_world = np.full((n_frames, 6), INVALID_VALUE, dtype=np.float32) + left_wrist = np.full((n_frames, 6), INVALID_VALUE, dtype=np.float32) + right_wrist = np.full((n_frames, 6), INVALID_VALUE, dtype=np.float32) + left_kps = np.full((n_frames, 63), INVALID_VALUE, dtype=np.float32) + right_kps = np.full((n_frames, 63), INVALID_VALUE, dtype=np.float32) + head_pose_world = np.zeros((n_frames, 6), dtype=np.float32) + + for i, frame in enumerate(frames): + if frame.hand_keypoints.left is not None: + left_world[i] = _compute_palm_6dof(frame.hand_keypoints.left) + left_wrist[i] = _compute_wrist_6dof(frame.hand_keypoints.left) + left_kps[i] = frame.hand_keypoints.left.flatten().astype(np.float32) + if frame.hand_keypoints.right is not None: + right_world[i] = _compute_palm_6dof(frame.hand_keypoints.right, mirror_y=True) + right_wrist[i] = _compute_wrist_6dof(frame.hand_keypoints.right, mirror_y=True) + right_kps[i] = frame.hand_keypoints.right.flatten().astype(np.float32) + head_pose_world[i, :3] = frame.camera_pose.position.astype(np.float32) + head_pose_world[i, 3:] = R.from_matrix(frame.camera_pose.rotation_matrix).as_euler( + "ZYX", degrees=False + ).astype(np.float32) + + # ------------------------------------------------------------------ + # Filter valid frame indices (same criteria as old script) + # ------------------------------------------------------------------ + valid_indices: list[int] = [] + for t in range(valid_frame_count): + if ( + frames[t].collector_issue is not None + and frames[t].collector_issue.get("issue_type") == "Inactive Time" + ): + continue + window = slice(t, t + ACTION_WINDOW) + n_invalid = ( + np.sum(np.any(left_world[window] >= INVALID_VALUE - 1, axis=1)) + + np.sum(np.any(right_world[window] >= INVALID_VALUE - 1, axis=1)) + ) + if n_invalid > ACTION_WINDOW: # >50% of 2*ACTION_WINDOW + continue + valid_indices.append(t) + + if not valid_indices: + raise ValueError(f"Task {task_id} has no valid frames after filtering") + + print(f"[{task_id}] {len(valid_indices)} valid frames out of {valid_frame_count}") + + # ------------------------------------------------------------------ + # Write sub-episodes + # ------------------------------------------------------------------ + folder = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H-%M-%S-%f") + task_output_dir = Path(output_dir) / folder + task_output_dir.mkdir(parents=True, exist_ok=True) + + written = 0 + for ep_start in range(0, len(valid_indices), SUB_EPISODE_LENGTH): + sub = valid_indices[ep_start : ep_start + SUB_EPISODE_LENGTH] + if len(sub) < 10: + continue + + min_frame = min(sub) + max_frame = max(sub) + image_batch = extractor.load_images_for_range(min_frame, max_frame+1) + + # First pass: figure out which frames have images + kept: list[int] = [] + for t in sub: + img = image_batch[t - min_frame] + if img is not None: + kept.append(t) + if len(kept) < 10: + continue + + T = len(kept) + + # ---- Per-frame current state (vectorised) ---- + kept_arr = np.array(kept) + left_curr_6 = left_world[kept_arr] # (T, 6) + right_curr_6 = right_world[kept_arr] + left_curr_6 = np.where(left_curr_6 >= INVALID_VALUE - 1, 0.0, left_curr_6).astype( + np.float32 + ) + right_curr_6 = np.where(right_curr_6 >= INVALID_VALUE - 1, 0.0, right_curr_6).astype( + np.float32 + ) + left_wrist_curr_6 = np.where( + left_wrist[kept_arr] >= INVALID_VALUE - 1, 0.0, left_wrist[kept_arr] + ).astype(np.float32) + right_wrist_curr_6 = np.where( + right_wrist[kept_arr] >= INVALID_VALUE - 1, 0.0, right_wrist[kept_arr] + ).astype(np.float32) + + # Head pose & keypoints + actions_head = head_pose_world[kept_arr] + left_keypoints = np.where( + left_kps[kept_arr] >= INVALID_VALUE - 1, 0.0, left_kps[kept_arr] + ).astype(np.float32) + right_keypoints = np.where( + right_kps[kept_arr] >= INVALID_VALUE - 1, 0.0, right_kps[kept_arr] + ).astype(np.float32) + + # ---- Build image array ---- + images = np.stack( + [cv2.resize(image_batch[t - min_frame], IMAGE_SIZE, interpolation=cv2.INTER_LINEAR) + for t in kept], + axis=0, + ).astype(np.uint8) + + # ---- Numeric data ---- + numeric_data = { + "left.obs_ee_pose": left_curr_6, + "right.obs_ee_pose": right_curr_6, + "left.obs_keypoints": left_keypoints, + "right.obs_keypoints": right_keypoints, + "left.obs_wrist_pose": left_wrist_curr_6, + "right.obs_wrist_pose": right_wrist_curr_6, + "obs_head_pose": actions_head, + } + image_data = { + "images.front_1": images, + } + + used_frames = [frames[t] for t in kept] + lang_ann = _build_language_annotations(used_frames) + + episode_path = task_output_dir / f"{task_id}_episode_{written:06d}.zarr" + ZarrWriter.create_and_write( + episode_path=episode_path, + numeric_data=numeric_data, + image_data=image_data, + embodiment=robot_type, + fps=fps, + task=task_desc, + annotations=lang_ann if lang_ann else None, + enable_sharding=False, + ) + written += 1 + print(f"[{task_id}] Wrote episode {written} ({T} frames) -> {episode_path.name}") + + # Clean download cache + if os.path.exists(task_download_path): + shutil.rmtree(task_download_path) + + elapsed = time.perf_counter() - t_start + print(f"[{task_id}] Done: {written} episode(s) in {elapsed:.1f}s -> {task_output_dir}") + return written + + +# --------------------------------------------------------------------------- +# CLI +# --------------------------------------------------------------------------- + +def main() -> int: + parser = argparse.ArgumentParser( + description="Convert Scale SFS tasks to EgoVerse Zarr episodes" + ) + parser.add_argument("--task-ids", nargs="+", required=True, help="Scale task IDs") + parser.add_argument("--output-dir", default="egoverse_zarr_dataset", help="Output root") + parser.add_argument("--download-dir", default="scale_data", help="Temp download cache") + parser.add_argument("--robot-type", default="scale_bimanual", help="Embodiment tag") + parser.add_argument("--fps", type=int, default=30) + args = parser.parse_args() + + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + Path(args.download_dir).mkdir(parents=True, exist_ok=True) + + total_episodes = 0 + failed: list[str] = [] + for idx, task_id in enumerate(args.task_ids, start=1): + print(f"\n[{idx}/{len(args.task_ids)}] {task_id}") + try: + n = convert_task_to_zarr( + task_id=task_id, + output_dir=args.output_dir, + download_dir=args.download_dir, + robot_type=args.robot_type, + fps=args.fps, + ) + total_episodes += n + except Exception as exc: + print(f"[{task_id}] ERROR: {exc}") + traceback.print_exc() + failed.append(task_id) + + print(f"\n{'=' * 60}") + print(f"Conversion complete: {len(args.task_ids)} tasks, " + f"{len(args.task_ids) - len(failed)} ok, {len(failed)} failed") + print(f"Episodes written: {total_episodes}") + if failed: + print(f"Failed: {failed}") + print(f"Output: {Path(args.output_dir).resolve()}") + print("=" * 60) + return 1 if failed else 0 + + +if __name__ == "__main__": + raise SystemExit(main())