Add files using upload-large-folder tool

scripts/common.py

@@ -0,0 +1,284 @@
+"""Shared helpers for the LAFAN1 → Lite retargeting pipeline.
+
+Conventions:
+- Quaternions are scalar-first WXYZ, unit-norm, ``w >= 0``. The only non-WXYZ
+  appearance is the LAFAN1 CSV row, converted exactly once in
+  :func:`load_lafan_csv`.
+- The Lite ``joint_pos`` column order is whatever MuJoCo emits from the MJCF
+  (:func:`lite_joint_names`); we never hardcode it.
+"""
+
+import re
+from pathlib import Path
+
+import mujoco
+import numpy as np
+
+# ── Constants ─────────────────────────────────────────────────────────────────
+
+FPS: int = 30
+LAFAN_REPO_ID: str = "lvhaidong/LAFAN1_Retargeting_Dataset"
+LITE_DATASET_REPO_ID: str = "Berkeley-Humanoids/Lite-Motion-Tracking-Dataset"
+LITE_TASK_NAME: str = "track_lafan1"
+
+# End-effector body names — Lite (matches the MJCF) and the G1 URDF after MuJoCo
+# import (the ``*_rubber_hand`` link is fixed-jointed and fuses into
+# ``*_wrist_yaw_link``, which is the last named body in each arm chain).
+LITE_FOOT_BODIES: tuple[str, str] = ("left_foot", "right_foot")
+LITE_HAND_BODIES: tuple[str, str] = ("left_hand", "right_hand")
+G1_FOOT_BODIES: tuple[str, str] = ("left_ankle_roll_link", "right_ankle_roll_link")
+G1_HAND_BODIES: tuple[str, str] = ("left_wrist_yaw_link", "right_wrist_yaw_link")
+
+LAFAN_G1_URDF_RELPATH: str = "robot_description/g1/g1_29dof_rev_1_0.urdf"
+
+# Authoritative LAFAN1 G1 CSV joint order. Every CSV row is
+# ``[base_x, base_y, base_z, base_qx, base_qy, base_qz, base_qw,
+#   *G1_LAFAN_JOINT_NAMES]`` at 30 FPS.
+G1_LAFAN_JOINT_NAMES: tuple[str, ...] = (
+    "left_hip_pitch_joint",
+    "left_hip_roll_joint",
+    "left_hip_yaw_joint",
+    "left_knee_joint",
+    "left_ankle_pitch_joint",
+    "left_ankle_roll_joint",
+    "right_hip_pitch_joint",
+    "right_hip_roll_joint",
+    "right_hip_yaw_joint",
+    "right_knee_joint",
+    "right_ankle_pitch_joint",
+    "right_ankle_roll_joint",
+    "waist_yaw_joint",
+    "waist_roll_joint",
+    "waist_pitch_joint",
+    "left_shoulder_pitch_joint",
+    "left_shoulder_roll_joint",
+    "left_shoulder_yaw_joint",
+    "left_elbow_joint",
+    "left_wrist_roll_joint",
+    "left_wrist_pitch_joint",
+    "left_wrist_yaw_joint",
+    "right_shoulder_pitch_joint",
+    "right_shoulder_roll_joint",
+    "right_shoulder_yaw_joint",
+    "right_elbow_joint",
+    "right_wrist_roll_joint",
+    "right_wrist_pitch_joint",
+    "right_wrist_yaw_joint",
+)
+
+# G1 joint → (Lite joint, sign, offset_rad). Step-1 retargeting applies
+# ``lite_q[t] = sign * g1_q[t] + offset`` per joint.
+#
+# Decisions baked into this table:
+#   - Legs: chain order and axes match; sign=+1, offset=0.
+#   - Waist: chain order DIFFERS (G1 yaw→roll→pitch vs Lite yaw→pitch→roll),
+#     but axes match by *name*, so we map by name and accept the small
+#     rotation-order approximation when multiple waist joints are non-zero.
+#   - Shoulders + elbows: chain order matches; offsets bring G1's arms-down
+#     rest pose to Lite's T-pose rest (±π/2 on shoulder_roll and elbow).
+#   - Wrists: chain order DIFFERS (G1 roll→pitch→yaw vs Lite yaw→roll→pitch)
+#     but the physical 3-DoF wrist is the same, so we map by *position in
+#     the chain* (G1 wrist_roll → Lite wrist_yaw, etc.). Sign of the first
+#     wrist DoF is -1 because the URDFs picked opposite positive directions.
+G1_TO_LITE: dict[str, tuple[str, int, float]] = {
+    # Legs (12)
+    "left_hip_pitch_joint":      ("left_hip_pitch",      +1, 0.0),
+    "left_hip_roll_joint":       ("left_hip_roll",       +1, 0.0),
+    "left_hip_yaw_joint":        ("left_hip_yaw",        +1, 0.0),
+    "left_knee_joint":           ("left_knee_pitch",     +1, 0.0),
+    "left_ankle_pitch_joint":    ("left_ankle_pitch",    +1, 0.0),
+    "left_ankle_roll_joint":     ("left_ankle_roll",     +1, 0.0),
+    "right_hip_pitch_joint":     ("right_hip_pitch",     +1, 0.0),
+    "right_hip_roll_joint":      ("right_hip_roll",      +1, 0.0),
+    "right_hip_yaw_joint":       ("right_hip_yaw",       +1, 0.0),
+    "right_knee_joint":          ("right_knee_pitch",    +1, 0.0),
+    "right_ankle_pitch_joint":   ("right_ankle_pitch",   +1, 0.0),
+    "right_ankle_roll_joint":    ("right_ankle_roll",    +1, 0.0),
+    # Waist (3)
+    "waist_yaw_joint":           ("waist_yaw",           +1, 0.0),
+    "waist_roll_joint":          ("waist_roll",          +1, 0.0),
+    "waist_pitch_joint":         ("waist_pitch",         +1, 0.0),
+    # Arms (14) — left
+    "left_shoulder_pitch_joint": ("left_shoulder_pitch", +1, 0.0),
+    "left_shoulder_roll_joint":  ("left_shoulder_roll",  +1, -1.5708),
+    "left_shoulder_yaw_joint":   ("left_shoulder_yaw",   +1, 0.0),
+    "left_elbow_joint":          ("left_elbow_pitch",    +1, -1.5708),
+    "left_wrist_roll_joint":     ("left_wrist_yaw",      -1, 0.0),
+    "left_wrist_pitch_joint":    ("left_wrist_roll",     +1, 0.0),
+    "left_wrist_yaw_joint":      ("left_wrist_pitch",    +1, 0.0),
+    # Arms (14) — right
+    "right_shoulder_pitch_joint":("right_shoulder_pitch",+1, 0.0),
+    "right_shoulder_roll_joint": ("right_shoulder_roll", +1, +1.5708),
+    "right_shoulder_yaw_joint":  ("right_shoulder_yaw",  +1, 0.0),
+    "right_elbow_joint":         ("right_elbow_pitch",   +1, -1.5708),
+    "right_wrist_roll_joint":    ("right_wrist_yaw",     -1, 0.0),
+    "right_wrist_pitch_joint":   ("right_wrist_roll",    +1, 0.0),
+    "right_wrist_yaw_joint":     ("right_wrist_pitch",   +1, 0.0),
+}
+
+
+# ── Model loaders ─────────────────────────────────────────────────────────────
+
+
+def load_lite_model() -> mujoco.MjModel:
+    """Load the Berkeley Lite humanoid MJCF via the Berkeley-Humanoids package."""
+    from robot_descriptions import load_asset
+
+    return mujoco.MjModel.from_xml_path(str(load_asset("robots/lite/mjcf/lite.xml")))
+
+
+def load_g1_model(lafan_root: Path) -> mujoco.MjModel:
+    """Load the Unitree G1 URDF bundled in the downloaded LAFAN1 dataset.
+
+    The URDF declares ``<compiler meshdir="meshes"/>`` and also references
+    meshes as ``meshes/foo.STL`` — MuJoCo would concatenate to
+    ``meshes/meshes/foo.STL``. We rewrite meshdir to ``"."`` and supply the
+    mesh bytes through the ``assets`` dict so nothing touches the filesystem
+    a second time.
+    """
+    urdf = Path(lafan_root) / LAFAN_G1_URDF_RELPATH
+    if not urdf.exists():
+        raise FileNotFoundError(
+            f"G1 URDF not found at {urdf}. Run scripts/download_lafan.py first."
+        )
+    text = re.sub(r'meshdir="[^"]*"', 'meshdir="."', urdf.read_text())
+    assets = {f"meshes/{p.name}": p.read_bytes() for p in (urdf.parent / "meshes").glob("*.STL")}
+    return mujoco.MjModel.from_xml_string(text, assets=assets)
+
+
+def joint_qpos_addr(model: mujoco.MjModel, joint_name: str) -> int:
+    """Index into ``data.qpos`` for a 1-DoF joint by name."""
+    jid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_JOINT, joint_name)
+    if jid < 0:
+        raise KeyError(f"Joint {joint_name!r} not found in model")
+    return int(model.jnt_qposadr[jid])
+
+
+def body_id(model: mujoco.MjModel, body_name: str) -> int:
+    """Body id for ``body_name``, raising if absent."""
+    bid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_BODY, body_name)
+    if bid < 0:
+        raise KeyError(f"Body {body_name!r} not found in model")
+    return int(bid)
+
+
+def lite_joint_names(model: mujoco.MjModel) -> tuple[str, ...]:
+    """All hinge joint names in the Lite model in MuJoCo's depth-first order.
+
+    Skips the free joint at index 0 if present. The result is the single
+    source of truth for the LeRobotDataset ``joint_pos`` column order.
+    """
+    names: list[str] = []
+    for jid in range(model.njnt):
+        if model.jnt_type[jid] == mujoco.mjtJoint.mjJNT_FREE:
+            continue
+        name = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_JOINT, jid)
+        if name is None:
+            raise RuntimeError(f"Lite joint id {jid} has no name")
+        names.append(name)
+    return tuple(names)
+
+
+# ── LAFAN1 CSV I/O ────────────────────────────────────────────────────────────
+
+
+def load_lafan_csv(path: Path) -> dict[str, np.ndarray]:
+    """Read one LAFAN1 G1 CSV into base pose + joint positions.
+
+    On-disk format: headerless, 30 FPS, ``[base_xyz(3), base_quat_xyzw(4),
+    joint_pos(29)]`` per row. Converts XYZW → WXYZ and flips quaternion sign
+    so ``w >= 0``.
+
+    Returns:
+        Dict with ``base_pos`` ``(T, 3)``, ``base_quat_wxyz`` ``(T, 4)``,
+        ``g1_joint_pos`` ``(T, 29)`` — all float32. Joint columns follow
+        :data:`G1_LAFAN_JOINT_NAMES`.
+    """
+    raw = np.loadtxt(path, delimiter=",", dtype=np.float32)
+    expected_cols = 7 + len(G1_LAFAN_JOINT_NAMES)
+    if raw.ndim != 2 or raw.shape[1] != expected_cols:
+        raise ValueError(
+            f"{path}: expected {expected_cols} columns, got shape {raw.shape}"
+        )
+    base_quat = np.empty((raw.shape[0], 4), dtype=np.float32)
+    base_quat[:, 0] = raw[:, 6]
+    base_quat[:, 1:4] = raw[:, 3:6]
+    base_quat /= np.linalg.norm(base_quat, axis=1, keepdims=True)
+    base_quat[base_quat[:, 0] < 0] *= -1.0
+    return {
+        "base_pos": raw[:, 0:3],
+        "base_quat_wxyz": base_quat,
+        "g1_joint_pos": raw[:, 7:],
+    }
+
+
+# ── Derivatives ───────────────────────────────────────────────────────────────
+
+
+def finite_diff(x: np.ndarray, fps: int) -> np.ndarray:
+    """Central finite difference along axis 0."""
+    return np.gradient(x, 1.0 / fps, axis=0).astype(x.dtype, copy=False)
+
+
+def angular_velocity_from_quat(q_wxyz: np.ndarray, fps: int) -> np.ndarray:
+    """World-frame angular velocity (rad/s) from a sequence of WXYZ quaternions.
+
+    Uses the central stencil ``omega = axis_angle(q[t+1] * q[t-1]^-1) / 2dt``;
+    endpoints are repeated to keep length T.
+    """
+    dt = 1.0 / fps
+    rel = _quat_mul(q_wxyz[2:], _quat_conj(q_wxyz[:-2]))
+    omega_mid = _axis_angle_from_quat(rel) / (2.0 * dt)
+    omega = np.empty((q_wxyz.shape[0], 3), dtype=q_wxyz.dtype)
+    omega[1:-1] = omega_mid
+    omega[0] = omega_mid[0]
+    omega[-1] = omega_mid[-1]
+    return omega
+
+
+def _quat_mul(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    aw, ax, ay, az = a[..., 0], a[..., 1], a[..., 2], a[..., 3]
+    bw, bx, by, bz = b[..., 0], b[..., 1], b[..., 2], b[..., 3]
+    out = np.empty_like(a)
+    out[..., 0] = aw * bw - ax * bx - ay * by - az * bz
+    out[..., 1] = aw * bx + ax * bw + ay * bz - az * by
+    out[..., 2] = aw * by - ax * bz + ay * bw + az * bx
+    out[..., 3] = aw * bz + ax * by - ay * bx + az * bw
+    return out
+
+
+def _quat_conj(q: np.ndarray) -> np.ndarray:
+    out = q.copy()
+    out[..., 1:] *= -1.0
+    return out
+
+
+def _axis_angle_from_quat(q: np.ndarray) -> np.ndarray:
+    """WXYZ quaternion → rotation vector ``axis * angle``, shape ``(..., 3)``."""
+    w = np.clip(q[..., 0], -1.0, 1.0)
+    xyz = q[..., 1:]
+    sin_half = np.linalg.norm(xyz, axis=-1)
+    angle = 2.0 * np.arctan2(sin_half, w)
+    safe = sin_half > 1e-8
+    axis = np.zeros_like(xyz)
+    axis[safe] = xyz[safe] / sin_half[safe, None]
+    return axis * angle[..., None]
+
+
+# ── LeRobotDataset feature schema ─────────────────────────────────────────────
+
+
+def dataset_features(joint_count: int) -> dict:
+    """LeRobotDataset feature schema for the retargeted Lite motion dataset.
+
+    Six flat fields, scalar-first WXYZ for the base orientation, no ``action``
+    (this is a kinematic reference).
+    """
+    return {
+        "base_pos": {"dtype": "float32", "shape": (3,), "names": ["x", "y", "z"]},
+        "base_quat": {"dtype": "float32", "shape": (4,), "names": ["w", "x", "y", "z"]},
+        "base_lin_vel": {"dtype": "float32", "shape": (3,), "names": ["vx", "vy", "vz"]},
+        "base_ang_vel": {"dtype": "float32", "shape": (3,), "names": ["wx", "wy", "wz"]},
+        "joint_pos": {"dtype": "float32", "shape": (joint_count,), "names": None},
+        "joint_vel": {"dtype": "float32", "shape": (joint_count,), "names": None},
+    }

scripts/download_lafan.py

@@ -0,0 +1,69 @@
+"""Download the LAFAN1 G1 subset from the Hugging Face Hub.
+
+Pulls only the G1 motion CSVs, the G1 URDF + meshes (needed by
+``visualize.py`` to render the source ghost), and dataset metadata.
+
+Usage:
+    uv run scripts/download_lafan.py
+    uv run scripts/download_lafan.py --clip 'walk.*subject1'
+    uv run scripts/download_lafan.py --force
+"""
+
+import re
+import sys
+from pathlib import Path
+
+import numpy as np
+import tyro
+from huggingface_hub import snapshot_download
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import G1_LAFAN_JOINT_NAMES, LAFAN_REPO_ID  # noqa: E402
+
+CACHE_ROOT: Path = Path(__file__).resolve().parent.parent / ".cache" / "lafan1_g1"
+ALLOW_PATTERNS: list[str] = [
+    "g1/*.csv",
+    "robot_description/g1/**",
+    "meta_data/**",
+    "README.md",
+    "LICENSE",
+]
+
+
+def main(clip: str | None = None, force: bool = False) -> None:
+    """Download the LAFAN1 G1 subset into ``.cache/lafan1_g1/``.
+
+    Args:
+        clip: Regex; if given, the smoke check only inspects matching CSVs.
+            The download itself always pulls every G1 CSV — restricting at
+            ``snapshot_download`` would defeat the cache for later runs.
+        force: Re-download even if files already exist.
+    """
+    CACHE_ROOT.mkdir(parents=True, exist_ok=True)
+    local_path = Path(snapshot_download(
+        repo_id=LAFAN_REPO_ID,
+        repo_type="dataset",
+        local_dir=str(CACHE_ROOT),
+        allow_patterns=ALLOW_PATTERNS,
+        force_download=force,
+    ))
+
+    csvs = sorted((local_path / "g1").glob("*.csv"))
+    if clip is not None:
+        csvs = [p for p in csvs if re.search(clip, p.stem)]
+    if not csvs:
+        raise SystemExit(f"No G1 CSVs found under {local_path / 'g1'} (clip={clip!r}).")
+
+    raw = np.loadtxt(csvs[0], delimiter=",", dtype=np.float32)
+    expected = 7 + len(G1_LAFAN_JOINT_NAMES)
+    if raw.ndim != 2 or raw.shape[1] != expected:
+        raise SystemExit(
+            f"Schema check failed on {csvs[0]}: expected {expected} cols, got {raw.shape}"
+        )
+    print(f"LAFAN1 G1 subset → {local_path}")
+    print(f"  csvs   : {len(csvs)}")
+    print(f"  sample : {csvs[0].name}  ({raw.shape[0]} frames @ 30 FPS, {raw.shape[1]} cols)")
+
+
+if __name__ == "__main__":
+    tyro.cli(main)

scripts/push_to_hub.py

@@ -0,0 +1,86 @@
+"""Push the local LeRobotDataset to the Hugging Face Hub.
+
+Authenticate first (``hf auth login`` or ``export HF_TOKEN=hf_...``).
+Uses :meth:`LeRobotDataset.push_to_hub` so the repo gets a LeRobot
+auto-generated dataset card and a version tag.
+
+Usage:
+    uv run scripts/push_to_hub.py
+    uv run scripts/push_to_hub.py --repo-id your-org/your-dataset --private
+    uv run scripts/push_to_hub.py --branch v0.1
+"""
+
+import sys
+from pathlib import Path
+
+import tyro
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import LITE_DATASET_REPO_ID  # noqa: E402
+
+REPO_ROOT: Path = Path(__file__).resolve().parent.parent
+TAGS: list[str] = [
+    "lerobot",
+    "humanoid",
+    "motion-capture",
+    "motion-tracking",
+    "berkeley-humanoids",
+    "lite",
+    "lafan1",
+]
+
+
+def main(
+    repo_id: str = LITE_DATASET_REPO_ID,
+    private: bool = False,
+    branch: str | None = None,
+) -> None:
+    """Upload the local dataset to the HF Hub.
+
+    Args:
+        repo_id: Target dataset repo id ``{user_or_org}/{name}``. Must be a
+            location your authenticated account can write to.
+        private: If True, create the repo as private.
+        branch: Optional branch to push to (created from main if missing).
+    """
+    from lerobot.datasets import LeRobotDataset
+
+    if not (REPO_ROOT / "meta").exists() or not (REPO_ROOT / "data").exists():
+        raise SystemExit(
+            f"Expected meta/ and data/ under {REPO_ROOT}. "
+            f"Run scripts/retarget.py first."
+        )
+
+    dataset = LeRobotDataset(repo_id=repo_id, root=REPO_ROOT)
+    print(
+        f"Uploading {dataset.meta.total_episodes} episodes "
+        f"({dataset.meta.total_frames} frames @ {dataset.meta.fps} FPS) "
+        f"→ https://huggingface.co/datasets/{repo_id}"
+    )
+    # The dataset root *is* the repo root, so the folder also contains the
+    # LAFAN1 download cache, venv, build artefacts, etc. ``allow_patterns``
+    # restricts the upload to dataset content + reproduction sources
+    # (scripts, pyproject, instructions). ``scripts/*.py`` is intentionally
+    # not ``scripts/**`` so we don't accidentally publish ``__pycache__/``.
+    # ``upload_large_folder`` chunks the parquet payload into retryable
+    # batches — robust against transient network drops on the ~218 shards.
+    dataset.push_to_hub(
+        tags=TAGS,
+        license="cc-by-nc-4.0",
+        private=private,
+        branch=branch,
+        push_videos=False,
+        allow_patterns=[
+            "meta/**",
+            "data/**",
+            "scripts/*.py",
+            "pyproject.toml",
+            "INSTRUCTIONS.md",
+        ],
+        upload_large_folder=True,
+    )
+    print(f"Done. View at https://huggingface.co/datasets/{repo_id}")
+
+
+if __name__ == "__main__":
+    tyro.cli(main)

scripts/retarget.py

@@ -0,0 +1,523 @@
+"""Retarget LAFAN1 G1 motions to the Berkeley Lite humanoid.
+
+Two-step pipeline per clip:
+
+* **Step 1** — direct joint copy ``lite_q = sign * g1_q + offset`` using the
+  static :data:`common.G1_TO_LITE` table. Adds a constant pelvis-z shift so
+  Lite's feet stand on the ground.
+* **Step 2** — per-frame ``mink`` IK that refines step 1 to match G1's
+  pelvis-local EE poses (feet + hands, position + orientation). The
+  per-DOF posture cost biases the solution toward step 1 so the refinement
+  is a *tweak*, not a rearrangement.
+
+Output is a HuggingFace LeRobotDataset written at the repository root.
+
+Usage:
+    uv run scripts/retarget.py
+    uv run scripts/retarget.py --clip 'walk1_subject1'
+    uv run scripts/retarget.py --validate-only
+    uv run scripts/retarget.py --workers 8        # parallel across clips
+    uv run scripts/retarget.py --workers -1       # use all CPU cores
+"""
+
+import os
+import re
+import shutil
+import sys
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+import mujoco
+import numpy as np
+import tyro
+from tqdm import tqdm
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import (  # noqa: E402
+    FPS,
+    G1_FOOT_BODIES,
+    G1_HAND_BODIES,
+    G1_LAFAN_JOINT_NAMES,
+    G1_TO_LITE,
+    LITE_DATASET_REPO_ID,
+    LITE_FOOT_BODIES,
+    LITE_HAND_BODIES,
+    LITE_TASK_NAME,
+    angular_velocity_from_quat,
+    body_id,
+    dataset_features,
+    finite_diff,
+    joint_qpos_addr,
+    lite_joint_names,
+    load_g1_model,
+    load_lafan_csv,
+    load_lite_model,
+)
+
+REPO_ROOT: Path = Path(__file__).resolve().parent.parent
+LAFAN_ROOT: Path = REPO_ROOT / ".cache" / "lafan1_g1"
+BUILD_ROOT: Path = REPO_ROOT / ".lerobot_build"
+# LeRobotDataset.create refuses an existing destination, so the writer drops
+# its meta/ + data/ tree into BUILD_ROOT and we move it up to REPO_ROOT on
+# finalize.
+
+# Validation frame stride for the EE-error summary.
+SAMPLE_STRIDE: int = 50
+
+
+# ── Step 1: direct copy with sign + offset ────────────────────────────────────
+
+
+def _build_remap_indices(
+    lite_model: mujoco.MjModel,
+    lite_joint_addrs: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Parallel arrays ``(lite_col, g1_col, sign, offset)`` over mapped joints."""
+    addr_to_col = {int(a): i for i, a in enumerate(lite_joint_addrs.tolist())}
+    lite_cols, g1_cols, signs, offsets = [], [], [], []
+    for g1_col, g1_name in enumerate(G1_LAFAN_JOINT_NAMES):
+        entry = G1_TO_LITE.get(g1_name)
+        if entry is None:
+            continue
+        lite_name, sign, offset = entry
+        lite_cols.append(addr_to_col[joint_qpos_addr(lite_model, lite_name)])
+        g1_cols.append(g1_col)
+        signs.append(float(sign))
+        offsets.append(float(offset))
+    return (
+        np.asarray(lite_cols, dtype=np.int32),
+        np.asarray(g1_cols, dtype=np.int32),
+        np.asarray(signs, dtype=np.float32),
+        np.asarray(offsets, dtype=np.float32),
+    )
+
+
+def _pelvis_z_offset(g1_model: mujoco.MjModel, lite_model: mujoco.MjModel) -> float:
+    """Difference in standing leg length between Lite and G1 (welded pelvis).
+
+    Both robots default with the pelvis at z=0 and feet hanging at negative z,
+    so ``-min(foot_z)`` is each robot's standing leg length; the difference
+    is the z-shift to apply to LAFAN1's base trajectory so Lite stays grounded.
+    """
+
+    def _leg_length(model: mujoco.MjModel, foot_names: tuple[str, str]) -> float:
+        data = mujoco.MjData(model)
+        mujoco.mj_kinematics(model, data)
+        return -min(float(data.xpos[body_id(model, n), 2]) for n in foot_names)
+
+    return _leg_length(lite_model, LITE_FOOT_BODIES) - _leg_length(g1_model, G1_FOOT_BODIES)
+
+
+def step1_direct_remap(
+    motion: dict[str, np.ndarray],
+    lite_joint_addrs: np.ndarray,
+    lite_model: mujoco.MjModel,
+    z_offset: float,
+) -> dict[str, np.ndarray]:
+    """Apply ``lite_q = sign * g1_q + offset`` to every mapped joint.
+
+    Returns ``base_pos`` (with the pelvis-z shift), ``base_quat`` (WXYZ,
+    unchanged from the source), and a ``(T, 74)`` ``joint_pos`` in Lite MJCF
+    order. Joints with no G1 source (neck, fingers, ankle_yaw) stay at 0.
+    """
+    lite_cols, g1_cols, signs, offsets = _build_remap_indices(lite_model, lite_joint_addrs)
+    frames = motion["base_pos"].shape[0]
+    joint_pos = np.zeros((frames, lite_joint_addrs.shape[0]), dtype=np.float32)
+    joint_pos[:, lite_cols] = signs * motion["g1_joint_pos"][:, g1_cols] + offsets
+
+    base_pos = motion["base_pos"].astype(np.float32, copy=True)
+    base_pos[:, 2] += z_offset
+    return {
+        "base_pos": base_pos,
+        "base_quat": motion["base_quat_wxyz"].astype(np.float32),
+        "joint_pos": joint_pos,
+    }
+
+
+# ── Step 2: per-frame IK refinement ────────────────────────────────────���──────
+
+_LIMB_TOKENS: tuple[str, ...] = ("hip", "knee", "ankle", "shoulder", "elbow", "wrist")
+_TRUNK_TOKENS: tuple[str, ...] = ("waist",)
+
+
+def _posture_cost_vector(lite_model: mujoco.MjModel) -> np.ndarray:
+    """Per-DOF posture cost — three tiers so step 2 only *tweaks* step 1.
+
+    The PostureTask pulls each joint toward step 1 with cost ``c``; the EE
+    FrameTasks pull joints away with cost 1.0 + 1.0 (position + orientation).
+    Costs:
+
+    * ``1e3`` — locked. Neck, fingers, and ankle_yaw have no G1 source, so
+      we keep them at step 1's zero.
+    * ``10.0`` — stiff but adjustable. Waist rotates the torso (and head),
+      so a high cost prevents the IK from twisting the whole upper body to
+      satisfy hand targets; arm joints are recruited first.
+    * ``1.0`` — same magnitude as the EE tasks. Arms + legs get a balanced
+      trade-off; per-frame corrections come out small.
+    """
+    cost = np.full(lite_model.nv, 1e3, dtype=np.float64)
+    for jid in range(lite_model.njnt):
+        name = mujoco.mj_id2name(lite_model, mujoco.mjtObj.mjOBJ_JOINT, jid)
+        if not name:
+            continue
+        dof = int(lite_model.jnt_dofadr[jid])
+        if any(tok in name for tok in _LIMB_TOKENS):
+            cost[dof] = 1.0
+        elif any(tok in name for tok in _TRUNK_TOKENS):
+            cost[dof] = 10.0
+    return cost
+
+
+def _rest_frame_conversions(
+    g1_model: mujoco.MjModel,
+    lite_model: mujoco.MjModel,
+) -> dict[str, np.ndarray]:
+    """Per-body constant ``R_conv`` such that ``R_target = R_g1_actual @ R_conv``.
+
+    Derivation: we want Lite's world-frame motion delta (relative to its
+    matched rest) to equal G1's world-frame motion delta (relative to G1
+    rest). Solving for the target orientation gives
+    ``R_target = R_g1_actual @ (R_g1_rest^-1 @ R_lite_matched_rest)``.
+    """
+    g1_data = mujoco.MjData(g1_model)
+    mujoco.mj_kinematics(g1_model, g1_data)
+    lite_data = mujoco.MjData(lite_model)
+    for _, (lite_name, _, offset) in G1_TO_LITE.items():
+        lite_data.qpos[joint_qpos_addr(lite_model, lite_name)] = offset
+    mujoco.mj_kinematics(lite_model, lite_data)
+
+    out: dict[str, np.ndarray] = {}
+    for lite_name, g1_name in zip(
+        (*LITE_FOOT_BODIES, *LITE_HAND_BODIES),
+        (*G1_FOOT_BODIES, *G1_HAND_BODIES),
+        strict=True,
+    ):
+        R_g1 = g1_data.xmat[body_id(g1_model, g1_name)].reshape(3, 3)
+        R_lite = lite_data.xmat[body_id(lite_model, lite_name)].reshape(3, 3)
+        out[lite_name] = R_g1.T @ R_lite
+    return out
+
+
+def step2_ik_refine(
+    motion: dict[str, np.ndarray],
+    step1_joint_pos: np.ndarray,
+    g1_model: mujoco.MjModel,
+    lite_model: mujoco.MjModel,
+    lite_joint_addrs: np.ndarray,
+    iters: int = 15,
+    show_progress: bool = True,
+) -> np.ndarray:
+    """Refine step-1 joint positions to match G1's pelvis-local EE poses.
+
+    Per-frame IK is independent — each frame seeds from step 1 and converges
+    on its own. ``show_progress`` controls the inner tqdm bar; worker
+    processes set it to False so their bars don't interleave in the terminal.
+    """
+    import mink
+
+    g1_data = mujoco.MjData(g1_model)
+    g1_addrs = np.asarray(
+        [joint_qpos_addr(g1_model, n) for n in G1_LAFAN_JOINT_NAMES], dtype=np.int32
+    )
+    R_conv = _rest_frame_conversions(g1_model, lite_model)
+
+    configuration = mink.Configuration(lite_model)
+    foot_tasks = [
+        mink.FrameTask(name, "body", position_cost=1.0, orientation_cost=1.0, lm_damping=1.0)
+        for name in LITE_FOOT_BODIES
+    ]
+    hand_tasks = [
+        mink.FrameTask(name, "body", position_cost=1.0, orientation_cost=1.0, lm_damping=1.0)
+        for name in LITE_HAND_BODIES
+    ]
+    posture_task = mink.PostureTask(lite_model, cost=_posture_cost_vector(lite_model))
+    all_tasks = [*foot_tasks, *hand_tasks, posture_task]
+    limits = [mink.ConfigurationLimit(lite_model)]
+
+    ee_pairs = tuple(zip(
+        (*LITE_FOOT_BODIES, *LITE_HAND_BODIES),
+        (*G1_FOOT_BODIES, *G1_HAND_BODIES),
+        strict=True,
+    ))
+    out = step1_joint_pos.copy()
+    seed_qpos = np.zeros(lite_model.nq, dtype=np.float64)
+    frames = step1_joint_pos.shape[0]
+    frame_iter = tqdm(range(frames), desc="    IK", leave=False, unit="frame") if show_progress else range(frames)
+
+    for t in frame_iter:
+        g1_data.qpos[g1_addrs] = motion["g1_joint_pos"][t]
+        mujoco.mj_kinematics(g1_model, g1_data)
+        for task, (lite_name, g1_name) in zip([*foot_tasks, *hand_tasks], ee_pairs, strict=True):
+            bid = body_id(g1_model, g1_name)
+            mat = np.eye(4)
+            mat[:3, :3] = g1_data.xmat[bid].reshape(3, 3) @ R_conv[lite_name]
+            mat[:3, 3] = g1_data.xpos[bid]
+            task.set_target(mink.SE3.from_matrix(mat))
+
+        seed_qpos[lite_joint_addrs] = step1_joint_pos[t]
+        configuration.q[:] = seed_qpos
+        posture_task.set_target(seed_qpos.copy())
+        for _ in range(iters):
+            vel = mink.solve_ik(
+                configuration, all_tasks, 1.0, solver="daqp", damping=1e-1, limits=limits,
+            )
+            configuration.integrate_inplace(vel, 1.0)
+        out[t] = configuration.q[lite_joint_addrs]
+
+    return out
+
+
+# ── Validation ────────────────────────────────────────────────────────────────
+
+
+def _rotation_angle_error(R_a: np.ndarray, R_b: np.ndarray) -> float:
+    cos_theta = np.clip((np.trace(R_a @ R_b.T) - 1.0) * 0.5, -1.0, 1.0)
+    return float(np.arccos(cos_theta))
+
+
+def validate_ee_tracking(
+    motion: dict[str, np.ndarray],
+    lite_joint_pos: np.ndarray,
+    g1_model: mujoco.MjModel,
+    lite_model: mujoco.MjModel,
+    lite_joint_addrs: np.ndarray,
+) -> None:
+    """Print per-EE position + rotation error vs. G1 at every SAMPLE_STRIDE frames.
+
+    Rotation error is measured as the angle of "motion delta from matched
+    rest" — each robot's EE rotation relative to its own matched rest.
+    Lite's matched rest is step 1 applied at G1 ``q = 0`` (arms at offsets).
+    """
+    g1_data = mujoco.MjData(g1_model)
+    lite_data = mujoco.MjData(lite_model)
+    g1_addrs = np.asarray(
+        [joint_qpos_addr(g1_model, n) for n in G1_LAFAN_JOINT_NAMES], dtype=np.int32
+    )
+
+    mujoco.mj_kinematics(g1_model, g1_data)
+    pairs = tuple(zip(
+        (*LITE_FOOT_BODIES, *LITE_HAND_BODIES),
+        (*G1_FOOT_BODIES, *G1_HAND_BODIES),
+        strict=True,
+    ))
+    rest_g1 = {g: g1_data.xmat[body_id(g1_model, g)].reshape(3, 3).copy() for _, g in pairs}
+
+    matched_rest = np.zeros(lite_model.nq, dtype=np.float64)
+    for _, (lite_name, _, offset) in G1_TO_LITE.items():
+        matched_rest[joint_qpos_addr(lite_model, lite_name)] = offset
+    lite_data.qpos[:] = matched_rest
+    mujoco.mj_kinematics(lite_model, lite_data)
+    rest_lite = {l: lite_data.xmat[body_id(lite_model, l)].reshape(3, 3).copy() for l, _ in pairs}
+
+    frames = lite_joint_pos.shape[0]
+    indices = list(range(0, frames, SAMPLE_STRIDE))
+    stats: dict[str, dict[str, list[float]]] = {l: {"pos": [], "rot": []} for l, _ in pairs}
+
+    for t in indices:
+        lite_data.qpos[lite_joint_addrs] = lite_joint_pos[t]
+        mujoco.mj_kinematics(lite_model, lite_data)
+        g1_data.qpos[g1_addrs] = motion["g1_joint_pos"][t]
+        mujoco.mj_kinematics(g1_model, g1_data)
+        for lname, gname in pairs:
+            lbid, gbid = body_id(lite_model, lname), body_id(g1_model, gname)
+            stats[lname]["pos"].append(float(np.linalg.norm(lite_data.xpos[lbid] - g1_data.xpos[gbid])))
+            R_l = lite_data.xmat[lbid].reshape(3, 3) @ rest_lite[lname].T
+            R_g = g1_data.xmat[gbid].reshape(3, 3) @ rest_g1[gname].T
+            stats[lname]["rot"].append(_rotation_angle_error(R_l, R_g))
+
+    print(f"\nEE tracking error across {len(indices)} frames (stride={SAMPLE_STRIDE}, total={frames}):")
+    print(f"  {'body':<14s} {'pos mean':>9s} {'pos max':>9s}   {'rot mean':>9s} {'rot max':>9s}")
+    for lname, _ in pairs:
+        pos = np.asarray(stats[lname]["pos"])
+        rot = np.asarray(stats[lname]["rot"])
+        print(
+            f"  {lname:<14s} {pos.mean():>8.3f}m {pos.max():>8.3f}m   "
+            f"{np.degrees(rot.mean()):>7.2f}° {np.degrees(rot.max()):>7.2f}°"
+        )
+
+
+# ── Per-clip pipeline + LeRobotDataset writer ─────────────────────────────────
+
+
+def _frame_records(
+    base_pos: np.ndarray,
+    base_quat: np.ndarray,
+    joint_pos: np.ndarray,
+) -> dict[str, np.ndarray]:
+    """Compose the six dataset-feature arrays from a per-clip trajectory."""
+    base_pos = base_pos.astype(np.float32, copy=False)
+    base_quat = base_quat.astype(np.float32, copy=False)
+    joint_pos = joint_pos.astype(np.float32, copy=False)
+    return {
+        "base_pos": base_pos,
+        "base_quat": base_quat,
+        "base_lin_vel": finite_diff(base_pos, FPS),
+        "base_ang_vel": angular_velocity_from_quat(base_quat, FPS).astype(np.float32),
+        "joint_pos": joint_pos,
+        "joint_vel": finite_diff(joint_pos, FPS),
+    }
+
+
+# ── Multiprocess worker (across-clip parallelism) ─────────────────────────────
+
+_WORKER_STATE: dict[str, object] = {}
+
+
+def _worker_init() -> None:
+    """ProcessPoolExecutor initializer: compile MuJoCo models once per worker."""
+    g1_model = load_g1_model(LAFAN_ROOT)
+    lite_model = load_lite_model()
+    addrs = np.asarray(
+        [joint_qpos_addr(lite_model, n) for n in lite_joint_names(lite_model)], dtype=np.int32
+    )
+    _WORKER_STATE.update(
+        g1_model=g1_model,
+        lite_model=lite_model,
+        lite_joint_addrs=addrs,
+        z_offset=_pelvis_z_offset(g1_model, lite_model),
+    )
+
+
+def _worker_retarget(args: tuple[str, bool, int]) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Retarget a single clip; returns ``(base_pos, base_quat, joint_pos)``."""
+    csv_path_str, do_ik, ik_iters = args
+    g1_model: mujoco.MjModel = _WORKER_STATE["g1_model"]  # type: ignore[assignment]
+    lite_model: mujoco.MjModel = _WORKER_STATE["lite_model"]  # type: ignore[assignment]
+    lite_joint_addrs: np.ndarray = _WORKER_STATE["lite_joint_addrs"]  # type: ignore[assignment]
+    z_offset: float = _WORKER_STATE["z_offset"]  # type: ignore[assignment]
+
+    motion = load_lafan_csv(Path(csv_path_str))
+    step1 = step1_direct_remap(motion, lite_joint_addrs, lite_model, z_offset)
+    joint_pos = step1["joint_pos"]
+    if do_ik:
+        joint_pos = step2_ik_refine(
+            motion, joint_pos, g1_model, lite_model, lite_joint_addrs,
+            iters=ik_iters, show_progress=False,
+        )
+    return step1["base_pos"], step1["base_quat"], joint_pos
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+
+def main(
+    repo_id: str = LITE_DATASET_REPO_ID,
+    clip: str | None = None,
+    ik: bool = True,
+    ik_iters: int = 15,
+    workers: int = 1,
+    validate_only: bool = False,
+) -> None:
+    """Retarget LAFAN1 G1 clips to Lite and write a LeRobotDataset.
+
+    Args:
+        repo_id: HF dataset repo id, recorded in dataset metadata.
+        clip: Optional regex to retarget only matching CSVs.
+        ik: If True, run step 2 IK to refine step 1. If False, output step 1 only.
+        ik_iters: Newton-step iterations per frame in step 2.
+        workers: Worker processes for across-clip parallelism. ``1`` (default)
+            keeps the sequential path with per-frame tqdm. ``-1`` uses every
+            CPU core. ``>1`` spawns a ``ProcessPoolExecutor`` and suppresses
+            inner tqdm bars to keep the terminal readable.
+        validate_only: Run on the first matching clip and stop without writing
+            the dataset. Prints the step-1 (and step-2 if ``ik=True``) EE error
+            table.
+    """
+    if workers == -1:
+        workers = os.cpu_count() or 1
+    # Each save_episode runs an HFDataset.map pass that prints its own bar
+    # — 218 of those interleave badly with our outer clip bar.
+    os.environ.setdefault("HF_DATASETS_DISABLE_PROGRESS_BARS", "1")
+
+    csvs = sorted((LAFAN_ROOT / "g1").glob("*.csv"))
+    if clip is not None:
+        csvs = [p for p in csvs if re.search(clip, p.stem)]
+    if not csvs:
+        raise SystemExit(
+            f"No CSVs to retarget under {LAFAN_ROOT / 'g1'} (clip={clip!r}). "
+            f"Run scripts/download_lafan.py first."
+        )
+
+    print("Loading models …")
+    g1_model = load_g1_model(LAFAN_ROOT)
+    lite_model = load_lite_model()
+    lite_jnames = lite_joint_names(lite_model)
+    lite_joint_addrs = np.asarray(
+        [joint_qpos_addr(lite_model, n) for n in lite_jnames], dtype=np.int32
+    )
+    z_offset = _pelvis_z_offset(g1_model, lite_model)
+    flipped = sum(1 for _, s, _ in G1_TO_LITE.values() if s < 0)
+    nonzero = sum(1 for _, _, off in G1_TO_LITE.values() if abs(off) > 1e-6)
+    print(f"  G1 nq={g1_model.nq}, Lite nq={lite_model.nq}, joints={len(lite_jnames)}")
+    print(
+        f"  {len(G1_TO_LITE)} joint pairs, {flipped} sign flips, "
+        f"{nonzero} nonzero offsets, pelvis z-offset={z_offset * 1000:.2f} mm"
+    )
+
+    if validate_only:
+        motion = load_lafan_csv(csvs[0])
+        step1 = step1_direct_remap(motion, lite_joint_addrs, lite_model, z_offset)
+        print(f"\nClip: {csvs[0].name} ({step1['joint_pos'].shape[0]} frames)")
+        print("\n=== Step 1 (direct copy with sign + offset) ===")
+        validate_ee_tracking(motion, step1["joint_pos"], g1_model, lite_model, lite_joint_addrs)
+        if ik:
+            step2 = step2_ik_refine(
+                motion, step1["joint_pos"], g1_model, lite_model, lite_joint_addrs,
+                iters=ik_iters,
+            )
+            print("\n=== Step 1 + Step 2 (per-frame IK refinement) ===")
+            validate_ee_tracking(motion, step2, g1_model, lite_model, lite_joint_addrs)
+        return
+
+    from lerobot.datasets import LeRobotDataset  # deferred: heavy import
+
+    if BUILD_ROOT.exists():
+        shutil.rmtree(BUILD_ROOT)
+    dataset = LeRobotDataset.create(
+        repo_id=repo_id,
+        fps=FPS,
+        features=dataset_features(joint_count=len(lite_jnames)),
+        root=BUILD_ROOT,
+        robot_type="lite",
+        use_videos=False,
+    )
+
+    def _write_clip(base_pos: np.ndarray, base_quat: np.ndarray, joint_pos: np.ndarray) -> None:
+        records = _frame_records(base_pos, base_quat, joint_pos)
+        for t in range(records["base_pos"].shape[0]):
+            dataset.add_frame({"task": LITE_TASK_NAME, **{k: v[t] for k, v in records.items()}})
+        dataset.save_episode()
+
+    if workers > 1:
+        args_list = [(str(p), bool(ik), int(ik_iters)) for p in csvs]
+        with ProcessPoolExecutor(max_workers=workers, initializer=_worker_init) as executor:
+            for base_pos, base_quat, joint_pos in tqdm(
+                executor.map(_worker_retarget, args_list, chunksize=1),
+                total=len(csvs), desc=f"Clips (workers={workers})", unit="clip",
+            ):
+                _write_clip(base_pos, base_quat, joint_pos)
+    else:
+        for csv_path in tqdm(csvs, desc="Clips", unit="clip"):
+            motion = load_lafan_csv(csv_path)
+            step1 = step1_direct_remap(motion, lite_joint_addrs, lite_model, z_offset)
+            joint_pos = step1["joint_pos"]
+            if ik:
+                joint_pos = step2_ik_refine(
+                    motion, joint_pos, g1_model, lite_model, lite_joint_addrs, iters=ik_iters,
+                )
+            _write_clip(step1["base_pos"], step1["base_quat"], joint_pos)
+
+    dataset.finalize()
+    for sub in ("meta", "data"):
+        src = BUILD_ROOT / sub
+        if src.exists():
+            dst = REPO_ROOT / sub
+            if dst.exists():
+                shutil.rmtree(dst)
+            shutil.move(str(src), str(dst))
+    shutil.rmtree(BUILD_ROOT, ignore_errors=True)
+    print(f"\nWrote dataset to {REPO_ROOT} ({len(csvs)} episodes)")
+
+
+if __name__ == "__main__":
+    tyro.cli(main)

scripts/visualize.py

@@ -0,0 +1,308 @@
+"""Viser-based viewer for the retargeted Lite motion dataset.
+
+Renders Lite (solid) alongside the source LAFAN1 G1 (alpha-blended ghost).
+Mesh data comes straight from MuJoCo — no yourdfpy / trimesh dependency.
+The GUI exposes an episode dropdown; switching episodes loads the new clip's
+motion arrays on demand.
+
+Usage:
+    uv run scripts/visualize.py
+    uv run scripts/visualize.py --episode-index 3 --port 8080
+    uv run scripts/visualize.py --no-ghost
+"""
+
+import sys
+import threading
+import time
+from pathlib import Path
+
+import mujoco
+import numpy as np
+import tyro
+import viser
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import (  # noqa: E402
+    FPS,
+    G1_LAFAN_JOINT_NAMES,
+    LITE_DATASET_REPO_ID,
+    joint_qpos_addr,
+    lite_joint_names,
+    load_g1_model,
+    load_lafan_csv,
+    load_lite_model,
+)
+
+REPO_ROOT: Path = Path(__file__).resolve().parent.parent
+LAFAN_ROOT: Path = REPO_ROOT / ".cache" / "lafan1_g1"
+
+
+# ── Rotation helpers ──────────────────────────────────────────────────────────
+
+
+def _rot_to_quat_wxyz(R: np.ndarray) -> np.ndarray:
+    """3x3 rotation matrix → WXYZ quaternion with ``w >= 0``."""
+    trace = R[0, 0] + R[1, 1] + R[2, 2]
+    if trace > 0.0:
+        s = np.sqrt(trace + 1.0) * 2.0
+        w = 0.25 * s
+        x = (R[2, 1] - R[1, 2]) / s
+        y = (R[0, 2] - R[2, 0]) / s
+        z = (R[1, 0] - R[0, 1]) / s
+    elif R[0, 0] > R[1, 1] and R[0, 0] > R[2, 2]:
+        s = np.sqrt(1.0 + R[0, 0] - R[1, 1] - R[2, 2]) * 2.0
+        w = (R[2, 1] - R[1, 2]) / s
+        x = 0.25 * s
+        y = (R[0, 1] + R[1, 0]) / s
+        z = (R[0, 2] + R[2, 0]) / s
+    elif R[1, 1] > R[2, 2]:
+        s = np.sqrt(1.0 + R[1, 1] - R[0, 0] - R[2, 2]) * 2.0
+        w = (R[0, 2] - R[2, 0]) / s
+        x = (R[0, 1] + R[1, 0]) / s
+        y = 0.25 * s
+        z = (R[1, 2] + R[2, 1]) / s
+    else:
+        s = np.sqrt(1.0 + R[2, 2] - R[0, 0] - R[1, 1]) * 2.0
+        w = (R[1, 0] - R[0, 1]) / s
+        x = (R[0, 2] + R[2, 0]) / s
+        y = (R[1, 2] + R[2, 1]) / s
+        z = 0.25 * s
+    q = np.array([w, x, y, z], dtype=np.float64)
+    if q[0] < 0:
+        q = -q
+    return q / np.linalg.norm(q)
+
+
+def _quat_wxyz_to_rot(q: np.ndarray) -> np.ndarray:
+    w, x, y, z = float(q[0]), float(q[1]), float(q[2]), float(q[3])
+    return np.array(
+        [
+            [1 - 2 * (y * y + z * z), 2 * (x * y - w * z),     2 * (x * z + w * y)],
+            [2 * (x * y + w * z),     1 - 2 * (x * x + z * z), 2 * (y * z - w * x)],
+            [2 * (x * z - w * y),     2 * (y * z + w * x),     1 - 2 * (x * x + y * y)],
+        ],
+        dtype=np.float64,
+    )
+
+
+# ── Robot rendering ───────────────────────────────────────────────────────────
+
+
+def _mesh_handles(
+    server: viser.ViserServer,
+    model: mujoco.MjModel,
+    prefix: str,
+    color: tuple[int, int, int],
+    opacity: float,
+) -> list[tuple[viser.MeshHandle, int]]:
+    """One viser mesh handle per ``mjGEOM_MESH`` geom in the model."""
+    handles: list[tuple[viser.MeshHandle, int]] = []
+    for gid in range(model.ngeom):
+        if model.geom_type[gid] != mujoco.mjtGeom.mjGEOM_MESH:
+            continue
+        mesh_id = int(model.geom_dataid[gid])
+        if mesh_id < 0:
+            continue
+        v0, vn = int(model.mesh_vertadr[mesh_id]), int(model.mesh_vertnum[mesh_id])
+        f0, fn = int(model.mesh_faceadr[mesh_id]), int(model.mesh_facenum[mesh_id])
+        handle = server.scene.add_mesh_simple(
+            name=f"{prefix}/g{gid}",
+            vertices=np.asarray(model.mesh_vert[v0 : v0 + vn], dtype=np.float32),
+            faces=np.asarray(model.mesh_face[f0 : f0 + fn], dtype=np.int32),
+            color=color,
+            opacity=opacity,
+        )
+        handles.append((handle, gid))
+    return handles
+
+
+def _update_pose(
+    handles: list[tuple[viser.MeshHandle, int]],
+    data: mujoco.MjData,
+    base_pos: np.ndarray,
+    base_R: np.ndarray,
+) -> None:
+    """Push current MuJoCo geom poses to viser.
+
+    Both Lite and G1 are welded to world in their shipped descriptions, so
+    ``data.geom_xpos`` / ``geom_xmat`` are pelvis-local; we compose with the
+    LAFAN1 base transform to recover world coordinates.
+    """
+    for handle, gid in handles:
+        handle.position = base_pos + base_R @ data.geom_xpos[gid]
+        handle.wxyz = _rot_to_quat_wxyz(base_R @ data.geom_xmat[gid].reshape(3, 3))
+
+
+# ── Dataset / CSV loading ─────────────────────────────────────────────────────
+
+
+def _load_episode_lite(repo_id: str, root: Path, episode_index: int) -> dict[str, np.ndarray]:
+    """Load one Lite LeRobotDataset episode as plain arrays."""
+    from lerobot.datasets import LeRobotDataset
+
+    dataset = LeRobotDataset(repo_id=repo_id, root=root, episodes=[episode_index])
+    rows = dataset.hf_dataset.with_format("numpy")[:]
+    return {
+        "base_pos": np.asarray(rows["base_pos"], dtype=np.float64),
+        "base_quat": np.asarray(rows["base_quat"], dtype=np.float64),
+        "joint_pos": np.asarray(rows["joint_pos"], dtype=np.float64),
+    }
+
+
+def _load_episode_g1(lafan_root: Path, episode_index: int) -> dict[str, np.ndarray]:
+    """Load the LAFAN1 G1 CSV paired with ``episode_index`` (sorted file order)."""
+    csvs = sorted((lafan_root / "g1").glob("*.csv"))
+    if not csvs:
+        raise SystemExit(f"No G1 CSVs under {lafan_root / 'g1'}. Run download_lafan.py.")
+    if episode_index >= len(csvs):
+        raise SystemExit(f"--episode-index {episode_index} out of range ({len(csvs)} clips).")
+    return load_lafan_csv(csvs[episode_index])
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+
+def main(
+    episode_index: int = 0,
+    repo_id: str = LITE_DATASET_REPO_ID,
+    port: int = 8080,
+    ghost: bool = True,
+) -> None:
+    """Play one retargeted clip alongside its LAFAN1 source.
+
+    Args:
+        episode_index: Initial episode to load (switch later from the GUI).
+        repo_id: Repo identifier of the local LeRobotDataset.
+        port: viser HTTP port.
+        ghost: Render the source G1 alpha-blended on top of the Lite robot.
+    """
+    print("Loading models …")
+    lite_model = load_lite_model()
+    lite_data = mujoco.MjData(lite_model)
+    lite_addrs = np.asarray(
+        [joint_qpos_addr(lite_model, n) for n in lite_joint_names(lite_model)], dtype=np.int32
+    )
+
+    g1_model: mujoco.MjModel | None = None
+    g1_data: mujoco.MjData | None = None
+    g1_addrs: np.ndarray | None = None
+    if ghost:
+        g1_model = load_g1_model(LAFAN_ROOT)
+        g1_data = mujoco.MjData(g1_model)
+        g1_addrs = np.asarray(
+            [joint_qpos_addr(g1_model, n) for n in G1_LAFAN_JOINT_NAMES], dtype=np.int32
+        )
+
+    csvs = sorted((LAFAN_ROOT / "g1").glob("*.csv"))
+    if not csvs:
+        raise SystemExit(f"No G1 CSVs under {LAFAN_ROOT / 'g1'}. Run download_lafan.py.")
+    if not (0 <= episode_index < len(csvs)):
+        raise SystemExit(f"--episode-index {episode_index} out of range ({len(csvs)} clips).")
+    idx_width = len(str(len(csvs) - 1))
+    episode_labels: list[str] = [f"{i:0{idx_width}d}: {p.stem}" for i, p in enumerate(csvs)]
+
+    # Mutable state shared between GUI callbacks and the playback thread; the
+    # lock guards the swap during episode reload.
+    state: dict[str, object] = {"lite": None, "g1": None, "frames": 0}
+    state_lock = threading.Lock()
+
+    def load_episode(idx: int) -> None:
+        print(f"Loading episode {episode_labels[idx]} …")
+        lite_motion = _load_episode_lite(repo_id, REPO_ROOT, idx)
+        g1_motion = _load_episode_g1(LAFAN_ROOT, idx) if ghost else None
+        frames = lite_motion["base_pos"].shape[0]
+        if g1_motion is not None:
+            frames = min(frames, g1_motion["base_pos"].shape[0])
+        with state_lock:
+            state["lite"] = lite_motion
+            state["g1"] = g1_motion
+            state["frames"] = frames
+
+    load_episode(episode_index)
+
+    server = viser.ViserServer(port=port)
+    server.scene.add_grid("/grid", width=4.0, height=4.0)
+    lite_handles = _mesh_handles(server, lite_model, "/lite", (200, 200, 210), opacity=1.0)
+    g1_handles: list[tuple[viser.MeshHandle, int]] = []
+    if ghost:
+        assert g1_model is not None
+        g1_handles = _mesh_handles(server, g1_model, "/g1", (100, 180, 255), opacity=0.35)
+
+    episode_dropdown = server.gui.add_dropdown(
+        "episode", options=tuple(episode_labels), initial_value=episode_labels[episode_index]
+    )
+    slider = server.gui.add_slider(
+        "frame", min=0, max=int(state["frames"]) - 1, step=1, initial_value=0
+    )
+    play_btn = server.gui.add_button("play / pause")
+    speed = server.gui.add_slider("speed", min=0.1, max=2.0, step=0.1, initial_value=1.0)
+    playing = threading.Event()
+
+    @play_btn.on_click
+    def _(_event):
+        playing.clear() if playing.is_set() else playing.set()
+
+    def render_frame(t: int) -> None:
+        with state_lock:
+            lite_motion = state["lite"]
+            g1_motion = state["g1"]
+        lite_data.qpos[lite_addrs] = lite_motion["joint_pos"][t]  # type: ignore[index]
+        mujoco.mj_kinematics(lite_model, lite_data)
+        _update_pose(
+            lite_handles, lite_data,
+            base_pos=lite_motion["base_pos"][t],          # type: ignore[index]
+            base_R=_quat_wxyz_to_rot(lite_motion["base_quat"][t]),  # type: ignore[index]
+        )
+        if g1_motion is None:
+            return
+        g1_data.qpos[g1_addrs] = g1_motion["g1_joint_pos"][t]  # type: ignore[index]
+        mujoco.mj_kinematics(g1_model, g1_data)
+        _update_pose(
+            g1_handles, g1_data,
+            base_pos=g1_motion["base_pos"][t],
+            base_R=_quat_wxyz_to_rot(g1_motion["base_quat_wxyz"][t]),
+        )
+
+    render_frame(0)
+
+    def play_loop() -> None:
+        while True:
+            if playing.is_set():
+                frames = int(state["frames"])
+                next_frame = (int(slider.value) + 1) % frames
+                slider.value = next_frame
+                render_frame(next_frame)
+                time.sleep(1.0 / (FPS * float(speed.value)))
+            else:
+                time.sleep(0.05)
+
+    threading.Thread(target=play_loop, daemon=True).start()
+
+    @slider.on_update
+    def _(_event):
+        t = int(slider.value)
+        if t < int(state["frames"]):
+            render_frame(t)
+
+    @episode_dropdown.on_update
+    def _(_event):
+        was_playing = playing.is_set()
+        playing.clear()
+        load_episode(int(episode_dropdown.value.split(":", 1)[0]))
+        slider.max = int(state["frames"]) - 1
+        slider.value = 0
+        render_frame(0)
+        if was_playing:
+            playing.set()
+
+    print(f"\nviser listening on http://localhost:{port}")
+    print("  ctrl-c to exit")
+    try:
+        while True:
+            time.sleep(1.0)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    tyro.cli(main)