| |
| """Training-oriented loader example for one package. |
| |
| The script locates the files most users need for model or robot training: |
| RGB/depth timelines, corrected EMG/IMU, semantic subtasks, contact-force tables, |
| and standard gold exports. It uses only the standard library by default. If |
| pandas + pyarrow are installed, it also previews parquet schemas/rows. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| from pathlib import Path |
| from typing import Iterable |
|
|
| try: |
| import pandas as pd |
| except Exception: |
| pd = None |
|
|
| CORE_PATHS = { |
| "rgb_timeline": "clean/timeline/rgb_frame_index.parquet", |
| "depth_timeline": "clean/timeline/depth_frame_index.parquet", |
| "frame_pairs": "clean/timeline/frame_pair_index.parquet", |
| "left_emg": "clean/sensors/left_emg_corrected.parquet", |
| "right_emg": "clean/sensors/right_emg_corrected.parquet", |
| "left_imu": "clean/sensors/left_imu_corrected.parquet", |
| "right_imu": "clean/sensors/right_imu_corrected.parquet", |
| "d455_imu": "clean/sensors/d455_imu.parquet", |
| "episode_manifest": "gold/episode_manifest.parquet", |
| "emg_features": "gold/emg_feat.parquet", |
| "labels": "gold/labels.parquet", |
| "robomimic": "gold/robomimic.hdf5", |
| "rlds_episodes": "gold/rlds/train/episodes.jsonl", |
| "contact_force_long": "analysis/contact_force_v2/tables/contact_force_v2_long.parquet", |
| "contact_force_wide": "analysis/contact_force_v2/tables/contact_force_v2_wide.parquet", |
| "semantic_segments": "analysis/semantic_subtasks/subtask_segments.jsonl", |
| "semantic_labels": "analysis/semantic_subtasks/semantic_labels.jsonl", |
| } |
|
|
|
|
| def read_viewer_index(dataset_root: Path) -> list[dict[str, str]]: |
| index_path = dataset_root / "viewer" / "train.csv" |
| with index_path.open("r", encoding="utf-8-sig", newline="") as f: |
| return list(csv.DictReader(f)) |
|
|
|
|
| def resolve_package(dataset_root: Path, package_id: str) -> tuple[Path, dict[str, str]]: |
| for row in read_viewer_index(dataset_root): |
| if row["package_id"] == package_id: |
| return dataset_root / row.get("package_path", f"packages/{package_id}"), row |
| raise KeyError(f"Package id not found in viewer/train.csv: {package_id}") |
|
|
|
|
| def file_size(path: Path) -> str: |
| if not path.exists(): |
| return "missing" |
| size = path.stat().st_size |
| for unit in ["B", "KB", "MB", "GB"]: |
| if size < 1024 or unit == "GB": |
| return f"{size:.1f} {unit}" if unit != "B" else f"{size} B" |
| size /= 1024 |
| return f"{size:.1f} GB" |
|
|
|
|
| def iter_jsonl(path: Path, limit: int) -> Iterable[dict[str, object]]: |
| with path.open("r", encoding="utf-8") as f: |
| for i, line in enumerate(f): |
| if i >= limit: |
| break |
| if line.strip(): |
| yield json.loads(line) |
|
|
|
|
| def preview_table(path: Path, max_rows: int) -> None: |
| print(f"\nPreview: {path}") |
| if not path.exists(): |
| print(" missing") |
| return |
| suffix = path.suffix.lower() |
| if suffix == ".jsonl": |
| rows = list(iter_jsonl(path, max_rows)) |
| print(f" jsonl rows shown: {len(rows)}") |
| if rows: |
| print(f" columns: {', '.join(rows[0].keys())}") |
| print(f" first row: {json.dumps(rows[0], ensure_ascii=False)[:800]}") |
| return |
| if suffix == ".csv": |
| with path.open("r", encoding="utf-8-sig", newline="") as f: |
| reader = csv.DictReader(f) |
| rows = [row for _, row in zip(range(max_rows), reader)] |
| print(f" csv rows shown: {len(rows)}") |
| if rows: |
| print(f" columns: {', '.join(rows[0].keys())}") |
| print(f" first row: {json.dumps(rows[0], ensure_ascii=False)[:800]}") |
| return |
| if suffix == ".parquet": |
| if pd is None: |
| print(" parquet preview skipped: install pandas and pyarrow to read parquet") |
| print(f" size: {file_size(path)}") |
| return |
| df = pd.read_parquet(path) |
| print(f" shape: {df.shape}") |
| print(f" columns: {', '.join(map(str, df.columns[:30]))}") |
| if len(df): |
| print(df.head(max_rows).to_string(index=False)) |
| return |
| print(f" binary or unsupported preview type; size: {file_size(path)}") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description="Load one package for training-oriented inspection.") |
| parser.add_argument("--dataset-root", default=".", help="Dataset repository root") |
| parser.add_argument("--package-id", default="hand-cream-application", help="Package id from viewer/train.csv") |
| parser.add_argument("--max-rows", type=int, default=3, help="Rows to preview for readable tables") |
| args = parser.parse_args() |
|
|
| dataset_root = Path(args.dataset_root).expanduser().resolve() |
| package_dir, row = resolve_package(dataset_root, args.package_id) |
|
|
| print(f"Dataset root: {dataset_root}") |
| print(f"Package: {args.package_id}") |
| print(f"Task: {row.get('task_name', '')}") |
| print(f"Description: {row.get('task_description', '')}") |
| print(f"Package dir: {package_dir}") |
| print() |
| print(f"{'name':24} {'status':>12} path") |
| print("-" * 92) |
| for name, rel in CORE_PATHS.items(): |
| path = package_dir / rel |
| print(f"{name:24} {file_size(path):>12} {rel}") |
|
|
| |
| for key in ["semantic_segments", "semantic_labels", "rlds_episodes", "contact_force_long", "rgb_timeline", "left_emg"]: |
| preview_table(package_dir / CORE_PATHS[key], args.max_rows) |
|
|
| print("\nSuggested training entry points:") |
| print(" 1. Use clean/timeline/rgb_frame_index.parquet as the RGB frame clock.") |
| print(" 2. Join corrected EMG/IMU by corrected timestamp or nearest RGB frame index.") |
| print(" 3. Read semantic_subtasks for action segments and clips.") |
| print(" 4. Read contact_force_v2 tables for per-finger contact and force labels.") |
| print(" 5. Use gold/rlds or gold/robomimic.hdf5 when your training stack supports them.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
|
|
|
|
