feat(policies): early stopping + termination

perf(pi0fast): stop FAST decoding at the end-of-action marker
The decode loop always runs all max_decoding_steps (256) tokens, but detokenize_actions() cuts the output at the first "|", so most of them get generated and then thrown away. On LIBERO the marker lands around token 25-35. Stopping there gives the same actions ~4x faster end to end. Checked on libero_10: 50/50 episodes came out identical to the old path, same success and same state trajectories.
2026-08-01 22:19:48 +00:00 · 2026-07-31 16:53:37 +02:00 · 2026-07-31 16:49:34 +02:00 · 2026-07-31 16:46:54 +02:00 · 2026-07-31 16:39:49 +02:00 · 2026-07-31 16:28:12 +02:00
10 changed files with 168 additions and 29 deletions
@@ -92,6 +92,20 @@ LIBERO supports two control modes — `relative` (default) and `absolute`. Diffe
 --env.control_mode=relative   # or "absolute"
 ```

+### Reset performance
+
+By default, LeRobot preserves LIBERO's hard-reset behavior. With fixed initial
+states enabled, you can opt into soft resets to skip rebuilding the simulator
+model and renderer on every episode:
+
+```bash
+--env.init_states=true --env.hard_reset=false
+```
+
+Soft resets are faster but are not bit-identical to hard resets after the
+environment's settling steps, so camera observations and policy results may
+differ slightly. Use hard resets when reproducing benchmark results.
+
 ### Policy inputs and outputs

 **Observations:**
@@ -134,6 +134,20 @@ LIBERO-plus supports two control modes — `relative` (default) and `absolute`.
 --env.control_mode=relative   # or "absolute"
 ```

+### Reset performance
+
+By default, LeRobot preserves LIBERO's hard-reset behavior. With fixed initial
+states enabled, you can opt into soft resets to skip rebuilding the simulator
+model and renderer on every episode:
+
+```bash
+--env.init_states=true --env.hard_reset=false
+```
+
+Soft resets are faster but are not bit-identical to hard resets after the
+environment's settling steps, so camera observations and policy results may
+differ slightly. Use hard resets when reproducing benchmark results.
+
 ### Policy inputs and outputs

 **Observations:**
@@ -328,6 +328,7 @@ class LiberoEnv(EnvConfig):
    render_mode: str = "rgb_array"
    camera_name: str = "agentview_image,robot0_eye_in_hand_image"
    init_states: bool = True
+    hard_reset: bool = True
    camera_name_mapping: dict[str, str] | None = None
    observation_height: int = 360
    observation_width: int = 360
@@ -356,6 +357,8 @@ class LiberoEnv(EnvConfig):
    def __post_init__(self):
        if self.fps <= 0:
            raise ValueError(f"fps must be positive, got {self.fps}")
+        if not self.hard_reset and not self.init_states:
+            raise ValueError("hard_reset=False requires init_states=True")

        if self.obs_type == "pixels":
            self.features[LIBERO_KEY_PIXELS_AGENTVIEW] = PolicyFeature(
@@ -416,6 +419,7 @@ class LiberoEnv(EnvConfig):
            "observation_height": self.observation_height,
            "observation_width": self.observation_width,
            "control_freq": self.fps,
+            "hard_reset": self.hard_reset,
        }
        if self.task_ids is not None:
            kwargs["task_ids"] = self.task_ids
@@ -128,10 +128,13 @@ class LiberoEnv(gym.Env):
        control_freq: int = 20,
        control_mode: str = "relative",
        is_libero_plus: bool = False,
+        hard_reset: bool = True,
    ):
        super().__init__()
        if control_freq <= 0:
            raise ValueError(f"control_freq must be positive, got {control_freq}")
+        if not hard_reset and not init_states:
+            raise ValueError("hard_reset=False requires init_states=True")
        self.task_id = task_id
        self.is_libero_plus = is_libero_plus
        self.obs_type = obs_type
@@ -158,6 +161,7 @@ class LiberoEnv(gym.Env):
        self.camera_name_mapping = camera_name_mapping
        self.num_steps_wait = num_steps_wait
        self.control_freq = control_freq
+        self.hard_reset = hard_reset
        self.episode_index = episode_index
        self.episode_length = episode_length
        # Load once and keep
@@ -265,6 +269,9 @@ class LiberoEnv(gym.Env):
            camera_heights=self.observation_height,
            camera_widths=self.observation_width,
            control_freq=self.control_freq,
+            # Soft resets skip LIBERO's model and renderer rebuild. They are opt-in
+            # because settle steps can make their observations differ from hard resets.
+            hard_reset=self.hard_reset,
        )
        env.reset()
        self._env = env
@@ -377,8 +384,9 @@ class LiberoEnv(gym.Env):
            }
        )
        observation = self._format_raw_obs(raw_obs)
-        if terminated:
-            self.reset()
+        # Return the terminal observation unchanged. The caller owns resetting after
+        # termination; vector envs created below use NEXT_STEP autoreset. Resetting here
+        # would therefore reset twice and skip an initial state.
        truncated = False
        return observation, reward, terminated, truncated, info

@@ -476,6 +484,7 @@ def create_libero_envs(
        print(f"Restricting to task_ids={task_ids_filter}")

    is_async = env_cls is gym.vector.AsyncVectorEnv
+    is_sync = env_cls is gym.vector.SyncVectorEnv

    out: dict[str, dict[int, Any]] = defaultdict(dict)
    for suite_name in suite_names:
@@ -512,6 +521,10 @@ def create_libero_envs(
                    cached_act_space = lazy.action_space
                    cached_metadata = lazy.metadata
                out[suite_name][tid] = lazy
+            elif is_sync:
+                out[suite_name][tid] = gym.vector.SyncVectorEnv(
+                    fns, autoreset_mode=gym.vector.AutoresetMode.NEXT_STEP
+                )
            else:
                out[suite_name][tid] = env_cls(fns)
            print(f"Built vec env | suite={suite_name} | task_id={tid} | n_envs={n_envs}")
@@ -212,7 +212,12 @@ class _LazyAsyncVectorEnv:

    def _ensure(self) -> None:
        if self._env is None:
-            self._env = gym.vector.AsyncVectorEnv(self._env_fns, context="forkserver", shared_memory=True)
+            self._env = gym.vector.AsyncVectorEnv(
+                self._env_fns,
+                context="forkserver",
+                shared_memory=True,
+                autoreset_mode=gym.vector.AutoresetMode.NEXT_STEP,
+            )

    @property
    def unwrapped(self):
@@ -604,6 +604,12 @@ class PI0FastPytorch(nn.Module):  # see openpi `PI0Pytorch`
    ) -> torch.Tensor:
        """
        Optimized autoregressive decoding for FAST tokens using KV Caching.
+
+        Greedy decoding stops once every sequence emits the end-of-action marker. The
+        returned tensor keeps its fixed shape, with positions not generated after the
+        batch-wide stop left zero-filled. Stochastic decoding always runs to
+        ``max_decoding_steps`` so early stopping does not change the RNG state used by
+        subsequent calls.
        """
        if max_decoding_steps is None:
            max_decoding_steps = self.config.max_action_tokens
@@ -612,6 +618,12 @@ class PI0FastPytorch(nn.Module):  # see openpi `PI0Pytorch`
        device = tokens.device
        lm_head = self.paligemma_with_expert.paligemma.lm_head

+        # detokenize_actions() cuts at the first "|", so greedy decoding can stop once
+        # every sequence has emitted it. Keep stochastic decoding unchanged because
+        # skipping multinomial calls would shift the RNG state for subsequent calls.
+        end_of_action_token_id = self._paligemma_tokenizer.convert_tokens_to_ids("|")
+        finished = torch.zeros(bsize, dtype=torch.bool, device=device) if temperature == 0 else None
+
        # --- 1. PREFILL PHASE ---
        # Process Images + Text Prompt + BOS token once to populate the KV cache.

@@ -663,6 +675,10 @@ class PI0FastPytorch(nn.Module):  # see openpi `PI0Pytorch`
        # Initialize storage for generated tokens
        generated_action_tokens = torch.zeros((bsize, max_decoding_steps), dtype=torch.long, device=device)
        generated_action_tokens[:, 0] = next_token.squeeze(-1)
+        if finished is not None:
+            finished |= next_token.squeeze(-1) == end_of_action_token_id
+            if bool(finished.all()):
+                return generated_action_tokens

        # Track valid tokens mask (0 for pad, 1 for valid)
        # We need this to tell the new token what it can attend to (images + text + past actions)
@@ -713,6 +729,11 @@ class PI0FastPytorch(nn.Module):  # see openpi `PI0Pytorch`

            generated_action_tokens[:, t] = next_token.squeeze(-1)

+            if finished is not None:
+                finished |= next_token.squeeze(-1) == end_of_action_token_id
+                if bool(finished.all()):
+                    break
+
        return generated_action_tokens


@@ -77,11 +77,13 @@ class EEReferenceAndDelta(RobotActionProcessorStep):
    _command_when_disabled: np.ndarray | None = field(default=None, init=False, repr=False)

    def action(self, action: RobotAction) -> RobotAction:
-        observation = self.transition.get(TransitionKey.OBSERVATION).copy()
+        raw_observation = self.transition.get(TransitionKey.OBSERVATION)

-        if observation is None:
+        if raw_observation is None:
            raise ValueError("Joints observation is require for computing robot kinematics")

+        observation = raw_observation.copy()
+
        if self.use_ik_solution and "IK_solution" in self.transition.get(TransitionKey.COMPLEMENTARY_DATA):
            q_raw = self.transition.get(TransitionKey.COMPLEMENTARY_DATA)["IK_solution"]
        else:
@@ -311,10 +313,12 @@ class InverseKinematicsEEToJoints(RobotActionProcessorStep):
                "Missing required end-effector pose components: ee.x, ee.y, ee.z, ee.wx, ee.wy, ee.wz, ee.gripper_pos must all be present in action"
            )

-        observation = self.transition.get(TransitionKey.OBSERVATION).copy()
-        if observation is None:
+        raw_observation = self.transition.get(TransitionKey.OBSERVATION)
+        if raw_observation is None:
            raise ValueError("Joints observation is require for computing robot kinematics")

+        observation = raw_observation.copy()
+
        q_raw = np.array(
            [float(v) for k, v in observation.items() if isinstance(k, str) and k.endswith(".pos")],
            dtype=float,
@@ -391,13 +395,15 @@ class GripperVelocityToJoint(RobotActionProcessorStep):
    discrete_gripper: bool = False

    def action(self, action: RobotAction) -> RobotAction:
-        observation = self.transition.get(TransitionKey.OBSERVATION).copy()
+        raw_observation = self.transition.get(TransitionKey.OBSERVATION)

        gripper_vel = action.pop("ee.gripper_vel")

-        if observation is None:
+        if raw_observation is None:
            raise ValueError("Joints observation is require for computing robot kinematics")

+        observation = raw_observation.copy()
+
        q_raw = np.array(
            [float(v) for k, v in observation.items() if isinstance(k, str) and k.endswith(".pos")],
            dtype=float,
@@ -583,10 +589,12 @@ class InverseKinematicsRLStep(ProcessorStep):
                "Missing required end-effector pose components: ee.x, ee.y, ee.z, ee.wx, ee.wy, ee.wz, ee.gripper_pos must all be present in action"
            )

-        observation = new_transition.get(TransitionKey.OBSERVATION).copy()
-        if observation is None:
+        raw_observation = new_transition.get(TransitionKey.OBSERVATION)
+        if raw_observation is None:
            raise ValueError("Joints observation is require for computing robot kinematics")

+        observation = raw_observation.copy()
+
        q_raw = np.array(
            [float(v) for k, v in observation.items() if isinstance(k, str) and k.endswith(".pos")],
            dtype=float,
@@ -240,6 +240,7 @@ Using JSON config file:

 import abc
 import logging
+import os
 import shutil
 import sys
 from dataclasses import dataclass, field
@@ -384,24 +385,35 @@ def _resolve_io_paths(
    return output_repo_id, input_path, output_path


+def _is_in_place(input_path: Path, output_path: Path) -> bool:
+    """Whether both paths point to the same dataset directory.
+
+    Uses os.path.samefile (device+inode) which is robust to case-insensitive filesystems, hardlinks
+    and symlinks.
+    """
+    try:
+        return os.path.samefile(input_path, output_path)
+    except OSError:
+        return False
+
+
 def get_output_path(
    repo_id: str,
    new_repo_id: str | None,
    root: Path | str | None,
    new_root: Path | str | None,
-) -> tuple[str, Path]:
+) -> tuple[str, Path, Path | None]:
    output_repo_id, input_path, output_path = _resolve_io_paths(repo_id, new_repo_id, root, new_root)

-    # In case of in-place modification, create a backup of the original dataset (if it exists)
-    if output_path == input_path:
+    # In case of in-place modification, create a backup of the original dataset (if it exists).
+    backup_path: Path | None = None
+    if _is_in_place(input_path, output_path):
        backup_path = input_path.with_name(input_path.name + "_old")
-
-        if input_path.exists():
        if backup_path.exists():
            shutil.rmtree(backup_path)
        shutil.move(input_path, backup_path)

-    return output_repo_id, output_path
+    return output_repo_id, output_path, backup_path


 def handle_delete_episodes(cfg: EditDatasetConfig) -> None:
@@ -412,7 +424,7 @@ def handle_delete_episodes(cfg: EditDatasetConfig) -> None:
        raise ValueError("episode_indices must be specified for delete_episodes operation")

    dataset = LeRobotDataset(cfg.repo_id, root=cfg.root)
-    output_repo_id, output_dir = get_output_path(
+    output_repo_id, output_dir, backup_path = get_output_path(
        cfg.repo_id,
        new_repo_id=cfg.new_repo_id,
        root=cfg.root,
@@ -420,8 +432,8 @@ def handle_delete_episodes(cfg: EditDatasetConfig) -> None:
    )

    # In case of in-place modification, make the dataset point to the backup directory
-    if output_dir == dataset.root:
-        dataset.root = dataset.root.with_name(dataset.root.name + "_old")
+    if backup_path is not None:
+        dataset.root = backup_path

    logging.info(f"Deleting episodes {cfg.operation.episode_indices} from {cfg.repo_id}")
    new_dataset = delete_episodes(
@@ -525,7 +537,7 @@ def handle_remove_feature(cfg: EditDatasetConfig) -> None:
        raise ValueError("feature_names must be specified for remove_feature operation")

    dataset = LeRobotDataset(cfg.repo_id, root=cfg.root)
-    output_repo_id, output_dir = get_output_path(
+    output_repo_id, output_dir, backup_path = get_output_path(
        cfg.repo_id,
        new_repo_id=cfg.new_repo_id,
        root=cfg.root,
@@ -533,8 +545,8 @@ def handle_remove_feature(cfg: EditDatasetConfig) -> None:
    )

    # In case of in-place modification, make the dataset point to the backup directory
-    if output_dir == dataset.root:
-        dataset.root = dataset.root.with_name(dataset.root.name + "_old")
+    if backup_path is not None:
+        dataset.root = backup_path

    logging.info(f"Removing features {cfg.operation.feature_names} from {cfg.repo_id}")
    new_dataset = remove_feature(
@@ -671,7 +683,7 @@ def handle_recompute_stats(cfg: EditDatasetConfig) -> None:
        cfg.new_root,
        default_new_repo_id=f"{cfg.repo_id}_recomputed_stats",
    )
-    in_place = output_root == input_root
+    in_place = _is_in_place(input_root, output_root)

    if in_place and not cfg.operation.overwrite:
        raise ValueError(
@@ -731,7 +743,7 @@ def handle_reencode_videos(cfg: EditDatasetConfig) -> None:
        cfg.new_root,
        default_new_repo_id=f"{cfg.repo_id}_reencoded",
    )
-    in_place = output_root == input_root
+    in_place = _is_in_place(input_root, output_root)

    if in_place and not cfg.operation.overwrite:
        raise ValueError(
@@ -243,9 +243,17 @@ def train(cfg: TrainPipelineConfig, accelerator: "Accelerator | None" = None):
        # Accelerate auto-detects the device based on the available hardware and ignores the policy.device setting.
        # Force the device to be CPU when the active config's device is set to CPU (works for both policy and reward model training).
        force_cpu = cfg.trainable_config.device == "cpu"
-        # Drive Accelerate's autocast from policy.dtype (bf16/fp16 activate it; float32/absent -> launcher default).
+        # Drive Accelerate's autocast from policy.dtype (bf16/fp16 activate it; float32 -> full precision).
+        has_policy_dtype = hasattr(cfg.trainable_config, "dtype")
        policy_dtype = getattr(cfg.trainable_config, "dtype", None)
        mixed_precision = {"bfloat16": "bf16", "float16": "fp16", "float32": "no"}.get(policy_dtype)
+        # Policies without a `dtype` field fall back to `use_amp`, which would otherwise be
+        # silently ignored here while lerobot-eval honors it. Follow torch.autocast's default
+        # for the configured device so training and evaluation use the same precision.
+        if not has_policy_dtype and getattr(cfg.trainable_config, "use_amp", False):
+            device_type = torch.device(cfg.trainable_config.device).type
+            autocast_dtype = torch.get_autocast_dtype(device_type)
+            mixed_precision = {torch.bfloat16: "bf16", torch.float16: "fp16"}[autocast_dtype]
        accelerator = Accelerator(
            step_scheduler_with_optimizer=False,
            mixed_precision=mixed_precision,
@@ -17,9 +17,14 @@
 import pytest

 from lerobot.configs import FeatureType, PipelineFeatureType, PolicyFeature
+from lerobot.processor.converters import create_transition
 from lerobot.robots.so_follower.robot_kinematic_processor import (
+    EEReferenceAndDelta,
    ForwardKinematicsJointsToEEAction,
    ForwardKinematicsJointsToEEObservation,
+    GripperVelocityToJoint,
+    InverseKinematicsEEToJoints,
+    InverseKinematicsRLStep,
 )

 MOTOR_NAMES = ["shoulder_pan", "shoulder_lift", "elbow_flex", "wrist_flex", "wrist_roll", "gripper"]
@@ -43,3 +48,38 @@ def test_fk_feature_schema(step_cls, bucket, feature_type):
    out = step_cls(kinematics=None, motor_names=MOTOR_NAMES).transform_features(features)[bucket]
    assert set(out) == EE_KEYS
    assert {feature.type for feature in out.values()} == {feature_type}
+
+
+EE_ACTION = dict.fromkeys(EE_KEYS, 0.0)
+
+
+@pytest.mark.parametrize(
+    ("step", "action"),
+    [
+        (
+            EEReferenceAndDelta(kinematics=None, end_effector_step_sizes={}, motor_names=MOTOR_NAMES),
+            dict(EE_ACTION),
+        ),
+        (InverseKinematicsEEToJoints(kinematics=None, motor_names=MOTOR_NAMES), dict(EE_ACTION)),
+        (GripperVelocityToJoint(), {**EE_ACTION, "ee.gripper_vel": 0.0}),
+        (InverseKinematicsRLStep(kinematics=None, motor_names=MOTOR_NAMES), dict(EE_ACTION)),
+    ],
+    ids=[
+        "ee_reference_and_delta",
+        "inverse_kinematics_ee_to_joints",
+        "gripper_velocity_to_joint",
+        "inverse_kinematics_rl_step",
+    ],
+)
+def test_missing_observation_raises_value_error(step, action):
+    """A transition without an observation must surface the documented ValueError.
+
+    `RobotProcessorPipeline.process_action` builds its transition with
+    `create_transition(action=...)`, which sets `TransitionKey.OBSERVATION` to None.
+    These steps used to call `.copy()` on that before the None check, so the guard
+    below them was unreachable and an AttributeError escaped instead.
+    """
+    transition = create_transition(action=action)
+
+    with pytest.raises(ValueError, match="Joints observation"):
+        step(transition)
Author	SHA1	Message	Date
Steven Palma	fdd9d92349	feat(policies): early stopping + termination	2026-07-31 16:53:37 +02:00
Thomas Landeg	50192947fd	perf(pi0fast): stop FAST decoding at the end-of-action marker The decode loop always runs all max_decoding_steps (256) tokens, but detokenize_actions() cuts the output at the first "\|", so most of them get generated and then thrown away. On LIBERO the marker lands around token 25-35. Stopping there gives the same actions ~4x faster end to end. Checked on libero_10: 50/50 episodes came out identical to the old path, same success and same state trajectories.	2026-07-31 16:49:34 +02:00
Steven Palma	99443a936d	fix(train): honor policy.use_amp when the policy has no dtype field (#4274 ) * fix(train): honor policy.use_amp when the policy has no dtype field Since the Accelerate migration, accelerator.autocast() has been a no-op for policies that do not expose a string dtype field (act, diffusion, multi_task_dit, ...): PR #3912 wires mixed_precision from policy.dtype, so these policies resolve to None and always train in full fp32 regardless of --policy.use_amp=true. Meanwhile lerobot-eval does honor use_amp, and PreTrainedConfig documents the flag as applying to training and evaluation. Fall back to use_amp when no dtype field is present: bf16 where supported, fp16 otherwise (matching torch.autocast's cuda default used by eval). Measured on multi_task_dit / pusht, batch 256, H100: peak allocated drops from ~75 GiB (fp32) to ~46.5 GiB under bf16 autocast. * fix(train): conservative check --------- Co-authored-by: Reece O'Mahoney <reece.omahoney3@gmail.com>	2026-07-31 16:46:54 +02:00
Steven Palma	7a3298ea26	fix(libero): don't reset inside step() on termination (#4273 ) * fix(libero): don't reset inside step() on termination LiberoEnv.step() called self.reset() when an episode terminated. Gymnasium's vector envs default to AutoresetMode.NEXT_STEP, so the vector env resets the sub-env again on the following step -- every termination paid two full resets. The self-reset was also pure waste: `observation` is built from the terminal raw_obs before it, so the reset's return value was discarded outright. Worse, LiberoEnv.reset() advances init_state_id by _reset_stride, so the extra reset skipped an initial state on every episode. Measured with a counting subclass under SyncVectorEnv (gymnasium 1.3.0, terminating every 4 steps over a 14-step loop): n_envs=1: 3 terminations -> 6 resets = 1 initial + 3 self + 2 autoreset n_envs=2: 6 terminations -> 12 resets = 2 initial + 6 self + 4 autoreset (the final termination's autoreset does not fire before the loop ends) Each LiberoEnv.reset() is a full LIBERO reset plus num_steps_wait settle steps, so on the current default reset path this duplicates roughly 1.3 s per termination. Standalone (non-vectorised) users must now call reset() themselves after termination, which is the Gymnasium contract. * test(libero): pin the autoreset default, not the enum's spelling The previous assertion checked `AutoresetMode.NEXT_STEP.value == "NextStep"`, which is a naming detail. If a future Gymnasium flipped the vector-env default to SAME_STEP, that assertion would still pass and the bug this fixes would come back as a missing reset instead of a double one. Assert the observable default instead. Verified on gymnasium 1.1.1 (the floor in pyproject) and 1.3.0, for both SyncVectorEnv and AsyncVectorEnv. Negative control: constructing with autoreset_mode=SAME_STEP fails the new assertion and passes the old one. Also document why `env._env = inner` is not redundant with the monkeypatched factory: `LiberoEnv.__init__` defers simulator creation, so pre-binding keeps `_ensure_env()` a no-op and avoids a stray `reset()` on the mock. * test(libero): drop the redundant `env._env` prebind @noron12234 flagged this as redundant. Their stated reason was wrong -- `__init__` defers simulator creation (`self._env = None`, libero.py:180), so the monkeypatched factory has not been called by the time it returns -- but the conclusion holds: `_ensure_env()` pulls the same `inner` from the mocked factory on first `step()`. I claimed the prebind was load-bearing because a stray `reset()` would pollute the tests' call counts. That was wrong and I had not run it. Ran both variants against the real class: the stray reset lands on `inner.reset`, which no assertion touches, and both tests pass with or without the line. Dropping it. * refactor(env): add explicit NEXT_STEP * fix(style): pre-commit --------- Co-authored-by: Dimitar Dimitrov <dvdimitrov13@gmail.com> Co-authored-by: Dimitar Dimitrov <60075474+dvdimitrov13@users.noreply.github.com>	2026-07-31 16:39:49 +02:00
Steven Palma	2d8f5f314e	feat(env): config to skip the discarded scene rebuild on reset Libero (#4272 ) * perf(libero): skip the discarded scene rebuild on reset LIBERO's OffScreenRenderEnv defaults to hard_reset=True, so every reset() frees the MjSim, re-serialises the scene with model.get_xml(), recompiles it with MjSim.from_xml_string(), constructs a fresh offscreen GL context and re-wires every observable. When init states are in use, LiberoEnv.reset() immediately calls set_init_state(), which overwrites the whole sim state -- so all of that work is discarded. This passes hard_reset=not init_states instead. Without init states the randomisation reset() performs is the only thing placing the objects, so the hard reset is kept. Measured on an RTX 3060 Ti (EGL, robosuite 1.4.0, mujoco 3.2.7, 256x256 x2 cameras), through LiberoEnv.reset(), fresh env per arm: suite hard soft saved libero_spatial 1697 ms 233 ms 1464 ms libero_object 1394 ms 172 ms 1222 ms libero_goal 1177 ms 164 ms 1013 ms libero_10 1528 ms 207 ms 1321 ms Equivalence ----------- Immediately after set_init_state, qpos, qvel, ctrl and act are bit-identical between the two paths on every suite tested. After the 10 settle steps that reset() runs, 9 of 41 qpos entries differ: robot0_joint1..7 (<= 2.4e-5 rad) and gripper0_finger_joint1/2 (<= 2.1e-4 rad). No object joint differs on any suite. The drift is driven by the gripper component of the settle action ([0,0,0,0,0,0,-1]); replacing it with zeros keeps the two paths bit-identical for 12 further steps, and with num_steps_wait=0 there is no divergence at all. Wrist-camera pixels can differ by up to ~87/255, because a sub-millimetre finger displacement crosses rasterisation boundaries at 256x256. The pixel metric badly overstates the physical difference here; 2.1e-4 rad is 0.012 degrees. So this is not bit-identical end to end, and reviewers should decide whether 0.012 degrees of gripper drift is acceptable for the benchmark. It does not change object placement, which is what the fixed init states exist to control. * refactor(env): config param libero + docs --------- Co-authored-by: Dimitar Dimitrov <dvdimitrov13@gmail.com>	2026-07-31 16:28:12 +02:00
Lin Junrong	732a12108e	fix(so_follower): check the observation for None before copying it (#4255 ) Four kinematic processor steps read the observation as observation = self.transition.get(TransitionKey.OBSERVATION).copy() if observation is None: raise ValueError("Joints observation is require for computing robot kinematics") so `.copy()` runs first and the guard below it is unreachable. A transition without an observation raises `AttributeError: 'NoneType' object has no attribute 'copy'` instead of the intended message. That transition is not hypothetical: `RobotProcessorPipeline.process_action` builds one with `create_transition(action=action)`, which sets `TransitionKey.OBSERVATION` to None. Reads the value first, checks it, then copies. Affects EEReferenceAndDelta, InverseKinematicsEEToJoints, GripperVelocityToJoint and InverseKinematicsRLStep. Adds a parametrised regression test covering all four; each fails with the AttributeError if the fix is reverted. Co-authored-by: Steven Palma <imstevenpmwork@ieee.org>	2026-07-31 16:12:18 +02:00
Caroline Pascal	29fcf057dc	fix(edit-dataset): redirect dataset.root via backup_path from get_output_path (#4271 ) * fix(edit-dataset): redirect dataset.root via backup_path returned from get_output_path The in-place backup logic compared `output_dir` (run through `.resolve()`) to `dataset.root` (unresolved), so when `HF_LEROBOT_HOME` was a symlink the swap to the `_old` backup never fired and `_copy_and_reindex_videos` then read from the now-empty output directory. Have `get_output_path` return the backup path directly so callers don't rely on path equality. * feat(samefile): making same file detection more robust using os.path.samefile --------- Co-authored-by: Reece O'Mahoney <reece.omahoney3@gmail.com>	2026-07-31 16:11:57 +02:00