A sequential pipeline for processing data, integrated with the Hugging Face Hub. This class chains together multiple `ProcessorStep` instances to

Processor step to move all tensors within an `EnvTransition` to a specified device and optionally cast their floating-point data type. T

A processor step that applies normalization to observations and actions in a transition. This class uses the logic from `_NormalizationMixin

A composite processor step that adds a batch dimension to the entire environment transition. This step combines individual processors for ac

Processor step to tokenize a natural language task description. This step extracts a task string from the `complementary_data` of an `EnvTra

Mock tokenizer for testing that mimics transformers tokenizer interface.

Configuration for Real Time Chunking (RTC) inference. RTC improves real-time inference by treating chunk generation as an inpainting problem,

Configuration class for OpenCV-based camera devices or video files. This class provides configuration options for cameras accessed through OpenCV

For each transform, the following parameters are available: weight: This represents the multinomial probability (with no replacement)

Mock pipeline step for testing - demonstrates best practices. This example shows the proper separation: - JSON-serializable attributes (name,

A processor step that renames keys in an observation dictionary. This step is useful for creating a standardized data interface by mapping k

Real-Time Chunking processor for action chunking policies. This class implements RTC techniques including velocity calculation, prefix attent

A processor step that applies unnormalization to observations and actions. This class inverts the normalization process, scaling data back t

Processes standard Gymnasium observations into the LeRobot format. This step handles both image and state data from a typical observation di

Manages camera interactions using OpenCV for efficient frame recording. This class provides a high-level interface to connect to, configure,

The FeetechMotorsBus class allows to efficiently read and write to the attached motors. It relies on the python feetech sdk to communicate wi

This class abstract away the initialisation of processes or/and threads to save images on disk asynchronously, which is critical to control a

The Dynamixel implementation for a MotorsBus. It relies on the python dynamixel sdk to communicate with the motors. For more info, see the Dy

Manages interactions with Intel RealSense cameras for frame and depth recording. This class provides an interface similar to `OpenCVCamera`

Computes and stores the average and current value Adapted from https://github.com/pytorch/examples/blob/main/imagenet/main.py

Configuration class for Intel RealSense cameras. This class provides specialized configuration options for Intel RealSense cameras, including

Processor step to map a dictionary to a tensor action.

Exception raised when the device is not connected.

A class to compose image transforms based on configuration.

These transforms are all using standard torchvision.transforms.v2 You can find out how these transformations affect images here: https://

Mock step that requires a non-serializable parameter.

Maintains running statistics for batches of vectors, including mean, standard deviation, min, max, and approximate quantiles. Statistics

Processor step to map a policy action to a robot action.

Mock step demonstrating mixed JSON attributes and tensor state.

Robot kinematics using placo library for forward and inverse kinematics.

Value model config using the Pistar06 stack (SigLIP + Gemma).

Used by Physical Intelligence to train Pi0. Automatically scales warmup and decay steps if num_training_steps < num_decay_steps. This ensures

A helper class to track and log metrics over time. Usage pattern: ```python # initialize, potentially with non-zero initial step (e

Utility class to attach graceful shutdown signal handlers. The class exposes a shutdown_event attribute that is set when a shutdown signal is

Soft Actor-Critic (SAC) configuration. SAC is an off-policy actor-critic deep RL algorithm based on the maximum entropy reinforcement learnin

Thread-safe queue for managing action chunks in real-time control. This queue handles two types of action sequences: - Original actions: Used

A no-op processor step that returns the input transition and features unchanged. This can be useful as a placeholder or for debugging purposes.

Piper leader arm used as a teleoperator through Piper SDK CAN messages.

Computes desired joint positions from a target end-effector pose using inverse kinematics (IK). This step translates a Cartesian command (po

Multi-layer perceptron builder. Dynamically constructs a sequence of layers based on `hidden_dims`: 1) Linear (in_dim -> out_dim) 2)

PI0 OpenPI Policy for LeRobot.

Configuration class for Reachy 2 camera devices. This class provides configuration options for Reachy 2 cameras, supporting both the teleop a

Collects and manages debug information for RTC processing. This tracker stores debug information from recent denoising steps in a dictionary,

PI05 Policy for LeRobot.

Piper follower arm controlled through the Piper SDK (CAN).

Configuration for the Reward Classifier model.

ProcessorStep that encodes images and text with CLIP and generates stage and progress labels for SARM.

Randomly change the sharpness of an image or video. Similar to a v2.RandomAdjustSharpness with p=1 and a sharpness_factor sampled randomly. W

LeRobotDataset with streaming capabilities. This class extends LeRobotDataset to add streaming functionality, allowing data to be streamed ra

Container for debug information from a single denoising step. Attributes: step_idx (int): Step index/counter. x_t (Tensor | None)

ResNet style 1D convolutional block with FiLM modulation for conditioning.

Utility class to track FPS metrics over time.

Mock SARMConfig for testing processor methods.

Mock dataset metadata for testing processor.

Mock step that only implements the required __call__ method.

Configuration for a Piper follower arm controlled over CAN.

Apply a random subset of N transformations from a list of transformations. Args: transforms: list of transformations. p: represen

A processor step that ensures the 'task' description ends with a newline character. This step is necessary for certain tokenizers (e.g., Pal

Configuration class for the Action Chunking Transformers policy. Defaults are configured for training on bimanual Aloha tasks like "insertion" or

Clips the end-effector pose to predefined bounds and checks for unsafe jumps. This step ensures that the target end-effector pose remains wi

Tracks recent latencies and provides max/percentile queries. Args: maxlen (int | None): Optional sliding window size. If provided, only t

Exception raised when trying to look ahead in the future of a Backtrackable object.

Configuration for multiple Adam optimizers with different parameter groups. This creates a dictionary of Adam optimizers, each with its own hyper

Wrapper class around VLAFlowMatching model to train and run inference within LeRobot.

Adds state features (and optionally an image spec to test precedence).