Delete patch_lerobot_for_smolvla.py

patch_lerobot_for_smolvla.py

@@ -1,298 +0,0 @@
-"""Patch an existing LeRobot v3 dataset to be usable for SmolVLA.
-
-This script is intended for the common situation where a dataset was converted for ACT
-but is missing SmolVLA-required language fields and/or uses an incompatible definition
-for observation.state.
-
-What it does:
-- Creates a patched copy of the dataset (optionally symlinking videos to avoid duplication)
-- Sets observation.state to the previous target (scheme-2): state[t] = action[t-1] within each episode
-  (state[0] is set to action[0] as a boundary condition)
-- Adds SmolVLA language inputs:
-    - observation.language.tokens
-    - observation.language.attention_mask
-  computed from each episode's metadata.json "task" string using a Transformers tokenizer.
-- Updates meta/info.json features and meta/stats.json.
-- Updates meta/tasks.parquet (task strings live in the dataframe index) and meta/episodes parquet "tasks".
-
-Usage example:
-  python backend/scripts/patch_lerobot_for_smolvla.py \
-    --dataset-dir backend/datasets/pick_up_objects \
-    --raw-dir backend/data/pick_up_objects \
-    --output-dir backend/datasets/pick_up_objects_smolvla \
-    --vlm-model-name HuggingFaceTB/SmolVLM2-500M-Video-Instruct \
-    --tokenizer-max-length 48
-
-Notes:
-- This does NOT re-encode videos.
-- Requires "transformers" to be installed in the current environment.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import shutil
-from pathlib import Path
-
-import numpy as np
-import pandas as pd
-
-try:
-    from transformers import AutoTokenizer
-
-    _TRANSFORMERS_AVAILABLE = True
-except Exception:
-    _TRANSFORMERS_AVAILABLE = False
-
-try:
-    from lerobot.datasets.compute_stats import DEFAULT_QUANTILES, get_feature_stats
-
-    _LEROBOT_STATS_AVAILABLE = True
-except Exception:
-    _LEROBOT_STATS_AVAILABLE = False
-
-
-STATE_KEY = "observation.state"
-ACTION_KEY = "action"
-LANG_TOKENS_KEY = "observation.language.tokens"
-LANG_MASK_KEY = "observation.language.attention_mask"
-
-
-def _iter_episode_dirs(raw_dir: Path) -> list[Path]:
-    eps = [p for p in raw_dir.iterdir() if p.is_dir() and p.name.startswith("episode_")]
-    eps.sort(key=lambda p: int(p.name.split("_")[1]))
-    return eps
-
-
-def _collect_tasks_from_raw(raw_dir: Path) -> list[str]:
-    tasks: list[str] = []
-    for ep_dir in _iter_episode_dirs(raw_dir):
-        meta_path = ep_dir / "metadata.json"
-        if not meta_path.exists():
-            continue
-        meta = json.loads(meta_path.read_text())
-        task = meta.get("task")
-        if isinstance(task, str) and task.strip():
-            tasks.append(task.strip())
-    # preserve order but unique
-    seen = set()
-    uniq: list[str] = []
-    for t in tasks:
-        if t not in seen:
-            seen.add(t)
-            uniq.append(t)
-    return uniq
-
-
-def _normalize_task_text(task: str) -> str:
-    # Keep it minimal and stable: convert snake_case to words.
-    return task.replace("_", " ").strip()
-
-
-def _encode_tasks(tasks: list[str], vlm_model_name: str, tokenizer_max_length: int) -> dict[str, tuple[list[int], list[int]]]:
-    if not _TRANSFORMERS_AVAILABLE:
-        raise RuntimeError(
-            "transformers is required to generate language tokens. Install it with `pip install transformers`."
-        )
-
-    tokenizer = AutoTokenizer.from_pretrained(vlm_model_name, use_fast=True)
-    encoded: dict[str, tuple[list[int], list[int]]] = {}
-    for task in tasks:
-        text = _normalize_task_text(task)
-        out = tokenizer(
-            text,
-            padding="max_length",
-            truncation=True,
-            max_length=tokenizer_max_length,
-            return_attention_mask=True,
-            return_tensors=None,
-        )
-        input_ids = list(map(int, out["input_ids"]))
-        attn = list(map(int, out["attention_mask"]))
-        if len(input_ids) != tokenizer_max_length or len(attn) != tokenizer_max_length:
-            raise ValueError("Tokenizer output length mismatch; expected fixed max_length")
-        encoded[task] = (input_ids, attn)
-
-    return encoded
-
-
-def _compute_stats(states: np.ndarray, actions: np.ndarray, existing_stats: dict) -> dict:
-    # Recompute state/action stats; preserve image stats unchanged.
-    stats = dict(existing_stats) if isinstance(existing_stats, dict) else {}
-
-    if _LEROBOT_STATS_AVAILABLE:
-        state_stats = get_feature_stats(states, axis=0, keepdims=False, quantile_list=DEFAULT_QUANTILES)
-        action_stats = get_feature_stats(actions, axis=0, keepdims=False, quantile_list=DEFAULT_QUANTILES)
-        stats[STATE_KEY] = {k: v.tolist() for k, v in state_stats.items()}
-        stats[ACTION_KEY] = {k: v.tolist() for k, v in action_stats.items()}
-    else:
-        stats[STATE_KEY] = {
-            "min": states.min(axis=0).tolist(),
-            "max": states.max(axis=0).tolist(),
-            "mean": states.mean(axis=0).tolist(),
-            "std": states.std(axis=0).tolist(),
-        }
-        stats[ACTION_KEY] = {
-            "min": actions.min(axis=0).tolist(),
-            "max": actions.max(axis=0).tolist(),
-            "mean": actions.mean(axis=0).tolist(),
-            "std": actions.std(axis=0).tolist(),
-        }
-
-    return stats
-
-
-def patch_dataset(
-    dataset_dir: Path,
-    raw_dir: Path,
-    output_dir: Path,
-    vlm_model_name: str,
-    tokenizer_max_length: int,
-    symlink_videos: bool,
-) -> None:
-    if not dataset_dir.exists():
-        raise FileNotFoundError(f"dataset_dir not found: {dataset_dir}")
-    if not raw_dir.exists():
-        raise FileNotFoundError(f"raw_dir not found: {raw_dir}")
-
-    tasks = _collect_tasks_from_raw(raw_dir)
-    if not tasks:
-        raise ValueError(f"No tasks found in raw metadata under {raw_dir}")
-    if len(tasks) != 1:
-        # The existing converter currently writes a single task_index=0 for all frames.
-        # If you truly have multiple tasks, you should re-convert with a corrected mapping.
-        raise ValueError(
-            f"Found {len(tasks)} unique tasks in raw data ({tasks}), but this dataset appears single-task. "
-            "Re-run conversion with multi-task support if needed."
-        )
-
-    task = tasks[0]
-    encoded = _encode_tasks([task], vlm_model_name, tokenizer_max_length)
-    tok, mask = encoded[task]
-
-    if output_dir.exists():
-        shutil.rmtree(output_dir)
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Copy data/meta; reuse videos via symlink if requested.
-    shutil.copytree(dataset_dir / "data", output_dir / "data")
-    shutil.copytree(dataset_dir / "meta", output_dir / "meta")
-
-    src_videos = dataset_dir / "videos"
-    if src_videos.exists():
-        if symlink_videos:
-            (output_dir / "videos").symlink_to(src_videos, target_is_directory=True)
-        else:
-            shutil.copytree(src_videos, output_dir / "videos")
-
-    # Patch tasks.parquet (task string is the index).
-    tasks_df = pd.DataFrame({"task_index": [0]}, index=[task])
-    tasks_df.to_parquet(output_dir / "meta" / "tasks.parquet", index=True)
-
-    # Patch episodes parquet (update tasks list entry).
-    episodes_paths = sorted((output_dir / "meta" / "episodes").glob("chunk-*/*.parquet"))
-    if not episodes_paths:
-        raise FileNotFoundError("No episodes parquet found under meta/episodes")
-    for ep_path in episodes_paths:
-        edf = pd.read_parquet(ep_path)
-        if "tasks" in edf.columns:
-            edf["tasks"] = [[task] for _ in range(len(edf))]
-        if "task_index" in edf.columns:
-            edf["task_index"] = 0
-        edf.to_parquet(ep_path, index=False)
-
-    # Patch data parquet(s).
-    data_paths = sorted((output_dir / "data").glob("chunk-*/*.parquet"))
-    if not data_paths:
-        raise FileNotFoundError("No data parquet found under data/")
-
-    all_states = []
-    all_actions = []
-
-    for dp in data_paths:
-        df = pd.read_parquet(dp)
-        required = {STATE_KEY, ACTION_KEY, "episode_index", "frame_index", "task_index"}
-        missing = required - set(df.columns)
-        if missing:
-            raise ValueError(f"Missing required columns in {dp}: {sorted(missing)}")
-
-        df = df.sort_values(["episode_index", "frame_index"]).reset_index(drop=False)
-        # Shift state within each episode: state[t] = action[t-1]
-        action_arr = np.stack(df[ACTION_KEY].to_numpy())
-        ep_idx = df["episode_index"].to_numpy()
-
-        state_arr = np.empty_like(action_arr)
-        # process per episode
-        start = 0
-        while start < len(df):
-            curr_ep = ep_idx[start]
-            end = start
-            while end < len(df) and ep_idx[end] == curr_ep:
-                end += 1
-            a = action_arr[start:end]
-            s = np.vstack([a[0:1], a[:-1]])
-            state_arr[start:end] = s
-            start = end
-
-        # Add language columns (same for all rows; single-task)
-        df[STATE_KEY] = [row.tolist() for row in state_arr]
-        df[LANG_TOKENS_KEY] = [tok for _ in range(len(df))]
-        df[LANG_MASK_KEY] = [mask for _ in range(len(df))]
-
-        # Restore original row order (by the previous dataframe index).
-        df = df.sort_values("index").drop(columns=["index"]).reset_index(drop=True)
-
-        dp.parent.mkdir(parents=True, exist_ok=True)
-        df.to_parquet(dp, index=False)
-
-        all_states.append(state_arr)
-        all_actions.append(action_arr)
-
-    # Update info.json features.
-    info_path = output_dir / "meta" / "info.json"
-    info = json.loads(info_path.read_text())
-    features = info.get("features", {})
-    features[LANG_TOKENS_KEY] = {"dtype": "int64", "shape": [tokenizer_max_length], "names": None}
-    features[LANG_MASK_KEY] = {"dtype": "int64", "shape": [tokenizer_max_length], "names": None}
-    info["features"] = features
-    info["total_tasks"] = 1
-    info_path.write_text(json.dumps(info, indent=2))
-
-    # Update stats.json.
-    stats_path = output_dir / "meta" / "stats.json"
-    existing_stats = json.loads(stats_path.read_text()) if stats_path.exists() else {}
-
-    states = np.concatenate(all_states, axis=0)
-    actions = np.concatenate(all_actions, axis=0)
-    stats = _compute_stats(states, actions, existing_stats)
-    stats_path.write_text(json.dumps(stats, indent=2))
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Patch a LeRobot dataset for SmolVLA")
-    parser.add_argument("--dataset-dir", type=str, required=True)
-    parser.add_argument("--raw-dir", type=str, required=True)
-    parser.add_argument("--output-dir", type=str, required=True)
-    parser.add_argument(
-        "--vlm-model-name",
-        type=str,
-        default="HuggingFaceTB/SmolVLM2-500M-Video-Instruct",
-    )
-    parser.add_argument("--tokenizer-max-length", type=int, default=48)
-    parser.add_argument("--no-symlink-videos", action="store_true")
-
-    args = parser.parse_args()
-
-    patch_dataset(
-        dataset_dir=Path(args.dataset_dir),
-        raw_dir=Path(args.raw_dir),
-        output_dir=Path(args.output_dir),
-        vlm_model_name=args.vlm_model_name,
-        tokenizer_max_length=args.tokenizer_max_length,
-        symlink_videos=not args.no_symlink_videos,
-    )
-
-
-if __name__ == "__main__":
-    main()