debug rtc

debug
log
2026-06-18 00:37:10 +00:00 · 2026-01-09 16:58:57 +01:00 · 2026-01-09 16:54:11 +01:00 · 2026-01-09 16:50:44 +01:00 · 2026-01-09 16:41:59 +01:00 · 2026-01-09 16:26:54 +01:00
33 changed files with 1112 additions and 1551 deletions
@@ -1,321 +0,0 @@
-#!/usr/bin/env python
-"""
-OpenArms Policy Evaluation with Relative Actions
-
-Two modes supported (based on training config):
-  Mode 1: Relative actions only (use_relative_state=False)
-    - Policy outputs relative action deltas
-    - State input is absolute
-  Mode 2: Relative actions + state (use_relative_state=True)
-    - Policy outputs relative action deltas  
-    - State input is also converted to relative
-
-Example usage:
-    python examples/openarms/evaluate_relative.py
-"""
-
-import time
-from pathlib import Path
-
-import torch
-
-from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.configs.train import TrainPipelineConfig
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
-from lerobot.datasets.utils import build_dataset_frame, combine_feature_dicts
-from lerobot.policies.factory import make_policy, make_pre_post_processors
-from lerobot.policies.utils import predict_action
-from lerobot.processor import make_default_processors
-from lerobot.processor.core import RobotAction
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.utils.constants import ACTION, OBS_STR
-from lerobot.utils.control_utils import init_keyboard_listener, precise_sleep
-from lerobot.utils.device_utils import get_safe_torch_device
-from lerobot.utils.relative_actions import (
-    convert_from_relative_actions_dict,
-    convert_state_to_relative,
-    PerTimestepNormalizer,
-)
-from lerobot.utils.utils import log_say
-from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
-
-
-# Configuration
-HF_MODEL_ID = "your-org/your-relative-policy"
-HF_EVAL_DATASET_ID = "your-org/your-eval-dataset"
-TASK_DESCRIPTION = "your task description"
-
-NUM_EPISODES = 1
-FPS = 30
-EPISODE_TIME_SEC = 300
-
-FOLLOWER_LEFT_PORT = "can0"
-FOLLOWER_RIGHT_PORT = "can1"
-
-CAMERA_CONFIG = {
-    "left_wrist": OpenCVCameraConfig(index_or_path="/dev/video5", width=640, height=480, fps=FPS),
-    "right_wrist": OpenCVCameraConfig(index_or_path="/dev/video1", width=640, height=480, fps=FPS),
-    "base": OpenCVCameraConfig(index_or_path="/dev/video3", width=640, height=480, fps=FPS),
-}
-
-
-def make_robot_action(action_values: dict, features: dict) -> RobotAction:
-    robot_action = {}
-    for key in features:
-        if key.startswith(ACTION + "."):
-            action_key = key.removeprefix(ACTION + ".")
-            if action_key in action_values:
-                robot_action[action_key] = action_values[action_key]
-    return robot_action
-
-
-def load_relative_config(model_path: Path | str) -> tuple[PerTimestepNormalizer | None, bool]:
-    """Load normalizer and relative_state setting from checkpoint."""
-    model_path = Path(model_path) if isinstance(model_path, str) else model_path
-    normalizer = None
-    use_relative_state = False
-    
-    # Try local path first
-    if model_path.exists():
-        stats_path = model_path / "relative_stats.pt"
-        if stats_path.exists():
-            normalizer = PerTimestepNormalizer.load(stats_path)
-            print(f"Loaded per-timestep stats from: {stats_path}")
-        
-        config_path = model_path / "train_config.json"
-        if config_path.exists():
-            cfg = TrainPipelineConfig.from_pretrained(model_path)
-            use_relative_state = getattr(cfg, "use_relative_state", False)
-    else:
-        # Try hub
-        try:
-            from huggingface_hub import hf_hub_download
-            stats_file = hf_hub_download(repo_id=str(model_path), filename="relative_stats.pt")
-            normalizer = PerTimestepNormalizer.load(stats_file)
-            print("Loaded per-timestep stats from hub")
-            
-            config_file = hf_hub_download(repo_id=str(model_path), filename="train_config.json")
-            cfg = TrainPipelineConfig.from_pretrained(Path(config_file).parent)
-            use_relative_state = getattr(cfg, "use_relative_state", False)
-        except Exception as e:
-            print(f"Warning: Could not load relative config: {e}")
-    
-    return normalizer, use_relative_state
-
-
-def inference_loop_relative(
-    robot,
-    policy,
-    preprocessor,
-    postprocessor,
-    dataset,
-    events,
-    fps: int,
-    control_time_s: float,
-    single_task: str,
-    display_data: bool = True,
-    state_key: str = "observation.state",
-    relative_normalizer: PerTimestepNormalizer | None = None,
-    use_relative_state: bool = False,
-):
-    """
-    Inference loop for relative action policies.
-    
-    If use_relative_state=True, also converts observation state to relative.
-    """
-    device = get_safe_torch_device(policy.config.device)
-    timestamp = 0
-    start_t = time.perf_counter()
-    
-    while timestamp < control_time_s:
-        loop_start = time.perf_counter()
-        
-        if events["exit_early"] or events["stop_recording"]:
-            break
-        
-        obs = robot.get_observation()
-        observation_frame = build_dataset_frame(dataset.features, obs, prefix=OBS_STR)
-        current_pos = {k: v for k, v in obs.items() if k.endswith(".pos")}
-        
-        # Convert state to relative if using full UMI mode
-        if use_relative_state and state_key in observation_frame:
-            state_tensor = observation_frame[state_key]
-            if isinstance(state_tensor, torch.Tensor):
-                observation_frame[state_key] = convert_state_to_relative(state_tensor)
-        
-        # Policy inference (outputs normalized relative actions)
-        action_values = predict_action(
-            observation=observation_frame,
-            policy=policy,
-            device=device,
-            preprocessor=preprocessor,
-            postprocessor=postprocessor,
-            use_amp=policy.config.use_amp,
-            task=single_task,
-            robot_type=robot.robot_type,
-        )
-        
-        # Unnormalize actions
-        if relative_normalizer is not None:
-            action_keys = [k for k in action_values.keys() if not k.startswith("task")]
-            action_tensor = torch.tensor([[action_values[k] for k in action_keys]])
-            action_tensor = action_tensor.unsqueeze(1)
-            action_unnorm = relative_normalizer.unnormalize(action_tensor)
-            for i, k in enumerate(action_keys):
-                action_values[k] = action_unnorm[0, 0, i].item()
-        
-        # Convert to absolute
-        relative_action = make_robot_action(action_values, dataset.features)
-        absolute_action = convert_from_relative_actions_dict(relative_action, current_pos)
-        
-        robot.send_action(absolute_action)
-        
-        if dataset is not None:
-            action_frame = build_dataset_frame(dataset.features, absolute_action, prefix=ACTION)
-            frame = {**observation_frame, **action_frame, "task": single_task}
-            dataset.add_frame(frame)
-        
-        if display_data:
-            log_rerun_data(observation=obs, action=absolute_action)
-        
-        dt = time.perf_counter() - loop_start
-        precise_sleep(1 / fps - dt)
-        timestamp = time.perf_counter() - start_t
-
-
-def main():
-    print("=" * 60)
-    print("  OpenArms Evaluation - Relative Actions")
-    print("=" * 60)
-    print(f"\nModel: {HF_MODEL_ID}")
-    print(f"Dataset: {HF_EVAL_DATASET_ID}")
-    print(f"Episodes: {NUM_EPISODES}, Duration: {EPISODE_TIME_SEC}s")
-    
-    # Load relative action config
-    relative_normalizer, use_relative_state = load_relative_config(HF_MODEL_ID)
-    mode = "actions + state" if use_relative_state else "actions only"
-    print(f"Mode: relative {mode}")
-    
-    # Setup robot
-    follower_config = OpenArmsFollowerConfig(
-        port_left=FOLLOWER_LEFT_PORT,
-        port_right=FOLLOWER_RIGHT_PORT,
-        can_interface="socketcan",
-        id="openarms_follower",
-        disable_torque_on_disconnect=True,
-        max_relative_target=10.0,
-        cameras=CAMERA_CONFIG,
-    )
-    
-    follower = OpenArmsFollower(follower_config)
-    follower.connect(calibrate=False)
-    
-    if not follower.is_connected:
-        raise RuntimeError("Robot failed to connect!")
-
-    teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()
-    action_features_hw = {k: v for k, v in follower.action_features.items() if k.endswith(".pos")}
-    
-    dataset_features = combine_feature_dicts(
-        aggregate_pipeline_dataset_features(
-            pipeline=teleop_action_processor,
-            initial_features=create_initial_features(action=action_features_hw),
-            use_videos=True,
-        ),
-        aggregate_pipeline_dataset_features(
-            pipeline=robot_observation_processor,
-            initial_features=create_initial_features(observation=follower.observation_features),
-            use_videos=True,
-        ),
-    )
-    
-    dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / HF_EVAL_DATASET_ID
-    if dataset_path.exists():
-        print(f"\nDataset exists at: {dataset_path}")
-        if input("Continue? (y/n): ").strip().lower() != 'y':
-            follower.disconnect()
-            return
-    
-    dataset = LeRobotDataset.create(
-        repo_id=HF_EVAL_DATASET_ID,
-        fps=FPS,
-        features=dataset_features,
-        robot_type=follower.name,
-        use_videos=True,
-        image_writer_processes=0,
-        image_writer_threads=12, 
-    )
-    
-    policy_config = PreTrainedConfig.from_pretrained(HF_MODEL_ID)
-    policy_config.pretrained_path = HF_MODEL_ID
-    policy = make_policy(policy_config, ds_meta=dataset.meta)
-    
-    preprocessor, postprocessor = make_pre_post_processors(
-        policy_cfg=policy.config,
-        pretrained_path=HF_MODEL_ID,
-        dataset_stats=dataset.meta.stats,
-        preprocessor_overrides={"device_processor": {"device": str(policy.config.device)}},
-    )
-
-    listener, events = init_keyboard_listener()
-    init_rerun(session_name="openarms_eval_relative")
-    episode_idx = 0
-    
-    print("\nControls: ESC=stop, →=next episode, ←=rerecord")
-    
-    try:
-        while episode_idx < NUM_EPISODES and not events["stop_recording"]:
-            log_say(f"Episode {episode_idx + 1} of {NUM_EPISODES}")
-            
-            inference_loop_relative(
-                robot=follower,
-                policy=policy,
-                preprocessor=preprocessor,
-                postprocessor=postprocessor,
-                dataset=dataset,
-                events=events,
-                fps=FPS,
-                control_time_s=EPISODE_TIME_SEC,
-                single_task=TASK_DESCRIPTION,
-                display_data=True,
-                relative_normalizer=relative_normalizer,
-                use_relative_state=use_relative_state,
-            )
-            
-            if events.get("rerecord_episode", False):
-                log_say("Re-recording")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
-            
-            if dataset.episode_buffer is not None and dataset.episode_buffer.get("size", 0) > 0:
-                print(f"Saving episode {episode_idx + 1}...")
-                dataset.save_episode()
-                episode_idx += 1
-            
-            events["exit_early"] = False
-            
-            if not events["stop_recording"] and episode_idx < NUM_EPISODES:
-                input("Press ENTER for next episode...")
-        
-        print(f"\nDone! {episode_idx} episodes recorded")
-        log_say("Complete", blocking=True)
-    
-    except KeyboardInterrupt:
-        print("\n\nInterrupted")
-    
-    finally:
-        follower.disconnect()
-        if listener is not None:
-            listener.stop()
-        dataset.finalize()
-        print("Uploading to Hub...")
-        dataset.push_to_hub(private=True)
-
-
-if __name__ == "__main__":
-    main()
@@ -167,6 +167,8 @@ class OpenArmsRTCEvalConfig(HubMixin):
    record_dataset: bool = True
    push_to_hub: bool = True

+    interpolation: bool = False
+
    use_torch_compile: bool = False
    torch_compile_backend: str = "inductor"
    torch_compile_mode: str = "default"
@@ -323,54 +325,99 @@ def actor_thread(
 ):
    """Thread function to execute actions on the robot."""
    try:
-        logger.info("[ACTOR] Starting actor thread")
-
-        action_count = 0
-        action_interval = 1.0 / cfg.fps
        action_keys = [k for k in robot.action_features.keys() if k.endswith(".pos")]

+        if cfg.interpolation:
+            interp_factor = 2
+            robot_interval = 1.0 / (cfg.fps * interp_factor)
+            logger.info(f"[ACTOR] Interpolation ON: policy={cfg.fps}Hz -> robot={cfg.fps * interp_factor}Hz (2x)")
+        else:
+            interp_factor = 1
+            robot_interval = 1.0 / cfg.fps
+            logger.info(f"[ACTOR] Interpolation OFF: policy={cfg.fps}Hz, robot={cfg.fps}Hz")
+
+        prev_action: Tensor | None = None
+        interpolated_actions: list[Tensor] = []
+        interp_idx = 0
+
+        robot_send_count = 0
+        policy_consume_count = 0
+        last_hz_print = time.perf_counter()
+        last_dataset_time = 0.0
+
        while not shutdown_event.is_set():
            if not episode_active.is_set():
+                prev_action = None
+                interpolated_actions = []
+                interp_idx = 0
+                robot_send_count = 0
+                policy_consume_count = 0
+                last_hz_print = time.perf_counter()
                time.sleep(0.01)
                continue

            start_time = time.perf_counter()
-            action = action_queue.get()

-            if action is not None:
-                action = action.cpu()
+            if interp_idx >= len(interpolated_actions):
+                new_action = action_queue.get()
+                if new_action is not None:
+                    current_action = new_action.cpu()
+                    policy_consume_count += 1
+
+                    if cfg.interpolation and prev_action is not None:
+                        mid = prev_action + 0.5 * (current_action - prev_action)
+                        interpolated_actions = [mid, current_action]
+                    else:
+                        interpolated_actions = [current_action]
+
+                    prev_action = current_action
+                    interp_idx = 0
+
+            if interp_idx < len(interpolated_actions):
+                action_to_send = interpolated_actions[interp_idx]
+                interp_idx += 1

                action_dict = {}
                for i, key in enumerate(action_keys):
-                    if i < len(action):
-                        action_dict[key] = action[i].item()
+                    if i < len(action_to_send):
+                        action_dict[key] = action_to_send[i].item()

                action_processed = robot_action_processor((action_dict, None))
                robot.send_action(action_processed)
+                robot_send_count += 1

                if cfg.record_dataset and dataset is not None:
-                    with dataset_lock:
-                        obs = robot.get_observation()
-                        obs_processed = robot_observation_processor(obs)
-                        action_for_dataset = teleop_action_processor((action_dict, None))
+                    now = time.perf_counter()
+                    if now - last_dataset_time >= (1.0 / cfg.fps):
+                        last_dataset_time = now
+                        with dataset_lock:
+                            obs = robot.get_observation()
+                            obs_processed = robot_observation_processor(obs)
+                            action_for_dataset = teleop_action_processor((action_dict, None))
+                            frame = {}
+                            for key, value in obs_processed.items():
+                                frame[f"observation.{key}"] = value
+                            for key, value in action_for_dataset.items():
+                                frame[f"action.{key}"] = value
+                            frame["task"] = cfg.task
+                            dataset.add_frame(frame)

-                        frame = {}
-                        for key, value in obs_processed.items():
-                            frame[f"observation.{key}"] = value
-                        for key, value in action_for_dataset.items():
-                            frame[f"action.{key}"] = value
-                        frame["task"] = cfg.task
-
-                        dataset.add_frame(frame)
-
-                action_count += 1
+            now = time.perf_counter()
+            if now - last_hz_print >= 5.0:
+                elapsed = now - last_hz_print
+                actual_robot_hz = robot_send_count / elapsed if elapsed > 0 else 0
+                actual_policy_hz = policy_consume_count / elapsed if elapsed > 0 else 0
+                logger.info(f"[ACTOR] Actual Hz - Robot: {actual_robot_hz:.1f}, Policy: {actual_policy_hz:.1f}")
+                robot_send_count = 0
+                policy_consume_count = 0
+                last_hz_print = now

            dt_s = time.perf_counter() - start_time
-            sleep_time = max(0, action_interval - dt_s - 0.001)
+            sleep_time = max(0, robot_interval - dt_s - 0.001)
            if sleep_time > 0:
                time.sleep(sleep_time)

-        logger.info(f"[ACTOR] Actor thread shutting down. Total actions executed: {action_count}")
+        logger.info("[ACTOR] Shutting down")
    except Exception as e:
        logger.error(f"[ACTOR] Fatal exception: {e}")
        logger.error(traceback.format_exc())
@@ -434,6 +481,9 @@ def main(cfg: OpenArmsRTCEvalConfig):
    print(f"RTC Enabled: {cfg.rtc.enabled}")
    print(f"RTC Execution Horizon: {cfg.rtc.execution_horizon}")
    print(f"RTC Max Guidance Weight: {cfg.rtc.max_guidance_weight}")
+    print(f"Policy Hz: {cfg.fps}")
+    print(f"Robot Hz: {cfg.fps * 2 if cfg.interpolation else cfg.fps}")
+    print(f"Interpolation: {cfg.interpolation}")
    print(f"Device: {cfg.device}")
    print("=" * 60)

@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Unify all tasks in a dataset to a single task (modifies in-place).
+
+This script:
+1. Loads a dataset
+2. Sets all task_index to 0 and task description to "fold"
+3. Updates tasks.parquet and task_index in data files (in-place, no copying)
+
+Usage:
+    python examples/openarms/unify_task.py --repo-id lerobot-data-collection/level1_rac1
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+
+import pandas as pd
+from tqdm import tqdm
+
+from lerobot.datasets.lerobot_dataset import LeRobotDatasetMetadata
+from lerobot.datasets.utils import (
+    DATA_DIR,
+    write_info,
+    write_tasks,
+)
+from lerobot.utils.constants import HF_LEROBOT_HOME
+
+
+# Single unified task
+UNIFIED_TASK = "fold"
+
+
+def unify_dataset_tasks(
+    repo_id: str,
+    root: Path | None = None,
+    push_to_hub: bool = False,
+) -> None:
+    """Unify all tasks in a dataset to a single task (modifies in-place).
+
+    Args:
+        repo_id: Dataset repository ID.
+        root: Optional root path for dataset.
+        push_to_hub: Whether to push the result to HuggingFace Hub.
+    """
+    input_root = root if root else HF_LEROBOT_HOME / repo_id
+    input_repo_id = repo_id
+
+    logging.info(f"Loading metadata from {repo_id}")
+
+    # Load source metadata
+    src_meta = LeRobotDatasetMetadata(repo_id, root=input_root)
+
+    logging.info(f"Source dataset: {src_meta.total_episodes} episodes, {src_meta.total_frames} frames")
+    logging.info(f"Original tasks: {len(src_meta.tasks)}")
+
+    # Modify in-place (input_root == output_root supported)
+    data_dir = input_root / DATA_DIR
+
+    # Process data files - set all task_index to 0
+    logging.info("Processing data files (in-place)...")
+    for parquet_file in tqdm(sorted(data_dir.rglob("*.parquet")), desc="Processing data"):
+        df = pd.read_parquet(parquet_file)
+        df["task_index"] = 0  # All tasks unified to index 0
+        df.to_parquet(parquet_file)
+
+    # Process episodes metadata - set all tasks to unified task
+    logging.info("Processing episodes metadata (in-place)...")
+    episodes_dir = input_root / "meta" / "episodes"
+    if episodes_dir.exists():
+        for parquet_file in tqdm(sorted(episodes_dir.rglob("*.parquet")), desc="Processing episodes"):
+            df = pd.read_parquet(parquet_file)
+            df["tasks"] = [[UNIFIED_TASK]] * len(df)  # All episodes get the unified task
+            df.to_parquet(parquet_file)
+    else:
+        logging.warning(f"No episodes directory found at {episodes_dir}, skipping")
+
+    # Update tasks.parquet with single task
+    logging.info(f"Creating single task: {UNIFIED_TASK}")
+    new_tasks = pd.DataFrame({"task_index": [0]}, index=[UNIFIED_TASK])
+    write_tasks(new_tasks, input_root)
+
+    # Update info.json
+    new_info = src_meta.info.copy()
+    new_info["total_tasks"] = 1
+    write_info(new_info, input_root)
+
+    logging.info(f"Dataset modified in-place at {input_root}")
+    logging.info(f"Task: {UNIFIED_TASK}")
+
+    if push_to_hub:
+        from lerobot.datasets.lerobot_dataset import LeRobotDataset
+
+        logging.info(f"Pushing {input_repo_id} to hub")
+        dataset = LeRobotDataset(input_repo_id, root=input_root)
+        dataset.push_to_hub(private=True)
+        logging.info("Push complete!")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Unify all tasks in a dataset to a single task 'fold' (modifies in-place)."
+    )
+
+    parser.add_argument(
+        "--repo-id",
+        type=str,
+        required=True,
+        help="Dataset repository ID",
+    )
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=None,
+        help="Optional root path (defaults to HF_LEROBOT_HOME/repo_id)",
+    )
+    parser.add_argument(
+        "--push-to-hub",
+        action="store_true",
+        help="Push result to HuggingFace Hub",
+    )
+
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+    unify_dataset_tasks(
+        repo_id=args.repo_id,
+        root=args.root,
+        push_to_hub=args.push_to_hub,
+    )
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,877 @@
+#!/usr/bin/env python
+"""
+RaC (Recovery and Correction) Data Collection for OpenArms Robot with RTC.
+
+This combines RaC data collection with Real-Time Chunking (RTC) for smooth policy execution.
+RTC enables large flow-matching policies (Pi0, Pi0.5, SmolVLA) to produce reactive motion
+despite high inference latency by asynchronously generating action chunks.
+
+The workflow:
+1. Policy runs autonomously with RTC (teleop is idle/free)
+2. Press SPACE to pause - teleop moves to match robot position
+3. Press 'c' to take control - teleop is free, human provides RECOVERY + CORRECTION
+4. Press → to end episode (save and continue to next)
+5. Reset, then do next rollout
+
+Usage:
+    python examples/rac/rac_data_collection_openarms_rtc.py \
+        --robot.port_right=can0 \
+        --robot.port_left=can1 \
+        --teleop.port_right=/dev/ttyUSB0 \
+        --teleop.port_left=/dev/ttyUSB1 \
+        --policy.path=outputs/train/my_policy/checkpoints/last/pretrained_model \
+        --dataset.repo_id=my_user/rac_openarms_dataset \
+        --dataset.single_task="Pick up the cube"
+"""
+
+import logging
+import math
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from pprint import pformat
+from threading import Event, Lock, Thread
+from typing import Any
+
+import torch
+from torch import Tensor
+
+from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig  # noqa: F401
+from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraConfig  # noqa: F401
+from lerobot.configs import parser
+from lerobot.configs.policies import PreTrainedConfig
+from lerobot.configs.types import RTCAttentionSchedule
+from lerobot.datasets.image_writer import safe_stop_image_writer
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
+from lerobot.datasets.utils import build_dataset_frame, combine_feature_dicts, hw_to_dataset_features
+from lerobot.datasets.video_utils import VideoEncodingManager
+from lerobot.policies.factory import get_policy_class, make_pre_post_processors
+from lerobot.policies.pretrained import PreTrainedPolicy
+from lerobot.policies.rtc.action_queue import ActionQueue
+from lerobot.policies.rtc.configuration_rtc import RTCConfig
+from lerobot.policies.rtc.latency_tracker import LatencyTracker
+from lerobot.policies.utils import make_robot_action
+from lerobot.processor import (
+    IdentityProcessorStep,
+    PolicyAction,
+    PolicyProcessorPipeline,
+    RobotAction,
+    RobotObservation,
+    RobotProcessorPipeline,
+)
+from lerobot.processor.converters import (
+    observation_to_transition,
+    robot_action_observation_to_transition,
+    transition_to_observation,
+    transition_to_robot_action,
+)
+from lerobot.processor.rename_processor import rename_stats
+from lerobot.robots import Robot, RobotConfig, make_robot_from_config
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig  # noqa: F401
+from lerobot.teleoperators import Teleoperator, TeleoperatorConfig, make_teleoperator_from_config
+from lerobot.teleoperators.openarms_mini.config_openarms_mini import OpenArmsMiniConfig  # noqa: F401
+from lerobot.utils.constants import ACTION, OBS_STR
+from lerobot.utils.control_utils import is_headless, predict_action
+from lerobot.utils.robot_utils import precise_sleep
+from lerobot.utils.utils import get_safe_torch_device, init_logging, log_say
+from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Configuration
+# ============================================================================
+
+@dataclass
+class RaCRTCDatasetConfig:
+    repo_id: str = "lerobot/rac_openarms_rtc"
+    single_task: str = "default task"
+    root: str | Path | None = None
+    fps: int = 30
+    episode_time_s: float = 500
+    reset_time_s: float = 30
+    num_episodes: int = 50
+    video: bool = True
+    push_to_hub: bool = True
+    private: bool = False
+    tags: list[str] | None = None
+    num_image_writer_processes: int = 0
+    num_image_writer_threads_per_camera: int = 4
+    video_encoding_batch_size: int = 1
+    rename_map: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class RaCRTCConfig:
+    robot: RobotConfig = field(default_factory=lambda: OpenArmsFollowerConfig(
+        port_left="can0",
+        port_right="can1",
+    ))
+    teleop: TeleoperatorConfig = field(default_factory=lambda: OpenArmsMiniConfig(
+        port_left="/dev/ttyUSB1",
+        port_right="/dev/ttyUSB0",
+    ))
+    dataset: RaCRTCDatasetConfig = field(default_factory=RaCRTCDatasetConfig)
+    policy: PreTrainedConfig | None = None
+    
+    rtc: RTCConfig = field(default_factory=lambda: RTCConfig(
+        enabled=True, 
+        execution_horizon=20,
+        max_guidance_weight=5.0,
+        prefix_attention_schedule=RTCAttentionSchedule.LINEAR,
+    ))
+    
+    interpolation: bool = True
+    display_data: bool = True
+    play_sounds: bool = True
+    resume: bool = False
+    device: str = "cuda"
+    action_queue_size_to_get_new_actions: int = 30
+
+    def __post_init__(self):
+        policy_path = parser.get_path_arg("policy")
+        if policy_path:
+            cli_overrides = parser.get_cli_overrides("policy")
+            self.policy = PreTrainedConfig.from_pretrained(policy_path, cli_overrides=cli_overrides)
+            self.policy.pretrained_path = policy_path
+        if self.policy is None:
+            raise ValueError("policy.path is required")
+
+    @classmethod
+    def __get_path_fields__(cls) -> list[str]:
+        return ["policy"]
+
+
+# ============================================================================
+# Thread-Safe Robot Wrapper (from evaluate_with_rtc.py)
+# ============================================================================
+
+class RobotWrapper:
+    """Thread-safe wrapper for robot operations."""
+
+    def __init__(self, robot: Robot):
+        self.robot = robot
+        self.lock = Lock()
+
+    def get_observation(self) -> dict[str, Tensor]:
+        with self.lock:
+            return self.robot.get_observation()
+
+    def send_action(self, action: dict) -> None:
+        with self.lock:
+            self.robot.send_action(action)
+
+    @property
+    def observation_features(self) -> dict:
+        return self.robot.observation_features
+
+    @property
+    def action_features(self) -> dict:
+        return self.robot.action_features
+
+    @property
+    def name(self) -> str:
+        return self.robot.name
+    
+    @property
+    def robot_type(self) -> str:
+        return self.robot.robot_type
+
+
+# ============================================================================
+# Keyboard/Pedal Listeners
+# ============================================================================
+
+def init_rac_keyboard_listener():
+    """Initialize keyboard listener with RaC-specific controls."""
+    events = {
+        "exit_early": False,
+        "rerecord_episode": False,
+        "stop_recording": False,
+        "policy_paused": False,
+        "correction_active": False,
+        "in_reset": False,
+        "start_next_episode": False,
+    }
+
+    if is_headless():
+        logging.warning("Headless environment - keyboard controls unavailable")
+        return None, events
+
+    from pynput import keyboard
+
+    def on_press(key):
+        try:
+            if events["in_reset"]:
+                if key == keyboard.Key.space or key == keyboard.Key.right:
+                    print("\n[RaC] Starting next episode...")
+                    events["start_next_episode"] = True
+                elif hasattr(key, 'char') and key.char == 'c':
+                    print("\n[RaC] Starting next episode...")
+                    events["start_next_episode"] = True
+                elif key == keyboard.Key.esc:
+                    print("[RaC] ESC - Stop recording, pushing to hub...")
+                    events["stop_recording"] = True
+                    events["start_next_episode"] = True
+            else:
+                if key == keyboard.Key.space:
+                    if not events["policy_paused"] and not events["correction_active"]:
+                        print("\n[RaC] ⏸ PAUSED - Policy stopped, teleop moving to robot position")
+                        print("      Press 'c' or START to take control")
+                        events["policy_paused"] = True
+                elif hasattr(key, 'char') and key.char == 'c':
+                    if events["policy_paused"] and not events["correction_active"]:
+                        print("\n[RaC] ▶ START pressed - taking control")
+                        events["start_next_episode"] = True
+                elif key == keyboard.Key.right:
+                    print("[RaC] → End episode")
+                    events["exit_early"] = True
+                elif key == keyboard.Key.left:
+                    print("[RaC] ← Re-record episode")
+                    events["rerecord_episode"] = True
+                    events["exit_early"] = True
+                elif key == keyboard.Key.esc:
+                    print("[RaC] ESC - Stop recording, pushing to hub...")
+                    events["stop_recording"] = True
+                    events["exit_early"] = True
+        except Exception as e:
+            print(f"Key error: {e}")
+
+    listener = keyboard.Listener(on_press=on_press)
+    listener.start()
+    
+    start_pedal_listener(events)
+    
+    return listener, events
+
+
+def start_pedal_listener(events: dict):
+    """Start foot pedal listener thread if evdev is available."""
+    import threading
+    
+    try:
+        from evdev import InputDevice, ecodes  # noqa: F401
+    except ImportError:
+        logging.info("[Pedal] evdev not installed - pedal support disabled")
+        return
+    
+    PEDAL_DEVICE = "/dev/input/by-id/usb-PCsensor_FootSwitch-event-kbd"
+    KEY_LEFT = "KEY_A"
+    KEY_RIGHT = "KEY_C"
+    
+    def pedal_reader():
+        try:
+            dev = InputDevice(PEDAL_DEVICE)
+            print(f"[Pedal] Connected: {dev.name}")
+            
+            for ev in dev.read_loop():
+                if ev.type != ecodes.EV_KEY:
+                    continue
+                
+                from evdev import categorize  # noqa: F401
+                key = categorize(ev)
+                code = key.keycode
+                if isinstance(code, (list, tuple)):
+                    code = code[0]
+                
+                if key.keystate != 1:
+                    continue
+                
+                if events["in_reset"]:
+                    if code in [KEY_LEFT, KEY_RIGHT]:
+                        events["start_next_episode"] = True
+                else:
+                    if code == KEY_RIGHT:
+                        if events["correction_active"]:
+                            events["exit_early"] = True
+                        elif not events["policy_paused"]:
+                            events["policy_paused"] = True
+                    elif code == KEY_LEFT:
+                        if events["policy_paused"] and not events["correction_active"]:
+                            events["start_next_episode"] = True
+                        
+        except FileNotFoundError:
+            logging.info(f"[Pedal] Device not found: {PEDAL_DEVICE}")
+        except PermissionError:
+            logging.warning(f"[Pedal] Permission denied for {PEDAL_DEVICE}")
+        except Exception as e:
+            logging.debug(f"[Pedal] Error: {e}")
+    
+    thread = threading.Thread(target=pedal_reader, daemon=True)
+    thread.start()
+
+
+def make_identity_processors():
+    """Create identity processors for RaC recording."""
+    teleop_proc = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
+        steps=[IdentityProcessorStep()],
+        to_transition=robot_action_observation_to_transition,
+        to_output=transition_to_robot_action,
+    )
+    robot_proc = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
+        steps=[IdentityProcessorStep()],
+        to_transition=robot_action_observation_to_transition,
+        to_output=transition_to_robot_action,
+    )
+    obs_proc = RobotProcessorPipeline[RobotObservation, RobotObservation](
+        steps=[IdentityProcessorStep()],
+        to_transition=observation_to_transition,
+        to_output=transition_to_observation,
+    )
+    return teleop_proc, robot_proc, obs_proc
+
+
+# ============================================================================
+# RTC Inference Thread (from evaluate_with_rtc.py)
+# ============================================================================
+
+def rtc_inference_thread(
+    policy,
+    obs_holder: dict,
+    hw_features: dict,
+    preprocessor,
+    postprocessor,
+    queue_holder: dict,
+    shutdown_event: Event,
+    policy_active: Event,
+    cfg: RaCRTCConfig,
+):
+    """Background thread that generates action chunks using RTC."""
+    try:
+        logger.info("[RTC] ========== INFERENCE THREAD STARTED ==========")
+        logger.info(f"[RTC] policy={policy.name}, hw_features has {len(hw_features)} keys")
+        
+        latency_tracker = LatencyTracker()
+        time_per_chunk = 1.0 / cfg.dataset.fps
+        policy_device = policy.config.device
+        
+        get_actions_threshold = cfg.action_queue_size_to_get_new_actions
+        if not cfg.rtc.enabled:
+            get_actions_threshold = 0
+        
+        inference_count = 0
+        wait_logged = False
+        
+        while not shutdown_event.is_set():
+            if not policy_active.is_set():
+                if not wait_logged:
+                    logger.info("[RTC] Waiting for policy_active...")
+                    wait_logged = True
+                time.sleep(0.01)
+                continue
+            
+            wait_logged = False
+            
+            action_queue = queue_holder["queue"]
+            if action_queue is None:
+                logger.warning("[RTC] queue_holder['queue'] is None!")
+                time.sleep(0.01)
+                continue
+            
+            obs_filtered = obs_holder.get("obs")
+            if obs_filtered is None:
+                logger.warning("[RTC] obs_holder['obs'] is None!")
+                time.sleep(0.01)
+                continue
+            
+            qsize = action_queue.qsize()
+            if qsize <= get_actions_threshold:
+                try:
+                    if inference_count == 0:
+                        logger.info(f"[RTC] Starting first inference, obs keys={len(obs_filtered)}, qsize={qsize}")
+                    
+                    current_time = time.perf_counter()
+                    action_index_before_inference = action_queue.get_action_index()
+                    prev_actions = action_queue.get_left_over()
+                    
+                    inference_latency = latency_tracker.max()
+                    inference_delay = math.ceil(inference_latency / time_per_chunk) if inference_latency else 0
+                    
+                    obs_with_policy_features = build_dataset_frame(hw_features, obs_filtered, prefix="observation")
+                    
+                    for name in obs_with_policy_features:
+                        obs_with_policy_features[name] = torch.from_numpy(obs_with_policy_features[name])
+                        if "image" in name:
+                            obs_with_policy_features[name] = obs_with_policy_features[name].float() / 255
+                            obs_with_policy_features[name] = obs_with_policy_features[name].permute(2, 0, 1).contiguous()
+                        obs_with_policy_features[name] = obs_with_policy_features[name].unsqueeze(0).to(policy_device)
+                    
+                    obs_with_policy_features["task"] = [cfg.dataset.single_task]
+                    obs_with_policy_features["robot_type"] = obs_holder.get("robot_type", "openarms_follower")
+                    
+                    preprocessed_obs = preprocessor(obs_with_policy_features)
+                    
+                    actions = policy.predict_action_chunk(
+                        preprocessed_obs,
+                        inference_delay=inference_delay,
+                        prev_chunk_left_over=prev_actions,
+                    )
+                    
+                    original_actions = actions.squeeze(0).clone()
+                    postprocessed_actions = postprocessor(actions).squeeze(0)
+                    
+                    new_latency = time.perf_counter() - current_time
+                    new_delay = math.ceil(new_latency / time_per_chunk)
+                    latency_tracker.add(new_latency)
+                    
+                    action_queue.merge(original_actions, postprocessed_actions, new_delay, action_index_before_inference)
+                    
+                    inference_count += 1
+                    logger.info(f"[RTC] Inference #{inference_count}, latency={new_latency:.2f}s, queue={action_queue.qsize()}")
+                except Exception as e:
+                    logger.error(f"[RTC] Inference error: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    time.sleep(1.0)
+            else:
+                time.sleep(0.01)
+        
+        logger.info("[RTC] Inference thread shutting down")
+    except Exception as e:
+        logger.error(f"[RTC] THREAD CRASHED: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+# ============================================================================
+# Main Rollout Loop
+# ============================================================================
+
+@safe_stop_image_writer
+def rac_rtc_rollout_loop(
+    robot: RobotWrapper,
+    teleop: Teleoperator,
+    policy: PreTrainedPolicy,
+    preprocessor,
+    postprocessor,
+    dataset: LeRobotDataset,
+    events: dict,
+    cfg: RaCRTCConfig,
+    queue_holder: dict,
+    obs_holder: dict,  # Main loop writes obs here for RTC thread to read
+    policy_active: Event,
+    hw_features: dict,
+) -> dict:
+    """RaC rollout loop with RTC for smooth policy execution."""
+    fps = cfg.dataset.fps
+    single_task = cfg.dataset.single_task
+    control_time_s = cfg.dataset.episode_time_s
+    device = get_safe_torch_device(cfg.device)
+    
+    # Reset policy state
+    policy.reset()
+    preprocessor.reset()
+    postprocessor.reset()
+    
+    frame_buffer = []
+    stats = {
+        "total_frames": 0,
+        "autonomous_frames": 0,
+        "paused_frames": 0,
+        "correction_frames": 0,
+    }
+
+    teleop.disable_torque()
+    was_paused = False
+    waiting_for_takeover = False
+    
+    # Action keys for converting tensor to dict
+    action_keys = [k for k in robot.action_features.keys() if k.endswith(".pos")]
+    
+    # Interpolation state
+    prev_action: Tensor | None = None
+    interpolated_actions: list[Tensor] = []
+    interp_idx = 0
+    
+    if cfg.interpolation:
+        control_interval = 1.0 / (fps * 2)  # 2x rate
+    else:
+        control_interval = 1.0 / fps
+    
+    robot_action = {}
+    timestamp = 0
+    start_t = time.perf_counter()
+
+    while timestamp < control_time_s:
+        loop_start = time.perf_counter()
+
+        if events["exit_early"]:
+            events["exit_early"] = False
+            events["policy_paused"] = False
+            events["correction_active"] = False
+            break
+
+        # State transition: entering paused state
+        if events["policy_paused"] and not was_paused:
+            policy_active.clear()  # Stop RTC inference
+            obs = robot.get_observation()
+            obs_filtered = {k: v for k, v in obs.items() if k in robot.observation_features}
+            robot_pos = {k: v for k, v in obs_filtered.items() if k.endswith(".pos")}
+            print("[RaC] Moving teleop to robot position...")
+            teleop.smooth_move_to(robot_pos, duration_s=2.0, fps=50)
+            print("[RaC] Teleop aligned. Press 'c' to take control.")
+            events["start_next_episode"] = False
+            waiting_for_takeover = True
+            was_paused = True
+            # Reset interpolation
+            prev_action = None
+            interpolated_actions = []
+            interp_idx = 0
+
+        # Wait for takeover
+        if waiting_for_takeover and events["start_next_episode"]:
+            print("[RaC] Taking control...")
+            teleop.disable_torque()
+            events["start_next_episode"] = False
+            events["correction_active"] = True
+            waiting_for_takeover = False
+
+        # Get observation (ONLY the main loop reads from robot!)
+        obs = robot.get_observation()
+        obs_filtered = {k: v for k, v in obs.items() if k in robot.observation_features}
+        obs_frame = build_dataset_frame(dataset.features, obs_filtered, prefix=OBS_STR)
+        
+        # Share observation with RTC thread (thread reads, main loop writes)
+        obs_holder["obs"] = obs_filtered
+
+        if events["correction_active"]:
+            # Human controlling
+            robot_action = teleop.get_action()
+            for key in robot_action:
+                if "gripper" in key:
+                    robot_action[key] = -0.65 * robot_action[key]
+            robot.send_action(robot_action)
+            stats["correction_frames"] += 1
+            
+            action_frame = build_dataset_frame(dataset.features, robot_action, prefix=ACTION)
+            frame = {**obs_frame, **action_frame, "task": single_task}
+            frame_buffer.append(frame)
+            stats["total_frames"] += 1
+            
+        elif waiting_for_takeover:
+            stats["paused_frames"] += 1
+            
+        elif events["policy_paused"]:
+            robot_pos = {k: v for k, v in obs_filtered.items() if k.endswith(".pos")}
+            teleop.send_feedback(robot_pos)
+            stats["paused_frames"] += 1
+            
+        else:
+            # Policy execution with RTC
+            if not policy_active.is_set():
+                policy_active.set()
+                logger.info("[ROLLOUT] Policy activated, waiting for first actions...")
+            
+            action_queue = queue_holder["queue"]
+            
+            # Get action from queue (with interpolation)
+            if interp_idx >= len(interpolated_actions):
+                new_action = action_queue.get() if action_queue else None
+                
+                # Log queue status periodically
+                if stats["autonomous_frames"] == 0 and new_action is None:
+                    qsize = action_queue.qsize() if action_queue else -1
+                    if timestamp < 0.5 or int(timestamp * 10) % 10 == 0:
+                        logger.info(f"[ROLLOUT] Waiting for actions... queue_size={qsize}, obs_set={obs_holder.get('obs') is not None}")
+                
+                if new_action is not None:
+                    current_action = new_action.cpu()
+                    
+                    if cfg.interpolation and prev_action is not None:
+                        mid = prev_action + 0.5 * (current_action - prev_action)
+                        interpolated_actions = [mid, current_action]
+                    else:
+                        interpolated_actions = [current_action]
+                    
+                    prev_action = current_action
+                    interp_idx = 0
+                    
+                    if stats["autonomous_frames"] == 0:
+                        logger.info(f"[ROLLOUT] Got first action! Starting robot motion.")
+            
+            if interp_idx < len(interpolated_actions):
+                action_to_send = interpolated_actions[interp_idx]
+                interp_idx += 1
+                
+                robot_action = {}
+                for i, key in enumerate(action_keys):
+                    if i < len(action_to_send):
+                        robot_action[key] = action_to_send[i].item()
+                
+                robot.send_action(robot_action)
+                stats["autonomous_frames"] += 1
+                
+                # Record at original fps
+                action_frame = build_dataset_frame(dataset.features, robot_action, prefix=ACTION)
+                frame = {**obs_frame, **action_frame, "task": single_task}
+                frame_buffer.append(frame)
+                stats["total_frames"] += 1
+
+        if cfg.display_data:
+            log_rerun_data(observation=obs_filtered, action=robot_action)
+
+        dt = time.perf_counter() - loop_start
+        sleep_time = control_interval - dt
+        if sleep_time > 0:
+            precise_sleep(sleep_time)
+        timestamp = time.perf_counter() - start_t
+
+    policy_active.clear()
+    teleop.disable_torque()
+
+    for frame in frame_buffer:
+        dataset.add_frame(frame)
+
+    return stats
+
+
+def reset_loop(robot: RobotWrapper, teleop: Teleoperator, events: dict, fps: int):
+    """Reset period where human repositions environment."""
+    print("\n" + "=" * 65)
+    print("  [RaC] RESET")
+    print("=" * 65)
+    
+    events["in_reset"] = True
+    events["start_next_episode"] = False
+    
+    obs = robot.get_observation()
+    robot_pos = {k: v for k, v in obs.items() if k.endswith(".pos") and k in robot.observation_features}
+    teleop.smooth_move_to(robot_pos, duration_s=2.0, fps=50)
+    
+    print("  Press any key/pedal to enable teleoperation")
+    while not events["start_next_episode"] and not events["stop_recording"]:
+        precise_sleep(0.05)
+    
+    if events["stop_recording"]:
+        return
+    
+    events["start_next_episode"] = False
+    teleop.disable_torque()
+    print("  Teleop enabled - press any key/pedal to start episode")
+
+    while not events["start_next_episode"] and not events["stop_recording"]:
+        loop_start = time.perf_counter()
+        action = teleop.get_action()
+        for key in action:
+            if "gripper" in key:
+                action[key] = -0.65 * action[key]
+        robot.send_action(action)
+        dt = time.perf_counter() - loop_start
+        precise_sleep(1 / fps - dt)
+    
+    events["in_reset"] = False
+    events["start_next_episode"] = False
+    events["exit_early"] = False
+    events["policy_paused"] = False
+    events["correction_active"] = False
+
+
+# ============================================================================
+# Main Entry Point
+# ============================================================================
+
+@parser.wrap()
+def rac_rtc_collect(cfg: RaCRTCConfig) -> LeRobotDataset:
+    """Main RaC data collection function with RTC."""
+    init_logging()
+    logging.info(pformat(cfg.__dict__))
+
+    if cfg.display_data:
+        init_rerun(session_name="rac_rtc_collection_openarms")
+
+    robot_raw = make_robot_from_config(cfg.robot)
+    teleop = make_teleoperator_from_config(cfg.teleop)
+    
+    teleop_proc, robot_proc, obs_proc = make_identity_processors()
+
+    dataset_features = combine_feature_dicts(
+        aggregate_pipeline_dataset_features(
+            pipeline=teleop_proc,
+            initial_features=create_initial_features(action=robot_raw.action_features),
+            use_videos=cfg.dataset.video,
+        ),
+        aggregate_pipeline_dataset_features(
+            pipeline=obs_proc,
+            initial_features=create_initial_features(observation=robot_raw.observation_features),
+            use_videos=cfg.dataset.video,
+        ),
+    )
+
+    dataset = None
+    listener = None
+    shutdown_event = Event()
+    policy_active = Event()
+    rtc_thread = None
+
+    try:
+        if cfg.resume:
+            dataset = LeRobotDataset(
+                cfg.dataset.repo_id,
+                root=cfg.dataset.root,
+                batch_encoding_size=cfg.dataset.video_encoding_batch_size,
+            )
+            if hasattr(robot_raw, "cameras") and robot_raw.cameras:
+                dataset.start_image_writer(
+                    num_processes=cfg.dataset.num_image_writer_processes,
+                    num_threads=cfg.dataset.num_image_writer_threads_per_camera * len(robot_raw.cameras),
+                )
+        else:
+            dataset = LeRobotDataset.create(
+                cfg.dataset.repo_id,
+                cfg.dataset.fps,
+                root=cfg.dataset.root,
+                robot_type=robot_raw.name,
+                features=dataset_features,
+                use_videos=cfg.dataset.video,
+                image_writer_processes=cfg.dataset.num_image_writer_processes,
+                image_writer_threads=cfg.dataset.num_image_writer_threads_per_camera
+                * len(robot_raw.cameras if hasattr(robot_raw, "cameras") else []),
+                batch_encoding_size=cfg.dataset.video_encoding_batch_size,
+            )
+
+        # Load policy
+        logger.info(f"Loading policy from: {cfg.policy.pretrained_path}")
+        policy_class = get_policy_class(cfg.policy.type)
+        policy = policy_class.from_pretrained(cfg.policy.pretrained_path)
+        policy.config.rtc_config = cfg.rtc
+        policy.init_rtc_processor()
+        policy = policy.to(cfg.device)
+        policy.eval()
+        logger.info(f"Policy loaded: {policy.name}")
+
+        # Setup preprocessor/postprocessor
+        hw_features = hw_to_dataset_features(robot_raw.observation_features, "observation")
+        preprocessor, postprocessor = make_pre_post_processors(
+            policy_cfg=cfg.policy,
+            pretrained_path=cfg.policy.pretrained_path,
+            dataset_stats=rename_stats(dataset.meta.stats, cfg.dataset.rename_map),
+            preprocessor_overrides={
+                "device_processor": {"device": cfg.device},
+                "rename_observations_processor": {"rename_map": cfg.dataset.rename_map},
+            },
+        )
+
+        # Connect robot and wrap for thread safety
+        robot_raw.connect()
+        robot = RobotWrapper(robot_raw)
+        
+        teleop.connect()
+        listener, events = init_rac_keyboard_listener()
+
+        # Shared state holders (main loop writes, RTC thread reads)
+        queue_holder = {"queue": ActionQueue(cfg.rtc)}
+        obs_holder = {"obs": None, "robot_type": robot.robot_type}  # Main loop updates obs
+
+        # Start RTC inference thread
+        # NOTE: Thread does NOT access robot directly - reads from obs_holder
+        rtc_thread = Thread(
+            target=rtc_inference_thread,
+            args=(
+                policy,
+                obs_holder,  # Thread reads obs from here (set by main loop)
+                hw_features,
+                preprocessor,
+                postprocessor,
+                queue_holder,
+                shutdown_event,
+                policy_active,
+                cfg,
+            ),
+            daemon=True,
+            name="RTCInference",
+        )
+        rtc_thread.start()
+        logger.info("Started RTC inference thread")
+
+        print("\n" + "=" * 65)
+        print("  RaC Data Collection with RTC")
+        print("=" * 65)
+        print(f"  Policy: {cfg.policy.pretrained_path}")
+        print(f"  Task: {cfg.dataset.single_task}")
+        print(f"  FPS: {cfg.dataset.fps}")
+        print(f"  Interpolation: {cfg.interpolation}")
+        print()
+        print("  Controls:")
+        print("    SPACE  - Pause policy")
+        print("    c      - Take control")
+        print("    →      - End episode")
+        print("    ESC    - Stop and push to hub")
+        print("=" * 65 + "\n")
+
+        with VideoEncodingManager(dataset):
+            recorded = 0
+            while recorded < cfg.dataset.num_episodes and not events["stop_recording"]:
+                log_say(f"RaC episode {dataset.num_episodes}", cfg.play_sounds)
+                
+                # Fresh action queue per episode (update holder so thread sees it)
+                queue_holder["queue"] = ActionQueue(cfg.rtc)
+                
+                logger.info(f"Episode {recorded + 1} / {cfg.dataset.num_episodes}")
+
+                stats = rac_rtc_rollout_loop(
+                    robot=robot,
+                    teleop=teleop,
+                    policy=policy,
+                    preprocessor=preprocessor,
+                    postprocessor=postprocessor,
+                    dataset=dataset,
+                    events=events,
+                    cfg=cfg,
+                    queue_holder=queue_holder,
+                    obs_holder=obs_holder,
+                    policy_active=policy_active,
+                    hw_features=hw_features,
+                )
+
+                logging.info(f"Episode stats: {stats}")
+
+                if events["rerecord_episode"]:
+                    log_say("Re-recording", cfg.play_sounds)
+                    events["rerecord_episode"] = False
+                    events["exit_early"] = False
+                    dataset.clear_episode_buffer()
+                    continue
+
+                dataset.save_episode()
+                recorded += 1
+
+                if recorded < cfg.dataset.num_episodes and not events["stop_recording"]:
+                    reset_loop(robot, teleop, events, cfg.dataset.fps)
+
+    finally:
+        log_say("Stop recording", cfg.play_sounds, blocking=True)
+        
+        shutdown_event.set()
+        policy_active.clear()
+        
+        if rtc_thread and rtc_thread.is_alive():
+            rtc_thread.join(timeout=2.0)
+
+        if dataset:
+            dataset.finalize()
+
+        if robot_raw.is_connected:
+            robot_raw.disconnect()
+        if teleop.is_connected:
+            teleop.disconnect()
+
+        if not is_headless() and listener:
+            listener.stop()
+
+        if cfg.dataset.push_to_hub:
+            dataset.push_to_hub(tags=cfg.dataset.tags, private=cfg.dataset.private)
+
+    return dataset
+
+
+def main():
+    from lerobot.utils.import_utils import register_third_party_plugins
+    register_third_party_plugins()
+    rac_rtc_collect()
+
+
+if __name__ == "__main__":
+    main()
@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-"""Unify all tasks in a dataset to a single task."""
-
-import argparse
-import json
-from pathlib import Path
-
-import pandas as pd
-
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.utils import write_tasks
-
-
-def unify_tasks(repo_id: str, new_task: str):
-    """Set all episodes to use a single task."""
-    print(f"Loading dataset: {repo_id}")
-    dataset = LeRobotDataset(repo_id)
-    root = dataset.root
-    
-    print(f"Current tasks: {list(dataset.meta.tasks['task']) if dataset.meta.tasks is not None else []}")
-    
-    # 1. Update tasks.parquet to have only one task
-    tasks_df = pd.DataFrame({"task": [new_task]})
-    write_tasks(tasks_df, root)
-    print(f"Set single task: '{new_task}'")
-    
-    # 2. Update all data parquet files to set task_index=0
-    data_dir = root / "data"
-    parquet_files = sorted(data_dir.glob("*/*.parquet"))
-    for parquet_path in parquet_files:
-        df = pd.read_parquet(parquet_path)
-        df["task_index"] = 0
-        df.to_parquet(parquet_path)
-        print(f"Updated: {parquet_path.relative_to(root)}")
-    
-    # 3. Update info.json
-    info_path = root / "info.json"
-    with open(info_path) as f:
-        info = json.load(f)
-    info["total_tasks"] = 1
-    with open(info_path, "w") as f:
-        json.dump(info, f, indent=2)
-    
-    print(f"\nDone! All {dataset.meta.total_episodes} episodes now use task: '{new_task}'")
-    print(f"\nTo push: huggingface-cli upload {repo_id} {root} --repo-type dataset")
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Unify all tasks in a dataset to a single task")
-    parser.add_argument("--repo_id", type=str, required=True, help="Dataset repo_id")
-    parser.add_argument("--task", type=str, required=True, help="New task description")
-    args = parser.parse_args()
-    
-    unify_tasks(args.repo_id, args.task)
-
-
-if __name__ == "__main__":
-    main()
-
@@ -66,17 +66,6 @@ class TrainPipelineConfig(HubMixin):
    eval: EvalConfig = field(default_factory=EvalConfig)
    wandb: WandBConfig = field(default_factory=WandBConfig)

-    # UMI-style relative actions with per-timestep normalization
-    # Mode 1: use_relative_actions=True, use_relative_state=False
-    #   - Actions: relative to current position + per-timestep normalized
-    #   - State: absolute (unchanged)
-    # Mode 2: use_relative_actions=True, use_relative_state=True (full UMI)
-    #   - Actions: relative to current position + per-timestep normalized  
-    #   - State: relative to current position (provides velocity info)
-    # Stats are computed automatically from first 1000 batches at training start
-    use_relative_actions: bool = False
-    use_relative_state: bool = False
-
    # RA-BC (Reward-Aligned Behavior Cloning) parameters
    use_rabc: bool = False  # Enable reward-weighted training
    rabc_progress_path: str | None = None  # Path to precomputed SARM progress parquet file
@@ -75,7 +75,7 @@ class OpenArmsFollowerConfig(RobotConfig):
    # MIT control parameters for position control (used in send_action)
    # List of 8 values: [joint_1, joint_2, joint_3, joint_4, joint_5, joint_6, joint_7, gripper]
    position_kp: list[float] = field(default_factory=lambda: [240.0, 240.0, 240.0, 240.0, 24.0, 31.0, 25.0, 25.0])
-    position_kd: list[float] = field(default_factory=lambda: [3.0, 3.0, 3.0, 3.0, 0.2, 0.2, 0.2, 0.2])
+    position_kd: list[float] = field(default_factory=lambda: [5.0, 5.0, 3.0, 5.0, 0.3, 0.3, 0.3, 0.3])
    
    # Damping gains for stability when applying torque compensation (gravity/friction)
    # Used when kp=0 and only torque is applied
@@ -96,26 +96,16 @@ class OpenArmsFollower(Robot):
        # Initialize Pinocchio robot model for dynamics (optional)
        self.pin_robot = None
        try:
+            # Load URDF - try external path first (with meshes), then repository
            import os
-            from os.path import dirname
-
-            # Prefer the URDF bundled in the repository
-            repo_urdf_path = os.path.join(
-                dirname(__file__), "urdf", "openarm_bimanual_pybullet.urdf"
-            )
-            external_urdf_path = os.path.expanduser(
-                "~/Documents/openarm_description/openarm_bimanual_pybullet.urdf"
-            )
-
-            if os.path.exists(repo_urdf_path):
-                urdf_path = repo_urdf_path
-            elif os.path.exists(external_urdf_path):
+            from os.path import expanduser, dirname
+            
+            # Try external URDF with meshes first
+            external_urdf_path = expanduser("~/Documents/openarm_description/openarm_bimanual_pybullet.urdf")
+            if os.path.exists(external_urdf_path):
                urdf_path = external_urdf_path
-            else:
-                urdf_path = None
-
-            if urdf_path is not None:
                urdf_dir = dirname(urdf_path)
+            
                self.pin_robot = pin.RobotWrapper.BuildFromURDF(urdf_path, urdf_dir)
                self.pin_robot.data = self.pin_robot.model.createData()
                logger.info(f"Loaded OpenArms URDF for dynamics computation from {urdf_path}")
@@ -1,618 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<robot name="openarm">
-  <link name="world" />
-  <joint name="openarm_body_world_joint" type="fixed">
-    <parent link="world" />
-    <child link="openarm_body_link0" />
-    <origin rpy="0 0 0" xyz="0 0 0" />
-  </joint>
-  <link name="openarm_body_link0">
-    <visual name="openarm_body_link0_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0" />
-      <geometry>
-        <mesh filename="./meshes/body/v10/visual/body_link0.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_body_link0_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0" />
-      <geometry>
-        <mesh filename="./meshes/body/v10/collision/body_link0_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0" />
-      <mass value="13.89" />
-      <inertia ixx="1.653" ixy="0.0" ixz="0.0" iyy="1.653" iyz="0.0" izz="0.051" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_openarm_body_link0_joint" type="fixed">
-    <parent link="openarm_body_link0" />
-    <child link="openarm_left_link0" />
-    <origin rpy="-1.5708 0 0" xyz="0.0 0.031 0.698" />
-  </joint>
-  <link name="openarm_left_link0">
-    <visual name="openarm_left_link0_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link0.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link0_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link0_symp.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0009483362816297526 -0.0001580207020448382 0.03076860287587199" />
-      <mass value="1.1432284943239561" />
-      <inertia ixx="0.001128" ixy="-4e-06" ixz="-3.3e-05" iyy="0.000962" iyz="-7e-06" izz="0.00147" />
-    </inertial>
-  </link>
-  <link name="openarm_left_link1">
-    <visual name="openarm_left_link1_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 0.0 -0.0625" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link1.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link1_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 0.0 -0.0625" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link1_symp.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.0011467657911800769 -3.319987657026362e-05 0.05395284380736254" />
-      <mass value="1.1416684646202298" />
-      <inertia ixx="0.001567" ixy="-1e-06" ixz="-2.9e-05" iyy="0.001273" iyz="1e-06" izz="0.001016" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint1" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0 0.0 0.0625" />
-    <parent link="openarm_left_link0" />
-    <child link="openarm_left_link1" />
-    <axis xyz="0 0 1" />
-    <limit effort="40" lower="-3.490659" upper="1.3962629999999998" velocity="16.754666" />
-  </joint>
-  <link name="openarm_left_link2">
-    <visual name="openarm_left_link2_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0301 0.0 -0.1225" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link2.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link2_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0301 0.0 -0.1225" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link2_symp.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.00839629182351943 2.0145102027597523e-08 0.03256649300522363" />
-      <mass value="0.2775092746011571" />
-      <inertia ixx="0.000359" ixy="1e-06" ixz="-0.000109" iyy="0.000376" iyz="1e-06" izz="0.000232" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint2" type="revolute">
-    <origin rpy="-1.57079632679 0 0" xyz="-0.0301 0.0 0.06" />
-    <parent link="openarm_left_link1" />
-    <child link="openarm_left_link2" />
-    <axis xyz="-1 0 0" />
-    <limit effort="40" lower="-3.3161253267948965" upper="0.17453267320510335" velocity="16.754666" />
-  </joint>
-  <link name="openarm_left_link3">
-    <visual name="openarm_left_link3_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.18875" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link3.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link3_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.18875" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link3_symp.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.002104752099628911 -0.0005549085042607548 0.09047470545721961" />
-      <mass value="1.073863338202347" />
-      <inertia ixx="0.004372" ixy="1e-06" ixz="1.1e-05" iyy="0.004319" iyz="-3.6e-05" izz="0.000661" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint3" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0301 0.0 0.06625" />
-    <parent link="openarm_left_link2" />
-    <child link="openarm_left_link3" />
-    <axis xyz="0 0 1" />
-    <limit effort="27" lower="-1.570796" upper="1.570796" velocity="5.445426" />
-  </joint>
-  <link name="openarm_left_link4">
-    <visual name="openarm_left_link4_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0315 -0.3425" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link4.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link4_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0315 -0.3425" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link4_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0029006831074562967 -0.03030575826634669 0.06339637422196209" />
-      <mass value="0.6348534566833373" />
-      <inertia ixx="0.000623" ixy="-1e-06" ixz="-1.9e-05" iyy="0.000511" iyz="3.8e-05" izz="0.000334" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint4" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0 0.0315 0.15375" />
-    <parent link="openarm_left_link3" />
-    <child link="openarm_left_link4" />
-    <axis xyz="0 1 0" />
-    <limit effort="27" lower="0.0" upper="2.443461" velocity="5.445426" />
-  </joint>
-  <link name="openarm_left_link5">
-    <visual name="openarm_left_link5_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.438" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link5.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link5_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.438" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link5_symp.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.003049665024221911 -0.0008866902457326625 0.043079803024980934" />
-      <mass value="0.6156588026168502" />
-      <inertia ixx="0.000423" ixy="-8e-06" ixz="6e-06" iyy="0.000445" iyz="-6e-06" izz="0.000324" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint5" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0 -0.0315 0.0955" />
-    <parent link="openarm_left_link4" />
-    <child link="openarm_left_link5" />
-    <axis xyz="0 0 1" />
-    <limit effort="7" lower="-1.570796" upper="1.570796" velocity="20.943946" />
-  </joint>
-  <link name="openarm_left_link6">
-    <visual name="openarm_left_link6_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0375 -0.0 -0.5585" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link6.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link6_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0375 -0.0 -0.5585" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link6_symp.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.037136587005447405 -0.00033230528343419053 -9.498374522309838e-05" />
-      <mass value="0.475202773187987" />
-      <inertia ixx="0.000143" ixy="1e-06" ixz="1e-06" iyy="0.000157" iyz="1e-06" izz="0.000159" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint6" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0375 0.0 0.1205" />
-    <parent link="openarm_left_link5" />
-    <child link="openarm_left_link6" />
-    <axis xyz="1 0 0" />
-    <limit effort="7" lower="-0.785398" upper="0.785398" velocity="20.943946" />
-  </joint>
-  <link name="openarm_left_link7">
-    <visual name="openarm_left_link7_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0 -0.5585" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link7.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link7_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0 -0.5585" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link7_symp.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="6.875510271106056e-05 -0.01266175250761268 0.06951945409987448" />
-      <mass value="0.4659771327380578" />
-      <inertia ixx="0.000639" ixy="1e-06" ixz="1e-06" iyy="0.000497" iyz="8.9e-05" izz="0.000342" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint7" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0375 0.0 0.0" />
-    <parent link="openarm_left_link6" />
-    <child link="openarm_left_link7" />
-    <axis xyz="0 -1 0" />
-    <limit effort="7" lower="-1.570796" upper="1.570796" velocity="20.943946" />
-  </joint>
-  <joint name="openarm_right_openarm_body_link0_joint" type="fixed">
-    <parent link="openarm_body_link0" />
-    <child link="openarm_right_link0" />
-    <origin rpy="1.5708 0 0" xyz="0.0 -0.031 0.698" />
-  </joint>
-  <link name="openarm_right_link0">
-    <visual name="openarm_right_link0_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link0.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link0_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link0_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0009483362816297526 0.0001580207020448382 0.03076860287587199" />
-      <mass value="1.1432284943239561" />
-      <inertia ixx="0.001128" ixy="-4e-06" ixz="-3.3e-05" iyy="0.000962" iyz="-7e-06" izz="0.00147" />
-    </inertial>
-  </link>
-  <link name="openarm_right_link1">
-    <visual name="openarm_right_link1_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 0.0 -0.0625" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link1.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link1_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 0.0 -0.0625" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link1_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.0011467657911800769 3.319987657026362e-05 0.05395284380736254" />
-      <mass value="1.1416684646202298" />
-      <inertia ixx="0.001567" ixy="-1e-06" ixz="-2.9e-05" iyy="0.001273" iyz="1e-06" izz="0.001016" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint1" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0 0.0 0.0625" />
-    <parent link="openarm_right_link0" />
-    <child link="openarm_right_link1" />
-    <axis xyz="0 0 1" />
-    <limit effort="40" lower="-1.396263" upper="3.490659" velocity="16.754666" />
-  </joint>
-  <link name="openarm_right_link2">
-    <visual name="openarm_right_link2_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0301 0.0 -0.1225" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link2.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link2_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0301 0.0 -0.1225" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link2_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.00839629182351943 -2.0145102027597523e-08 0.03256649300522363" />
-      <mass value="0.2775092746011571" />
-      <inertia ixx="0.000359" ixy="1e-06" ixz="-0.000109" iyy="0.000376" iyz="1e-06" izz="0.000232" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint2" type="revolute">
-    <origin rpy="1.57079632679 0 0" xyz="-0.0301 0.0 0.06" />
-    <parent link="openarm_right_link1" />
-    <child link="openarm_right_link2" />
-    <axis xyz="-1 0 0" />
-    <limit effort="40" lower="-0.17453267320510335" upper="3.3161253267948965" velocity="16.754666" />
-  </joint>
-  <link name="openarm_right_link3">
-    <visual name="openarm_right_link3_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.18875" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link3.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link3_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.18875" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link3_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.002104752099628911 0.0005549085042607548 0.09047470545721961" />
-      <mass value="1.073863338202347" />
-      <inertia ixx="0.004372" ixy="1e-06" ixz="1.1e-05" iyy="0.004319" iyz="-3.6e-05" izz="0.000661" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint3" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0301 0.0 0.06625" />
-    <parent link="openarm_right_link2" />
-    <child link="openarm_right_link3" />
-    <axis xyz="0 0 1" />
-    <limit effort="27" lower="-1.570796" upper="1.570796" velocity="5.445426" />
-  </joint>
-  <link name="openarm_right_link4">
-    <visual name="openarm_right_link4_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0315 -0.3425" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link4.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link4_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0315 -0.3425" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link4_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0029006831074562967 -0.03030575826634669 0.06339637422196209" />
-      <mass value="0.6348534566833373" />
-      <inertia ixx="0.000623" ixy="-1e-06" ixz="-1.9e-05" iyy="0.000511" iyz="3.8e-05" izz="0.000334" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint4" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0 0.0315 0.15375" />
-    <parent link="openarm_right_link3" />
-    <child link="openarm_right_link4" />
-    <axis xyz="0 1 0" />
-    <limit effort="27" lower="0.0" upper="2.443461" velocity="5.445426" />
-  </joint>
-  <link name="openarm_right_link5">
-    <visual name="openarm_right_link5_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.438" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link5.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link5_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.438" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link5_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.003049665024221911 0.0008866902457326625 0.043079803024980934" />
-      <mass value="0.6156588026168502" />
-      <inertia ixx="0.000423" ixy="-8e-06" ixz="6e-06" iyy="0.000445" iyz="-6e-06" izz="0.000324" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint5" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0 -0.0315 0.0955" />
-    <parent link="openarm_right_link4" />
-    <child link="openarm_right_link5" />
-    <axis xyz="0 0 1" />
-    <limit effort="7" lower="-1.570796" upper="1.570796" velocity="20.943946" />
-  </joint>
-  <link name="openarm_right_link6">
-    <visual name="openarm_right_link6_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0375 -0.0 -0.5585" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link6.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link6_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0375 -0.0 -0.5585" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link6_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.037136587005447405 0.00033230528343419053 -9.498374522309838e-05" />
-      <mass value="0.475202773187987" />
-      <inertia ixx="0.000143" ixy="1e-06" ixz="1e-06" iyy="0.000157" iyz="1e-06" izz="0.000159" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint6" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0375 0.0 0.1205" />
-    <parent link="openarm_right_link5" />
-    <child link="openarm_right_link6" />
-    <axis xyz="1 0 0" />
-    <limit effort="7" lower="-0.785398" upper="0.785398" velocity="20.943946" />
-  </joint>
-  <link name="openarm_right_link7">
-    <visual name="openarm_right_link7_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0 -0.5585" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link7.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link7_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0 -0.5585" />
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link7_symp.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="6.875510271106056e-05 0.01266175250761268 0.06951945409987448" />
-      <mass value="0.4659771327380578" />
-      <inertia ixx="0.000639" ixy="1e-06" ixz="1e-06" iyy="0.000497" iyz="8.9e-05" izz="0.000342" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint7" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0375 0.0 0.0" />
-    <parent link="openarm_right_link6" />
-    <child link="openarm_right_link7" />
-    <axis xyz="0 1 0" />
-    <limit effort="7" lower="-1.570796" upper="1.570796" velocity="20.943946" />
-  </joint>
-  <link name="openarm_left_hand">
-    <visual name="openarm_left_hand_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 -0.6585" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/hand.dae" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_hand_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 -0.6585" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/hand.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0 0.002 0.03" />
-      <mass value="0.35" />
-      <inertia ixx="0.0002473" ixy="1e-06" ixz="1e-06" iyy="1.763e-05" iyz="1e-06" izz="0.0002521" />
-    </inertial>
-  </link>
-  <joint name="left_openarm_hand_joint" type="fixed">
-    <parent link="openarm_left_link7" />
-    <child link="openarm_left_hand" />
-    <origin rpy="0 0 0" xyz="0 -0.0 0.1001" />
-  </joint>
-  <link name="openarm_left_hand_tcp">
-    <inertial>
-      <origin xyz="0 0 0" rpy="0 0 0" />
-      <mass value="0.001" />
-      <inertia ixx="0.000001" ixy="0.0" ixz="0.0" iyy="0.000001" iyz="0.0" izz="0.000001" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_hand_tcp_joint" type="fixed">
-    <origin rpy="0 0 0" xyz="0 -0.0 0.08" />
-    <parent link="openarm_left_hand" />
-    <child link="openarm_left_hand_tcp" />
-  </joint>
-  <link name="openarm_left_left_finger">
-    <visual name="openarm_left_left_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.673001" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/finger.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_left_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.673001" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0064528 0.01702 0.0219685" />
-      <mass value="0.03602545343277134" />
-      <inertia ixx="2.3749999999999997e-06" ixy="1e-06" ixz="1e-06" iyy="2.3749999999999997e-06" iyz="1e-06" izz="7.5e-07" />
-    </inertial>
-  </link>
-  <link name="openarm_left_right_finger">
-    <visual name="openarm_left_right_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.673001" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/finger.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_left_right_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.673001" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0064528 -0.01702 0.0219685" />
-      <mass value="0.03602545343277134" />
-      <inertia ixx="2.3749999999999997e-06" ixy="1e-06" ixz="1e-06" iyy="2.3749999999999997e-06" iyz="1e-06" izz="7.5e-07" />
-    </inertial>
-  </link>
-  <joint name="openarm_left_finger_joint1" type="prismatic">
-    <parent link="openarm_left_hand" />
-    <child link="openarm_left_right_finger" />
-    <origin rpy="0 0 0" xyz="0 -0.006 0.015" />
-    <axis xyz="0 -1 0" />
-    <limit effort="333" lower="0.0" upper="0.044" velocity="10.0" />
-  </joint>
-  <joint name="openarm_left_finger_joint2" type="prismatic">
-    <parent link="openarm_left_hand" />
-    <child link="openarm_left_left_finger" />
-    <origin rpy="0 0 0" xyz="0 0.006 0.015" />
-    <axis xyz="0 1 0" />
-    <limit effort="333" lower="0.0" upper="0.044" velocity="10.0" />
-    <mimic joint="openarm_left_finger_joint1" />
-  </joint>
-  <link name="openarm_right_hand">
-    <visual name="openarm_right_hand_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 -0.6585" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/hand.dae" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_hand_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 -0.6585" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/hand.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0 0.002 0.03" />
-      <mass value="0.35" />
-      <inertia ixx="0.0002473" ixy="1e-06" ixz="1e-06" iyy="1.763e-05" iyz="1e-06" izz="0.0002521" />
-    </inertial>
-  </link>
-  <joint name="right_openarm_hand_joint" type="fixed">
-    <parent link="openarm_right_link7" />
-    <child link="openarm_right_hand" />
-    <origin rpy="0 0 0" xyz="0 -0.0 0.1001" />
-  </joint>
-  <link name="openarm_right_hand_tcp">
-    <inertial>
-      <origin xyz="0 0 0" rpy="0 0 0" />
-      <mass value="0.001" />
-      <inertia ixx="0.000001" ixy="0.0" ixz="0.0" iyy="0.000001" iyz="0.0" izz="0.000001" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_hand_tcp_joint" type="fixed">
-    <origin rpy="0 0 0" xyz="0 -0.0 0.08" />
-    <parent link="openarm_right_hand" />
-    <child link="openarm_right_hand_tcp" />
-  </joint>
-  <link name="openarm_right_left_finger">
-    <visual name="openarm_right_left_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.673001" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/finger.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_left_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.673001" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0064528 0.01702 0.0219685" />
-      <mass value="0.03602545343277134" />
-      <inertia ixx="2.3749999999999997e-06" ixy="1e-06" ixz="1e-06" iyy="2.3749999999999997e-06" iyz="1e-06" izz="7.5e-07" />
-    </inertial>
-  </link>
-  <link name="openarm_right_right_finger">
-    <visual name="openarm_right_right_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.673001" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/finger.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </visual>
-    <collision name="openarm_right_right_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.673001" />
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 -0.001 0.001" />
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0064528 -0.01702 0.0219685" />
-      <mass value="0.03602545343277134" />
-      <inertia ixx="2.3749999999999997e-06" ixy="1e-06" ixz="1e-06" iyy="2.3749999999999997e-06" iyz="1e-06" izz="7.5e-07" />
-    </inertial>
-  </link>
-  <joint name="openarm_right_finger_joint1" type="prismatic">
-    <parent link="openarm_right_hand" />
-    <child link="openarm_right_right_finger" />
-    <origin rpy="0 0 0" xyz="0 -0.006 0.015" />
-    <axis xyz="0 -1 0" />
-    <limit effort="333" lower="0.0" upper="0.044" velocity="10.0" />
-  </joint>
-  <joint name="openarm_right_finger_joint2" type="prismatic">
-    <parent link="openarm_right_hand" />
-    <child link="openarm_right_left_finger" />
-    <origin rpy="0 0 0" xyz="0 0.006 0.015" />
-    <axis xyz="0 1 0" />
-    <limit effort="333" lower="0.0" upper="0.044" velocity="10.0" />
-    <mimic joint="openarm_right_finger_joint1" />
-  </joint>
-</robot>
@@ -13,7 +13,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import gc
 import logging
 import time
 from contextlib import nullcontext
@@ -47,10 +46,6 @@ from lerobot.utils.train_utils import (
    save_checkpoint,
    update_last_checkpoint,
 )
-from lerobot.utils.relative_actions import (
-    convert_to_relative_actions,
-    compute_global_relative_stats,
-)
 from lerobot.utils.utils import (
    format_big_number,
    has_method,
@@ -303,61 +298,6 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
            device=device,
        )

-    # Compute relative action/state stats and hotswap them into the normalizer
-    raw_state_key = None
-    if cfg.use_relative_actions:
-        from lerobot.processor.normalize_processor import hotswap_stats
-
-        mode = "actions + state" if cfg.use_relative_state else "actions only"
-        cfg.output_dir.mkdir(parents=True, exist_ok=True)
-        stats_path = cfg.output_dir / "relative_stats.pt"
-
-        reverse_rename = {v: k for k, v in cfg.rename_map.items()} if cfg.rename_map else {}
-        raw_state_key = reverse_rename.get("observation.state", "observation.state")
-
-        if is_main_process:
-            logging.info(colored(f"Relative mode: {mode}", "cyan", attrs=["bold"]))
-
-            if stats_path.exists():
-                logging.info(f"Loading pre-computed relative stats from: {stats_path}")
-            else:
-                logging.info("Computing global relative stats (first 1000 batches)...")
-                stats_dataset = make_dataset(cfg)
-                temp_loader = torch.utils.data.DataLoader(
-                    stats_dataset, batch_size=cfg.batch_size, shuffle=False, num_workers=0
-                )
-                rel_stats = compute_global_relative_stats(
-                    temp_loader, state_key=raw_state_key,
-                    convert_state=cfg.use_relative_state, num_batches=1000,
-                )
-                del temp_loader, stats_dataset
-                gc.collect()
-                torch.save(rel_stats, stats_path)
-                logging.info(f"Saved relative stats to: {stats_path}")
-
-        if not is_main_process:
-            while not stats_path.exists():
-                time.sleep(5)
-
-        rel_stats = torch.load(stats_path, weights_only=True, map_location="cpu")
-
-        # Replace absolute stats with relative stats in the normalizer
-        updated_stats = dict(dataset.meta.stats)
-        updated_stats["action"] = {
-            **updated_stats["action"],
-            "mean": rel_stats["action_mean"].numpy(),
-            "std": rel_stats["action_std"].numpy(),
-        }
-        if cfg.use_relative_state and "state_mean" in rel_stats:
-            updated_stats[raw_state_key] = {
-                **updated_stats.get(raw_state_key, {}),
-                "mean": rel_stats["state_mean"].numpy(),
-                "std": rel_stats["state_std"].numpy(),
-            }
-        preprocessor = hotswap_stats(preprocessor, updated_stats)
-        logging.info("Hotswapped normalizer stats with relative stats")
-        accelerator.wait_for_everyone()
-
    step = 0  # number of policy updates (forward + backward + optim)

    if cfg.resume:
@@ -444,15 +384,7 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
    for _ in range(step, cfg.steps):
        start_time = time.perf_counter()
        batch = next(dl_iter)
-
-        # Convert to relative on raw data BEFORE normalization
-        if cfg.use_relative_actions:
-            batch = convert_to_relative_actions(
-                batch, state_key=raw_state_key, convert_state=cfg.use_relative_state,
-            )
-
        batch = preprocessor(batch)
-        
        train_tracker.dataloading_s = time.perf_counter() - start_time

        train_tracker, output_dict = update_policy(
@@ -1,201 +0,0 @@
-"""
-UMI-style relative actions with per-timestep normalization.
-
-Two modes supported:
-  Mode 1: Relative actions only (use_relative_state=False)
-    - Actions converted to relative, state stays absolute
-  Mode 2: Relative actions + state (use_relative_state=True, full UMI)
-    - Both actions and state converted to relative
-
-Per-timestep normalization (TRI LBM / BEHAVIOR style):
-  Training: action_norm[t] = (action_rel[t] - mean[t]) / std[t]
-  Inference: action_rel[t] = action_norm[t] * std[t] + mean[t]
-"""
-
-import torch
-from pathlib import Path
-
-
-class PerTimestepNormalizer:
-    """Per-timestep normalization using precomputed dataset statistics."""
-    
-    def __init__(self, mean: torch.Tensor, std: torch.Tensor, eps: float = 1e-8):
-        self.mean = mean
-        self.std = std
-        self.eps = eps
-        self._cache = {}  # Cache for device/dtype converted tensors
-    
-    def _get_stats(self, device, dtype):
-        """Get cached stats for device/dtype, or create and cache them."""
-        key = (device, dtype)
-        if key not in self._cache:
-            self._cache[key] = (
-                self.mean.to(device, dtype),
-                self.std.to(device, dtype),
-            )
-        return self._cache[key]
-    
-    def normalize(self, x: torch.Tensor) -> torch.Tensor:
-        mean, std = self._get_stats(x.device, x.dtype)
-        if x.dim() == 3 and mean.dim() == 2:
-            mean, std = mean.unsqueeze(0), std.unsqueeze(0)
-        return (x - mean) / (std + self.eps)
-    
-    def unnormalize(self, x: torch.Tensor) -> torch.Tensor:
-        mean, std = self._get_stats(x.device, x.dtype)
-        if x.dim() == 3 and mean.dim() == 2:
-            mean, std = mean.unsqueeze(0), std.unsqueeze(0)
-        return x * (std + self.eps) + mean
-    
-    def save(self, path: Path | str):
-        path = Path(path)
-        path.parent.mkdir(parents=True, exist_ok=True)
-        torch.save({"mean": self.mean.cpu(), "std": self.std.cpu(), "eps": self.eps}, path)
-    
-    @classmethod
-    def load(cls, path: Path | str) -> "PerTimestepNormalizer":
-        data = torch.load(path, weights_only=True, map_location="cpu")
-        return cls(data["mean"], data["std"], data.get("eps", 1e-8))
-
-
-def compute_relative_action_stats(
-    dataloader,
-    state_key: str = "observation.state",
-    num_batches: int | None = None,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Compute per-timestep mean/std from relative actions."""
-    all_rel = []
-    for i, batch in enumerate(dataloader):
-        if num_batches is not None and i >= num_batches:
-            break
-        action, state = batch["action"], batch[state_key]
-        current_pos = state[:, -1, :] if state.dim() == 3 else state
-        min_dim = min(action.shape[-1], current_pos.shape[-1])
-        rel = action.clone()
-        rel[..., :min_dim] -= current_pos[:, None, :min_dim]
-        all_rel.append(rel)
-
-    all_rel = torch.cat(all_rel, dim=0)
-    return all_rel.mean(dim=0), all_rel.std(dim=0).clamp(min=1e-6)
-
-
-def compute_global_relative_stats(
-    dataloader,
-    state_key: str = "observation.state",
-    convert_state: bool = True,
-    num_batches: int | None = None,
-) -> dict[str, torch.Tensor]:
-    """Compute global mean/std for relative actions (and state) across all timesteps.
-
-    Returns stats compatible with the standard MEAN_STD normalizer (shape = action_dim).
-    """
-    all_rel_actions = []
-    all_rel_states = []
-    for i, batch in enumerate(dataloader):
-        if num_batches is not None and i >= num_batches:
-            break
-        action, state = batch["action"], batch[state_key]
-        current_pos = state[:, -1, :] if state.dim() == 3 else state
-
-        min_dim = min(action.shape[-1], current_pos.shape[-1])
-        rel = action.clone()
-        rel[..., :min_dim] -= current_pos[:, None, :min_dim]
-        all_rel_actions.append(rel.reshape(-1, rel.shape[-1]))
-
-        if convert_state:
-            if state.dim() == 3:
-                rel_state = state - current_pos[:, None, :]
-            else:
-                rel_state = torch.zeros_like(state)
-            all_rel_states.append(rel_state.reshape(-1, rel_state.shape[-1]))
-
-    all_rel_actions = torch.cat(all_rel_actions, dim=0)
-    result = {
-        "action_mean": all_rel_actions.mean(dim=0),
-        "action_std": all_rel_actions.std(dim=0).clamp(min=1e-6),
-    }
-    if convert_state and all_rel_states:
-        all_rel_states = torch.cat(all_rel_states, dim=0)
-        result["state_mean"] = all_rel_states.mean(dim=0)
-        result["state_std"] = all_rel_states.std(dim=0).clamp(min=1e-6)
-    return result
-
-
-def convert_to_relative(
-    batch: dict,
-    state_key: str = "observation.state",
-    convert_state: bool = True,
-) -> dict:
-    """
-    Convert actions (and optionally state) to relative.
-    
-    Args:
-        batch: Training batch with "action" and state_key
-        state_key: Key for observation state
-        convert_state: If True, also convert state to relative (full UMI mode)
-    """
-    if "action" not in batch or state_key not in batch:
-        return batch
-    
-    action = batch["action"]
-    state = batch[state_key]
-    batch = batch.copy()
-    
-    # Get current position as reference
-    current_pos = state[:, -1, :] if state.dim() == 3 else state
-    
-    # Convert state if requested
-    if convert_state:
-        if state.dim() == 3:
-            batch[state_key] = state - current_pos[:, None, :]
-        else:
-            batch[state_key] = torch.zeros_like(state)
-    
-    # Convert actions to relative
-    min_dim = min(action.shape[-1], current_pos.shape[-1])
-    rel_action = action.clone()
-    rel_action[..., :min_dim] -= current_pos[:, None, :min_dim]
-    batch["action"] = rel_action
-    
-    return batch
-
-
-# Backward compatibility alias
-convert_to_relative_actions = convert_to_relative
-
-
-def convert_state_to_relative(state: torch.Tensor) -> torch.Tensor:
-    """Convert state to relative (for inference with use_relative_state=True)."""
-    if state.dim() == 1:
-        return torch.zeros_like(state)
-    current_pos = state[-1, :] if state.dim() == 2 else state[:, -1, :]
-    if state.dim() == 2:
-        return state - current_pos[None, :]
-    return state - current_pos[:, None, :]
-
-
-def convert_from_relative_actions(
-    relative_actions: torch.Tensor,
-    current_pos: torch.Tensor,
-) -> torch.Tensor:
-    """Convert relative actions back to absolute for robot execution."""
-    current_pos = current_pos.to(relative_actions.device, relative_actions.dtype)
-    min_dim = min(relative_actions.shape[-1], current_pos.shape[-1])
-    absolute = relative_actions.clone()
-    
-    if relative_actions.dim() == 2:
-        absolute[..., :min_dim] += current_pos[:min_dim]
-    elif relative_actions.dim() == 3:
-        absolute[..., :min_dim] += current_pos[None, None, :min_dim]
-    else:
-        absolute[..., :min_dim] += current_pos[:min_dim]
-    
-    return absolute
-
-
-def convert_from_relative_actions_dict(
-    relative_actions: dict[str, float],
-    current_pos: dict[str, float],
-) -> dict[str, float]:
-    """Convert relative actions back to absolute (dict version for inference)."""
-    return {k: v + current_pos.get(k, 0.0) for k, v in relative_actions.items()}
Author	SHA1	Message	Date
Pepijn	3316301693	debug rtc	2026-01-09 16:58:57 +01:00
Pepijn	feedababd2	debug	2026-01-09 16:54:11 +01:00
Pepijn	480ee3299f	log	2026-01-09 16:50:44 +01:00
Pepijn	2d1fb0f508	refactor	2026-01-09 16:41:59 +01:00
Pepijn	b1a55b0666	by default dont use rtc	2026-01-09 16:26:54 +01:00
Pepijn	24af996f82	add logging	2026-01-09 16:10:32 +01:00
Pepijn	8d7eec79c8	f	2026-01-09 16:06:02 +01:00
Pepijn	ccced0c9fc	f	2026-01-09 15:58:37 +01:00
Pepijn	4166eeb7da	have only rtc thread read obs and expose it	2026-01-09 15:48:49 +01:00
Pepijn	1f93a74d8c	fix queue	2026-01-09 14:00:06 +01:00
Pepijn	b16e2f25f7	remove move to zero due to potential race condition	2026-01-09 13:56:16 +01:00
Pepijn	9cc841c674	wait for first actions	2026-01-09 13:45:06 +01:00
Pepijn	63c28ea395	add cmd arg	2026-01-09 13:38:33 +01:00
Pepijn	98c33a4748	Add RaC with RTC	2026-01-09 13:26:25 +01:00
Pepijn	4428248a01	Increase d	2026-01-09 13:17:18 +01:00
Pepijn	7d6f113072	fix at 2x actual freq	2026-01-09 13:03:29 +01:00
Pepijn	7ac05c838d	add interpolation option	2026-01-09 12:56:43 +01:00
Pepijn	c85f1692d6	in place	2026-01-03 22:12:22 +01:00
Pepijn	9fd329713a	modift in place	2026-01-03 22:11:11 +01:00
Pepijn	97d068e5a2	rename to fold	2026-01-03 21:59:11 +01:00
Pepijn	e5bea36387	add unify task	2026-01-03 21:52:19 +01:00