lerobot使用文档

最新推荐文章于 2025-04-12 20:22:38 发布
最新推荐文章于 2025-04-12 20:22:38 发布
阅读量1.1k 收藏 15
点赞数 29
文章标签： 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33673253/article/details/145852265
版权

视频基准测试

问题

如何在以下几个方面找到最佳平衡:

  • 最大化随机访问时的加载速度
  • 最小化磁盘存储空间
  • 最大化策略的成功率
  • 在不同设备/平台上解码视频的兼容性(如视频播放器、网页浏览器)

如何编码视频?

  • 使用哪种视频编解码器(-vcodec)? h264、h265 还是 AV1?
  • 使用什么像素格式(-pix_fmt)? yuv444p 还是 yuv420p?
  • 压缩程度(-crf)如何? 无压缩用 0,中等压缩用 25 还是极端压缩用 50+?
  • 选择什么关键帧频率(-g)? 每 10 帧一个关键帧?

如何解码视频?

  • 使用哪个解码器? torchvision、torchaudio、ffmpegio、decord 还是 nvc?
  • 基准测试中请求时间戳时使用什么场景?(timestamps_mode)

变量

图像内容和尺寸
我们预计不同类型的数据集会需要不同的最优设置,比如来自模拟环境的图像、来自公寓的真实场景、工厂场景、户外场景,或者场景中有大量移动物体等。同样,加载时间可能不会随图像尺寸(分辨率)线性变化。
因此,我们在四个具有代表性的数据集上运行这个基准测试:

  • lerobot/pusht_image: (96 x 96 像素)简单几何形状的模拟环境,固定摄像头。
  • aliberts/aloha_mobile_shrimp_image: (480 x 640 像素)室内真实场景,移动摄像头。
  • aliberts/paris_street: (720 x 1280 像素)户外真实场景,移动摄像头。
  • aliberts/kitchen: (1080 x 1920 像素)室内真实场景,固定摄像头。

注意: 用于此基准测试的数据集需要是图像数据集,而不是视频数据集。

数据增强
如果我们使用各种数据增强来训练策略使其更加鲁棒(例如对颜色变化、压缩等更加鲁棒),我们可能需要重新进行这个基准测试并找到更好的设置。

编码参数

参数值
vcodeclibx264, libx265, libsvtav1
pix_fmtyuv444p, yuv420p
g1, 2, 3, 4, 5, 6, 10, 15, 20, 40, None
crf0, 5, 10, 15, 20, 25, 30, 40, 50, None

注意不同的视频编解码器可能会对 crf 值有不同的解释。换句话说,在一个编解码器中使用的相同值不一定会在另一个编解码器中产生相同的压缩级别。实际上,默认值(None)在不同的视频编解码器之间也不相同。重要的是,这种情况也适用于许多其他 ffmpeg 参数,比如指定关键帧频率的 g。

有关这些参数的完整列表和文档,请参见根据使用的视频编解码器查看 ffmpeg 文档:

  • h264: https://trac.ffmpeg.org/wiki/Encode/H.264
  • h265: https://trac.ffmpeg.org/wiki/Encode/H.265
  • AV1: https://trac.ffmpeg.org/wiki/Encode/AV1

解码参数

解码器
我们测试了 torchvision 的两个视频解码后端:

  • pyav (默认)
  • video_reader (需要从源代码构建 torchvision)

请求的时间戳
考虑到视频解码的工作方式,一旦加载了关键帧,后续帧的解码就会很快。
这当然会受到编码时 -g 参数的影响,该参数指定关键帧的频率。考虑到我们在机器人策略中的典型用例可能会在不同的随机位置请求几个时间戳,我们想要用以下场景复现这些用例:

  • 1_frame: 1 帧
  • 2_frames: 2 个连续帧(例如 [t, t + 1 / fps])
  • 6_frames: 6 个连续帧(例如 [t + i / fps for i in range(6)])

注意这与观看电影等典型用例有很大不同,在那种情况下,每一帧都是从头到尾按顺序加载的,使用较大的 -g 值是可以接受的。

此外,由于某些策略可能会请求相隔几帧的单个时间戳,我们还有以下场景:

  • 2_frames_4_space: 2 帧之间间隔 4 个连续帧(例如 [t, t + 5 / fps])

然而,由于 pyav 的视频解码实现方式,我们无法进行精确的定位,所以在实践中这个场景本质上与 6_frames 相同,因为 t 和 t + 5 / fps 之间的所有 6 帧都会被解码。

指标

数据压缩比(越低越好)
video_images_size_ratio 是编码视频占用的磁盘空间与原始图像占用的磁盘空间之比。例如,video_images_size_ratio=25% 意味着视频占用的磁盘空间比原始图像少 4 倍。

加载时间比(越低越好)
video_images_load_time_ratio 是从视频解码给定时间戳的帧所需时间与加载相同原始图像所需时间之比。越低越好。例如,video_images_load_time_ratio=200% 意味着从视频解码的速度比加载原始图像慢 2 倍。

平均均方误差(越低越好)
avg_mse 是每个解码帧与其对应原始图像之间的平均均方误差,在所有请求的时间戳上取平均,并除以图像中的像素数以便在切换到不同图像尺寸时具有可比性。

平均峰值信噪比(越高越好)
avg_psnr 衡量信号的最大可能功率与影响其表示保真度的噪声功率之比。更高的 PSNR 表示更好的质量。

平均结构相似性指数(越高越好)
avg_ssim 通过比较亮度、对比度和结构来评估图像的感知质量。SSIM 值范围从 -1 到 1,其中 1 表示完全相似。

这些指标无法衡量的一个方面是编码在各平台上的兼容性,特别是在网页浏览器上用于可视化目的。
h264、h265 和 AV1 都是常用的编解码器,应该不会造成问题。但是,色度二次采样(pix_fmt)格式可能会影响兼容性:

  • yuv420p 在各种平台上得到更广泛的支持,包括网页浏览器。
  • yuv444p 提供更高的色彩保真度,但可能不会得到如此广泛的支持。

基准测试的工作原理

基准测试在每个数据集的第一个回合上评估视频帧的编码和解码。

编码: 对于每个 vcodec 和 pix_fmt 组合,我们使用 g 和 crf 的默认值,然后改变其中一个值(要么是 g 要么是 crf)为指定值之一(我们不测试所有组合,因为这在计算上太过繁重)。
这给出了一组唯一的编码参数,用于对回合进行编码。

解码: 然后,对于每个唯一的编码,我们遍历解码参数 backend 和 timestamps_mode 的每种组合。对于每种组合,我们记录多个样本(由 --num-samples 指定)的指标。为了提高效率,这个过程是并行的,进程数可以通过 --num-workers 控制。理想情况下,最好让 --num-samples 能被 --num-workers 整除。

中间结果保存在 csv 表格中,每个 vcodec 和 pix_fmt 组合一个表格。
然后将这些表格全部合并成一个用于分析的表格。

注意事项

我们尝试测量编码和解码最重要的参数。然而,出于计算原因,我们无法测试所有组合。

示例

要快速运行,你可以尝试这些参数:

python benchmark/video/run_video_benchmark.py \
    --output-dir outputs/video_benchmark \
    --repo-ids \
        lerobot/pusht_image \
        aliberts/aloha_mobile_shrimp_image \
    --vcodec libx264 libx265 \
    --pix-fmt yuv444p yuv420p \
    --g 2 20 None \
    --crf 10 40 None \
    --timestamps-modes 1_frame 2_frames \
    --backends pyav video_reader \
    --num-samples 5 \
    --num-workers 5 \
    --save-frames 0

结果

复现

我们使用以下参数运行基准测试:

# h264 和 h265 编码
python benchmark/video/run_video_benchmark.py \
    --output-dir outputs/video_benchmark \
    --repo-ids \
        lerobot/pusht_image \
        aliberts/aloha_mobile_shrimp_image \
        aliberts/paris_street \
        aliberts/kitchen \
    --vcodec libx264 libx265 \
    --pix-fmt yuv444p yuv420p \
    --g 1 2 3 4 5 6 10 15 20 40 None \
    --crf 0 5 10 15 20 25 30 40 50 None \
    --timestamps-modes 1_frame 2_frames 6_frames \
    --backends pyav video_reader \
    --num-samples 50 \
    --num-workers 5 \
    --save-frames 1

# av1 编码(仅兼容 yuv420p 和 pyav 解码器)
python benchmark/video/run_video_benchmark.py \
    --output-dir outputs/video_benchmark \
    --repo-ids \
        lerobot/pusht_image \
        aliberts/aloha_mobile_shrimp_image \
        aliberts/paris_street \
        aliberts/kitchen \
    --vcodec libsvtav1 \
    --pix-fmt yuv420p \
    --g 1 2 3 4 5 6 10 15 20 40 None \
    --crf 0 5 10 15 20 25 30 40 50 None \
    --timestamps-modes 1_frame 2_frames 6_frames \
    --backends pyav \
    --num-samples 50 \
    --num-workers 5 \
    --save-frames 1

完整结果可在这里查看

LeRobotDataset 选择的参数

考虑到这些结果,我们选择了我们认为最好的编码参数集:

  • vcodec: libsvtav1
  • pix-fmt: yuv420p
  • g: 2
  • crf: 30

由于我们使用 av1 编码,我们选择 pyav 解码器,因为 video_reader 不支持它(而且 pyav 不需要自定义构建 torchvision)。

总结

这些表格显示了 g=2 和 crf=30 时的结果,使用 timestamps-modes=6_frames 和 backend=pyav

video_images_size_ratiovcodecpix_fmt
libx264libx265libsvtav1
repo_idyuv420pyuv444pyuv420pyuv444pyuv420p
lerobot/pusht_image16.97%17.58%18.57%18.86%22.06%
aliberts/aloha_mobile_shrimp_image2.14%2.11%1.38%1.37%5.59%
aliberts/paris_street2.12%2.13%1.54%1.54%4.43%
aliberts/kitchen1.40%1.39%1.00%1.00%2.52%
video_images_load_time_ratiovcodecpix_fmt
libx264libx265libsvtav1
repo_idyuv420pyuv444pyuv420pyuv444pyuv420p
lerobot/pusht_image6.455.191.902.122.47
aliberts/aloha_mobile_shrimp_image11.807.920.710.850.48
aliberts/paris_street2.212.050.360.490.30
aliberts/kitchen1.461.460.280.510.26
vcodecpix_fmt
libx264libx265libsvtav1
repo_idmetricyuv420pyuv444pyuv420pyuv444pyuv420p
lerobot/pusht_imageavg_mse2.90E-042.03E-043.13E-042.29E-042.19E-04
avg_psnr35.4437.0735.4937.3037.20
avg_ssim98.28%98.85%98.31%98.84%98.72%
aliberts/aloha_mobile_shrimp_imageavg_mse2.76E-042.59E-043.17E-043.06E-041.30E-04
avg_psnr35.9136.2135.8836.0940.17
avg_ssim95.19%95.18%95.00%95.05%97.73%
aliberts/paris_streetavg_mse6.89E-046.70E-044.03E-034.02E-033.09E-04
avg_psnr33.4833.6832.0532.1535.40
avg_ssim93.76%93.75%89.46%89.46%95.46%
aliberts/kitchenavg_mse2.50E-042.24E-044.28E-044.18E-041.53E-04
avg_psnr36.7337.3336.5636.7539.12
avg_ssim95.47%95.58%95.52%95.53%96.82%

视频基准测试说明

一、基准测试的意义

视频基准测试(run_video_benchmark.py)主要解决以下关键问题:

  1. 数据存储效率
  • 评估不同视频编码方案的压缩效率
  • 平衡存储空间与视频质量
  • 优化数据集的磁盘占用
  1. 加载性能优化
  • 测试不同解码方案的加载速度
  • 评估随机访问性能
  • 优化训练过程中的数据加载
  1. 跨平台兼容性
  • 确保在不同设备上的解码兼容性
  • 评估不同编解码器的支持程度
  • 验证在网页浏览器中的可视化效果

二、测试参数说明

1. 编码参数

BASE_ENCODING = {
    "vcodec": "libx264",     # 视频编码器
    "pix_fmt": "yuv444p",    # 像素格式
    "g": 2,                  # 关键帧间隔
    "crf": None,            # 压缩质量
}

2. 测试场景

DATASETS = [
    "lerobot/pusht_image",                # 96x96 模拟环境
    "aliberts/aloha_mobile_shrimp_image", # 480x640 室内场景
    "aliberts/paris_street",              # 720x1280 户外场景
    "aliberts/kitchen"                    # 1080x1920 室内场景
]

TIMESTAMPS_MODES = [
    "1_frame",            # 单帧加载
    "2_frames",           # 连续2帧
    "2_frames_4_space",   # 间隔4帧的2帧
    "6_frames"           # 连续6帧
]

三、性能指标

  1. 存储效率
# 计算压缩比
video_images_size_ratio = video_size_bytes / images_size_bytes
  1. 加载性能
# 计算加载时间比
video_images_load_time_ratio = avg_load_time_video_ms / avg_load_time_images_ms
  1. 图像质量
# 计算质量指标
mse = mean_squared_error(original_frames, decoded_frames)
psnr = peak_signal_noise_ratio(original_frames, decoded_frames)
ssim = structural_similarity(original_frames, decoded_frames)

四、在项目中的作用

  1. 数据集优化
  • 指导数据集的视频编码配置选择
  • 优化数据集的存储效率
  • 确保数据加载性能
  1. 训练加速
  • 减少数据加载瓶颈
  • 优化批处理数据读取
  • 提高训练效率
  1. 部署支持
  • 确保模型在不同平台上的可用性
  • 优化在线推理的数据加载
  • 支持web端可视化需求

五、使用示例

  1. 运行基准测试:
python benchmarks/video/run_video_benchmark.py \
    --repo-ids lerobot/pusht_image \
    --vcodecs libx264 libx265 libsvtav1 \
    --pix-fmts yuv420p yuv444p \
    --num-samples 50
  1. 分析测试结果:
python benchmarks/video/plot_results.py \
    --results-dir results/benchmark_video
  1. 应用最佳实践:
# 使用测试验证的最优参数
encoding_config = {
    "vcodec": "libsvtav1",  # 最佳编码器
    "pix_fmt": "yuv420p",   # 最佳像素格式
    "g": 2,                 # 最优关键帧间隔
    "crf": 30              # 最佳压缩质量
}

这个基准测试工具帮助我们在数据效率、加载性能和质量之间找到最佳平衡,对整个项目的数据处理和训练效率有重要影响。

LeRobot 自定义策略开发指南

一、策略接入基础

1. 目录结构

lerobot/
  ├── common/
  │   └── policies/
  │       ├── base.py          # 基础策略类
  │       ├── normalize.py     # 数据归一化实现
  │       ├── act/            # ACT策略实现
  │       ├── diffusion/      # Diffusion策略实现
  │       └── your_policy/    # 你的自定义策略
  └── configs/
      └── policy/
          ├── act.yaml       # ACT配置
          ├── diffusion.yaml # Diffusion配置
          └── your_policy.yaml # 你的策略配置

2. 基础类继承

# 来自 lerobot/common/policies/act/modeling_act.py
class YourPolicy(BasePolicy, PyTorchModelHubMixin):
    """自定义策略类"""
    name = "your_policy"
    
    def __init__(self, config, dataset_stats=None):
        super().__init__()
        self.config = config
        
        # 1. 构建归一化层
        self.normalize_inputs = Normalize(
            config.input_shapes,
            config.input_normalization_modes,
            dataset_stats
        )
        self.normalize_targets = Normalize(
            config.output_shapes,
            config.output_normalization_modes,
            dataset_stats
        )
        self.unnormalize_outputs = Unnormalize(
            config.output_shapes,
            config.output_normalization_modes,
            dataset_stats
        )
        
        # 2. 构建网络组件
        self.build_networks()

3. 配置类定义

# 来自 lerobot/common/policies/act/configuration_act.py
@dataclass
class YourPolicyConfig:
    """策略配置类"""
    # 输入输出配置
    input_shapes: dict
    output_shapes: dict
    input_normalization_modes: dict
    output_normalization_modes: dict
    
    # 网络架构配置
    vision_backbone: str = "resnet18"
    pretrained_backbone_weights: str = None
    dim_model: int = 512
    n_heads: int = 8
    
    # 训练配置
    dropout: float = 0.1
    learning_rate: float = 1e-4

二、数据集处理

1. 数据集格式

# 来自 lerobot/common/datasets/lerobot_dataset.py
dataset = {
    "hf_dataset": {  # Hugging Face dataset格式
        "observation.image": VideoFrame,  # 视频帧
        "observation.state": List[float32],  # 状态向量
        "action": List[float32],  # 动作向量
        "episode_index": int64,  # 回合索引
        "frame_index": int64,  # 帧索引
        "timestamp": float32,  # 时间戳
        "next.done": bool,  # 回合结束标志
        "index": int64  # 全局索引
    },
    "episode_data_index": {
        "from": Tensor[int64],  # 回合起始索引
        "to": Tensor[int64]  # 回合结束索引
    }
}

2. 视频编码最佳实践

# 来自 lerobot/common/datasets/video_utils.py
def encode_video_frames(frames, output_path, fps=30):
    """将图像帧编码为视频"""
    encoding = {
        "vcodec": "libsvtav1",  # 最佳编解码器
        "pix_fmt": "yuv420p",   # 最佳像素格式
        "g": 2,                 # 关键帧间隔
        "crf": 30              # 压缩质量
    }

3. 数据增强配置

# 来自 lerobot/common/datasets/factory.py
def get_image_transforms(cfg):
    """获取图像增强配置"""
    transforms = []
    
    if cfg.training.image_transforms.enable:
        transforms.extend([
            v2.ColorJitter(
                brightness=cfg.brightness,
                contrast=cfg.contrast,
                saturation=cfg.saturation,
                hue=cfg.hue
            ),
            v2.RandomAdjustSharpness(
                sharpness_factor=cfg.sharpness,
                p=cfg.sharpness_prob
            )
        ])
    
    return v2.Compose(transforms)

三、策略实现示例

1. ACT策略

# 来自 lerobot/common/policies/act/modeling_act.py
class ACTPolicy(BasePolicy):
    """ACT策略实现"""
    def __init__(self, config):
        super().__init__()
        self.config = config
        
        # 构建编码器
        self.encoder = self._build_encoder()
        self.decoder = self._build_decoder()
        
        # 构建Transformer
        self.transformer = self._build_transformer()
    
    def forward(self, batch):
        # 归一化输入
        normalized = self.normalize_inputs(batch)
        
        # 特征提取
        features = self.encoder(normalized)
        
        # Transformer处理
        output = self.transformer(features)
        
        # 解码动作
        actions = self.decoder(output)
        
        return actions

2. Diffusion策略

# 来自 lerobot/common/policies/diffusion/modeling_diffusion.py
class DiffusionPolicy(BasePolicy):
    """Diffusion策略实现"""
    def __init__(self, config):
        super().__init__()
        self.config = config
        
        # 构建扩散模型
        self.diffusion = DiffusionModel(config)
        
        # 构建编码器
        self.encoder = self._build_encoder()
    
    def forward(self, batch):
        # 归一化输入
        normalized = self.normalize_inputs(batch)
        
        # 特征提取
        features = self.encoder(normalized)
        
        # 扩散过程
        actions = self.diffusion(features)
        
        return actions

四、训练和评估

1. 训练配置

# 来自 lerobot/configs/policy/act.yaml
training:
  offline_steps: 100000
  eval_freq: 20000
  save_freq: 20000
  
  batch_size: 8
  lr: 1e-5
  weight_decay: 1e-4
  grad_clip_norm: 10
  
  delta_timestamps:
    action: "[i / ${fps} for i in range(${policy.chunk_size})]"

2. 评估配置

eval:
  n_episodes: 50
  batch_size: 50

五、性能优化

1. 数据加载优化

  • 使用视频格式存储图像序列
  • 选择最优的视频编码参数
  • 使用多进程数据加载

2. 训练优化

  • 使用混合精度训练
  • 梯度裁剪和归一化
  • 使用适当的批次大小

3. 推理优化

  • 模型量化
  • TensorRT加速
  • 批处理推理

六、策略训练与验证

1. 基本训练流程

使用训练脚本进行训练:

python lerobot/scripts/train.py \
    policy=your_policy \  # 你的策略配置
    env=pusht \          # 使用的环境
    dataset_repo_id=lerobot/pusht  # 训练数据集

训练输出目录结构:

outputs/train/2024-XX-XX/XX-XX-XX_env_policy_default/
  └── checkpoints/
      ├── 000250/                    # 训练步数检查点
      │   ├── pretrained_model/      # Hugging Face预训练模型目录
      │   │   ├── config.json       # 模型配置
      │   │   ├── config.yaml       # 完整Hydra配置
      │   │   ├── model.safetensors # 模型权重
      │   │   └── README.md         # 模型说明
      │   └── training_state.pth    # 优化器/调度器状态

2. 恢复训练

从检查点恢复训练:

python lerobot/scripts/train.py \
    hydra.run.dir=your/original/experiment/dir \
    resume=true

3. 策略评估

使用评估脚本进行验证:

python lerobot/scripts/eval.py \
    -p outputs/train/checkpoints/last/pretrained_model \
    eval.n_episodes=10 \
    eval.batch_size=10

4. 性能监控

启用 WandB 监控训练过程:

python lerobot/scripts/train.py \
    policy=your_policy \
    wandb.enable=true

主要监控指标包括:

  • 训练损失
  • 评估成功率
  • 模型预测准确度
  • 资源使用情况

5. 数据集可视化

使用可视化工具检查数据:

python lerobot/scripts/visualize_dataset.py \
    --repo-id lerobot/pusht \
    --episode-index 0

这将在 rerun.io 中显示:

  • 相机流
  • 机器人状态
  • 动作序列

这些工具和流程可以帮助你有效地训练和验证自定义策略。需要了解更多细节吗？

七、数据格式转换示例

以 fourier_format.py 为例说明如何处理和转换原始数据为 LeRobot 标准格式:

1. 数据格式要求

原始数据需要包含以下内容(HDF5格式):

# 必需的数据字段
required_fields = {
    "/action/robot": np.ndarray,  # 机器人动作数据
    "/action/pose": np.ndarray,   # 末端位姿数据
    "/action/hand": np.ndarray,   # 手部动作数据
    "/state/robot": np.ndarray,   # 机器人状态
    "/state/pose": np.ndarray,    # 末端位姿状态
    "/state/hand": np.ndarray,    # 手部状态
}

2. 数据转换流程

  1. 格式检查:
def check_format(raw_dir):
    """检查原始数据格式是否符合要求"""
    hdf5_paths = list(raw_dir.glob("episode_*.hdf5"))
    for hdf5_path in hdf5_paths:
        with h5py.File(hdf5_path, "r") as data:
            # 检查必需字段
            assert "/action" in data
            assert "/state/robot" in data
            assert "/state/pose" in data
            assert "/state/hand" in data
            
            # 检查数据维度
            num_action_frames = data["/action/robot"].shape[0]
            num_state_frames = data["/state/robot"].shape[0]
  1. 视频编码:
def encode_video(image_dir, video_dir, episode_id, camera, encoding, fps):
    """将图像序列编码为视频"""
    # 1. 准备临时目录
    tmp_dir = video_dir / "tmp"
    tmp_dir.mkdir(parents=True, exist_ok=True)
    
    # 2. 复制并重命名图像
    for i, image_path in enumerate(image_paths):
        tmp_path = tmp_dir / f"frame_{i:06d}.png"
        shutil.copy(image_path, tmp_path)
        
    # 3. 编码视频
    video_path = video_dir / f"episode_{episode_id}" / f"{camera}.mp4"
    encode_video_frames(tmp_dir, video_path, fps, "libx264")
  1. 数据加载和转换:
def load_from_raw(raw_dir, videos_dir, fps, video):
    """加载并转换原始数据"""
    ep_dicts = []
    for ep_idx, ep_path in enumerate(hdf5_files):
        with h5py.File(ep_path, "r") as ep:
            # 合并状态数据
            state = torch.from_numpy(np.concatenate([
                ep["/state/robot"][:], 
                ep["/state/pose"][:], 
                ep["/state/hand"][:]
            ], axis=1))
            
            # 合并动作数据
            action = torch.from_numpy(np.concatenate([
                ep["/action/robot"][:],
                ep["/action/hand"][:]
            ], axis=1))
            
            # 处理图像数据
            for camera in get_cameras(ep_path):
                if video:
                    # 编码为视频
                    fname = encode_video(...)
                else:
                    # 保存为图像序列
                    imgs_array = get_imgs_array(...)

3. 使用方式

将原始数据转换为 LeRobot 格式:

# 1. 准备路径
raw_dir = Path("path/to/raw/data")
videos_dir = Path("path/to/output/videos")

# 2. 执行转换
hf_dataset, episode_data_index, info = from_raw_to_lerobot_format(
    raw_dir=raw_dir,
    videos_dir=videos_dir,
    fps=30,                # 视频帧率
    video=True,           # 是否编码为视频
    use_qpos_action=True  # 使用关节角度作为动作
)

转换后的数据结构:

{
    "hf_dataset": {
        "observation.images.{camera}": VideoFrame,
        "observation.state": Tensor,
        "action": Tensor,
        "episode_index": Tensor,
        "frame_index": Tensor,
        "timestamp": Tensor,
        "next.done": Tensor
    },
    "episode_data_index": {
        "from": Tensor,
        "to": Tensor
    },
    "info": {
        "codebase_version": str,
        "fps": int,
        "video": bool,
        "encoding": str
    }
}

这个示例展示了如何将自定义格式的数据转换为 LeRobot 可用的标准格式。你可以参考这个实现来处理自己的数据格式。

LeRobot 测试目录说明文档

一、目录结构概览

tests/
  ├── data/                     # 测试数据集
  │   └── lerobot/             # LeRobot格式数据集
  │       ├── aloha_mobile_chair/    # ALOHA移动椅子任务数据
  │       └── aloha_mobile_elevator/ # ALOHA移动电梯任务数据
  ├── test_*.py                # 单元测试文件
  └── conftest.py              # pytest配置文件

二、测试数据集组织

1. 标准数据集结构

每个数据集(如 aloha_mobile_elevator)包含:

aloha_mobile_elevator/
  ├── meta_data/               # 元数据目录
  │   ├── episode_data_index.safetensors  # 回合索引数据
  │   ├── info.json           # 数据集基本信息
  │   └── stats.safetensors   # 数据统计信息
  ├── train/                   # 训练数据目录
  │   ├── data-00000-of-00001.arrow  # Arrow格式数据文件
  │   ├── dataset_info.json   # 数据集特征描述
  │   └── state.json          # 训练状态信息
  └── videos/                  # 视频数据目录
      ├── observation.images.cam_high_episode_*.mp4        # 顶部相机视频
      ├── observation.images.cam_left_wrist_episode_*.mp4  # 左手腕相机视频
      └── observation.images.cam_right_wrist_episode_*.mp4 # 右手腕相机视频

2. 关键文件说明

meta_data/info.json
{
    "codebase_version": "v1.6",  # 代码库版本
    "fps": 50,                   # 视频帧率
    "video": true,               # 是否使用视频格式
    "encoding": {                # 视频编码参数
        "vcodec": "libsvtav1",   # 编码器
        "pix_fmt": "yuv420p",    # 像素格式
        "g": 2,                  # 关键帧间隔
        "crf": 30               # 压缩质量
    }
}
train/dataset_info.json

定义数据集特征格式:

{
    "features": {
        "observation.images.cam_high": {
            "_type": "VideoFrame"
        },
        "observation.state": {
            "feature": {"dtype": "float32"},
            "length": 14,
            "_type": "Sequence"
        },
        "action": {
            "feature": {"dtype": "float32"},
            "length": 14,
            "_type": "Sequence"
        }
    }
}

三、在训练中使用测试数据

1. 直接使用测试数据集

from lerobot.common.datasets import LeRobotDataset

# 加载测试数据集
dataset = LeRobotDataset(
    "tests/data/lerobot/aloha_mobile_elevator",
    split="train"
)

# 获取单帧数据
frame = dataset[0]

2. 通过训练脚本使用

# 设置数据集根目录
export DATA_DIR="tests/data"

# 启动训练
python lerobot/scripts/train.py \
    policy=act \
    env=aloha \
    dataset_repo_id=lerobot/aloha_mobile_elevator

3. 数据集验证

# 可视化测试数据集
python lerobot/scripts/visualize_dataset.py \
    --repo-id lerobot/aloha_mobile_elevator \
    --episode-index 0 \
    --data-dir tests/data

四、测试用例编写

1. 数据集测试示例

def test_dataset_loading():
    dataset = LeRobotDataset(
        "tests/data/lerobot/aloha_mobile_elevator"
    )
    
    # 检查数据集大小
    assert len(dataset) > 0
    
    # 检查数据格式
    sample = dataset[0]
    assert "observation.state" in sample
    assert "action" in sample
    
    # 检查视频加载
    assert "observation.images.cam_high" in sample

2. 策略测试示例

def test_policy_inference():
    # 加载策略
    policy = ACTPolicy.from_pretrained(
        "tests/data/models/act_aloha"
    )
    
    # 准备输入数据
    batch = {
        "observation.state": torch.randn(1, 14),
        "observation.images.cam_high": torch.randn(1, 3, 224, 224)
    }
    
    # 执行推理
    with torch.no_grad():
        output = policy(batch)
    
    # 验证输出
    assert output.shape == (1, 14)

五、测试配置说明

1. conftest.py 配置

# 来自 tests/conftest.py
@pytest.fixture
def is_robot_available(robot_type):
    """检查机器人硬件是否可用"""
    if robot_type not in available_robots:
        raise ValueError(
            f"The robot type '{robot_type}' is not valid. Expected one of these '{available_robots}"
        )

    try:
        config_path = ROBOT_CONFIG_PATH_TEMPLATE.format(robot=robot_type)
        robot_cfg = init_hydra_config(config_path)
        robot = make_robot(robot_cfg)
        robot.connect()
        return True
    except Exception as e:
        print(f"\nA {robot_type} robot is not available.")
        return False

@pytest.fixture
def is_camera_available(camera_type):
    """检查相机硬件是否可用"""
    if camera_type not in available_cameras:
        raise ValueError(
            f"The camera type '{camera_type}' is not valid. Expected one of these '{available_cameras}"
        )

    try:
        camera = make_camera(camera_type)
        camera.connect()
        return True
    except Exception as e:
        print(f"\nA {camera_type} camera is not available.")
        return False

2. 测试环境变量

# 设置测试设备
export DEVICE="cuda"  # 或 "cpu", "mps"

# 设置测试数据目录
export DATA_DIR="tests/data"

# 设置测试机器人类型
export ROBOT_TYPE="aloha"  # 或 "xarm", "koch"

六、常见测试场景

1. 硬件相关测试

def test_robot_control(is_robot_available):
    """测试机器人控制"""
    if not is_robot_available:
        pytest.skip("Robot hardware not available")
        
    # 执行机器人控制测试
    robot = make_robot(robot_cfg)
    robot.connect()
    robot.move_to_joint_positions([0] * 6)
    
def test_camera_capture(is_camera_available):
    """测试相机捕获"""
    if not is_camera_available:
        pytest.skip("Camera hardware not available")
        
    # 执行相机捕获测试
    camera = make_camera("realsense")
    camera.connect()
    frame = camera.capture()

2. 数据集测试

def test_dataset_conversion():
    """测试数据格式转换"""
    # 准备原始数据
    raw_dir = Path("tests/data/raw/demo_001")
    videos_dir = Path("tests/data/processed/demo_001")
    
    # 执行转换
    dataset, episode_index, info = from_raw_to_lerobot_format(
        raw_dir=raw_dir,
        videos_dir=videos_dir,
        fps=30,
        video=True
    )
    
    # 验证转换结果
    assert "observation.state" in dataset[0]
    assert episode_index["from"].shape[0] > 0
    assert info["fps"] == 30

3. 策略训练测试

def test_policy_training():
    """测试策略训练"""
    # 准备训练配置
    config = {
        "policy": "act",
        "env": "pusht",
        "training": {
            "batch_size": 8,
            "num_epochs": 1,
            "eval_freq": 100
        }
    }
    
    # 执行训练
    trainer = PolicyTrainer(config)
    metrics = trainer.train()
    
    # 验证训练结果
    assert "loss" in metrics
    assert "success_rate" in metrics

七、测试最佳实践

  1. 测试数据管理
  • 使用小型测试数据集(1-2个回合)
  • 使用git-lfs管理大文件
  • 提供数据集的完整元信息
  1. 硬件测试处理
  • 使用pytest.skip跳过不可用硬件
  • 提供硬件模拟器用于CI测试
  • 记录硬件相关的错误信息
  1. 测试覆盖率
  • 使用pytest-cov检查覆盖率
  • 关注核心功能的测试覆盖
  • 包含正常和异常情况的测试
  1. 持续集成
  • 在PR中运行所有测试
  • 定期运行完整测试套件
  • 保存测试结果和性能指标

这个文档提供了完整的测试指南,包括配置说明、常见测试场景和最佳实践。所有内容都基于代码库中的实际实现.

中文版本

本教程将解释训练脚本的使用方法,特别是如何使用 Hydra 来配置训练所需的一切。

训练脚本

LeRobot 提供了一个训练脚本 lerobot/scripts/train.py。从高层次来看,它执行以下步骤:

  • 加载 Hydra 配置文件用于后续步骤(稍后会详细介绍 Hydra)
  • 创建一个仿真环境
  • 创建与该仿真环境对应的数据集
  • 创建一个策略(policy)
  • 运行标准的训练循环,包括前向传播、反向传播、优化步骤,以及定期的日志记录、评估(在环境中评估策略)和检查点保存

Hydra 使用基础

完整解释 Hydra 的来龙去脉超出了本文档的范围,但这里我们会分享你需要了解的主要内容。

首先,lerobot/configs 的目录结构如下:

.
├── default.yaml
├── env
│   ├── aloha.yaml
│   ├── pusht.yaml
│   └── xarm.yaml
└── policy
    ├── act.yaml
    ├── diffusion.yaml
    └── tdmpc.yaml

为了简洁起见,在本文档的其余部分中,我们将省略开头的 lerobot/configs 路径。所以 default.yaml 实际上指的是 lerobot/configs/default.yaml。

当你运行训练脚本时:

python lerobot/scripts/train.py

Hydra 会被设置为读取 default.yaml(通过 @hydra.main 装饰器)。如果你查看 @hydra.main 的参数,你会看到 config_path="../configs", config_name="default"。在 default.yaml 的顶部,有一个 defaults 部分,看起来像这样:

defaults:
  - _self_
  - env: pusht
  - policy: diffusion

这个逻辑告诉 Hydra 要包含来自 env/pusht.yaml 和 policy/diffusion.yaml 的配置参数。注意:要注意顺序,因为具有相同名称的配置参数会被覆盖。因此,default.yaml 会被 env/pusht.yaml 覆盖,后者又会被 policy/diffusion.yaml 覆盖。

然后,default.yaml 还包含一些通用配置参数,如 device: cuda 或 use_amp: false(用于启用 fp16 训练)。一些其他参数被设置为 ???,这表示它们应该在其他 yaml 文件中设置。例如,default.yaml 中的 training.offline_steps: ??? 在 diffusion.yaml 中被设置为 200000。

由于 default.yaml 中的这个 defaults 部分,如果你想用 PushT 训练 Diffusion Policy,你只需要运行:

python lerobot/scripts/train.py

不过,你也可以更明确地启动完全相同的 Diffusion Policy 在 PushT 上的训练:

python lerobot/scripts/train.py policy=diffusion env=pusht

通过命令行覆盖默认值的这种方式在你想要更改策略和/或环境时特别有用。例如,你可以在默认的 Aloha 环境上训练 ACT:

python lerobot/scripts/train.py policy=act env=aloha

这里有两点需要注意:

  • 配置覆盖以 param_name=param_value 的形式传递
  • 这里我们覆盖了默认部分。policy=act 告诉 Hydra 使用 policy/act.yaml,而 env=aloha 告诉 Hydra 使用 env/aloha.yaml

顺便说一下:我们已经设置了所有配置,使它们能够重现文献中的最新研究成果。

在命令行中覆盖配置参数

现在假设我们想在 Aloha 环境中训练一个不同的任务。如果你查看 env/aloha.yaml,你会看到类似这样的内容:

# lerobot/configs/env/aloha.yaml
env:
  task: AlohaInsertion-v0

如果你查看 policy/act.yaml,你会看到类似这样的内容:

# lerobot/configs/policy/act.yaml
dataset_repo_id: lerobot/aloha_sim_insertion_human

但我们的 Aloha 环境实际上也支持立方体传输任务。要训练这个任务,你可以手动修改这两个 yaml 配置文件。

首先,我们需要将 ALOHA 环境切换到使用立方体传输任务。

# lerobot/configs/env/aloha.yaml
env:
-  task: AlohaInsertion-v0
+  task: AlohaTransferCube-v0

然后,我们还需要切换到使用立方体传输数据集。

# lerobot/configs/policy/act.yaml
-dataset_repo_id: lerobot/aloha_sim_insertion_human
+dataset_repo_id: lerobot/aloha_sim_transfer_cube_human

然后,你就可以运行:

python lerobot/scripts/train.py policy=act env=aloha

这样你就会在立方体传输任务上进行训练和评估。

除了编辑 yaml 配置文件外,还可以通过命令行覆盖默认值:

python lerobot/scripts/train.py \
    policy=act \
    dataset_repo_id=lerobot/aloha_sim_transfer_cube_human \
    env=aloha \
    env.task=AlohaTransferCube-v0

这里有一个新东西。注意用于遍历配置层次结构的 . 分隔符。但要注意 defaults 部分是一个例外。如你所见,我们不需要在命令行中写 defaults.policy=act。policy=act 就足够了。

把所有这些知识放在一起,这里是用来训练 https://huggingface.co/lerobot/act_aloha_sim_transfer_cube_human 的命令。

python lerobot/scripts/train.py \
    hydra.run.dir=outputs/train/act_aloha_sim_transfer_cube_human \
    device=cuda
    env=aloha \
    env.task=AlohaTransferCube-v0 \
    dataset_repo_id=lerobot/aloha_sim_transfer_cube_human \
    policy=act \
    training.eval_freq=10000 \
    training.log_freq=250 \
    training.offline_steps=100000 \
    training.save_model=true \
    training.save_freq=25000 \
    eval.n_episodes=50 \
    eval.batch_size=50 \
    wandb.enable=false \

这里有一个新东西:hydra.run.dir=outputs/train/act_aloha_sim_transfer_cube_human,它指定了保存训练输出的位置。

使用不在 lerobot/configs 中的配置文件

上面我们讨论了我们的训练脚本是如何设置的,使得 Hydra 在 lerobot/configs 中寻找 default.yaml。但是,如果你在文件系统的其他地方有一个配置文件,你可以使用:

python lerobot/scripts/train.py --config-dir PARENT/PATH --config-name FILE_NAME_WITHOUT_EXTENSION

注意:这里我们使用常规语法为 Python 脚本提供命令行参数,而不是 Hydra 的 param_name=param_value 语法。

作为一个具体的例子,当你有一个包含训练输出的文件夹,并且想要重新运行训练时,这变得特别方便。例如,假设你之前用前面的命令之一运行了训练脚本,并且有 outputs/train/my_experiment/checkpoints/pretrained_model/config.yaml。这个 config.yaml 文件将包含完整的配置参数集。要再次使用相同的配置运行训练,执行:

python lerobot/scripts/train.py --config-dir outputs/train/my_experiment/checkpoints/last/pretrained_model --config-name config

注意,你仍然可以使用常规语法进行配置参数覆盖(例如:通过添加 training.offline_steps=200000)。

典型的日志和指标

当你开始训练过程时,你首先会看到你的完整配置被打印在终端中。你可以检查它以确保你的配置是正确的,并且你的配置没有被其他文件覆盖。最终的配置也会与检查点一起保存。

之后,你会看到像这样的训练日志:

INFO 2024-08-14 13:35:12 ts/train.py:192 step:0 smpl:64 ep:1 epch:0.00 loss:1.112 grdn:15.387 lr:2.0e-07 updt_s:1.738 data_s:4.774

或者评估日志:

INFO 2024-08-14 13:38:45 ts/train.py:226 step:100 smpl:6K ep:52 epch:0.25 ∑rwrd:20.693 success:0.0% eval_s:120.266

如果 wandb.enable 设置为 true,这些日志也会保存在 wandb 中。以下是一些缩写的含义:

  • smpl: 训练期间看到的样本数
  • ep: 训练期间看到的回合数。一个回合包含完整操作任务中的多个样本
  • epch: 所有唯一样本被看到的次数(epoch)
  • grdn: 梯度范数
  • ∑rwrd: 计算每个评估回合中奖励的总和,然后取平均值
  • success: 评估回合的平均成功率。奖励和成功通常是不同的,除非在稀疏奖励设置中,只有当任务成功完成时奖励才为1
  • eval_s: 在环境中评估策略的时间,以秒为单位
  • updt_s: 更新网络参数的时间,以秒为单位
  • data_s: 加载一批数据的时间,以秒为单位

一些指标对于初始性能分析很有用。例如,如果你通过 nvidia-smi 命令发现当前 GPU 利用率很低,并且 data_s 有时太高,你可能需要修改批量大小或数据加载工作线程的数量来加速数据加载。我们也推荐使用 pytorch profiler 进行详细的性能探测。

到目前为止,我们已经看到了如何为 PushT 训练 Diffusion Policy 以及为 ALOHA 训练 ACT。现在,如果我们想为 PushT 训练 ACT 呢?好吧,ACT 配置中有一些特定于 ALOHA 环境的方面,这些方面恰好与 PushT 不兼容。因此,尝试运行以下命令几乎肯定会引发某种异常(例如:特征维度不匹配):

python lerobot/scripts/train.py policy=act env=pusht dataset_repo_id=lerobot/pusht

请查看我们的关于调整策略配置以适应各种环境的高级教程以了解更多信息。

在此期间,祝编码愉快! 🤗

为 PushT 环境适配 ACT 策略配置

在本教程中,我们将学习如何调整策略配置以适应新的环境和数据集。作为具体示例,我们将调整 ACT 的默认配置以适应 PushT 环境和数据集。

如果你还没有阅读我们关于训练脚本和配置工具的教程,请在开始本教程之前先阅读它。

让我们开始吧!

假设我们想要为 PushT 训练 ACT。然而,ACT 配置中有一些特定于 ALOHA 环境的方面,这些恰好与 PushT 不兼容。因此,尝试运行以下命令几乎肯定会引发某种异常(例如:特征维度不匹配):

python lerobot/scripts/train.py policy=act env=pusht dataset_repo_id=lerobot/pusht

我们需要调整 ACT 策略配置的参数以适应 PushT 环境。最重要的是图像键。

ALOHA 的数据集和环境通常使用可变数量的摄像头。在 lerobot/configs/policy/act.yaml 中你可能注意到两个相关部分。这里我们展示了调整到 PushT 所需的最小改动:

override_dataset_stats:
-  observation.images.top:
+  observation.image:
    # 来自 imagenet 的统计数据,因为我们使用预训练的视觉模型
    mean: [[[0.485]], [[0.456]], [[0.406]]]  # (c,1,1)
    std: [[[0.229]], [[0.224]], [[0.225]]]  # (c,1,1)

policy:
  input_shapes:
-    observation.images.top: [3, 480, 640]
+    observation.image: [3, 96, 96]
    observation.state: ["${env.state_dim}"]
  output_shapes:
    action: ["${env.action_dim}"]

  input_normalization_modes:
-    observation.images.top: mean_std
+    observation.image: mean_std
     observation.state: min_max
  output_normalization_modes:
    action: min_max

这里我们考虑了以下几点:

  • PushT 使用 “observation.image” 作为其图像键。
  • PushT 提供较小的图像。

旁注: 从技术上讲,我们可以通过命令行界面覆盖这些设置,但是对于许多更改来说会变得有点混乱,而且我们还面临一个挑战,即我们在观察键中使用 . 被 Hydra 视为层次分隔符。

为了方便起见,我们在本目录中提供了 act_pusht.yaml。它包含了上述差异,以及其他一些(可选的)差异,这些在文件中都有解释。请使用以下命令将其复制到 lerobot/configs/policy 中:

cp examples/advanced/1_train_act_pusht/act_pusht.yaml lerobot/configs/policy/act_pusht.yaml

(记住从之前的教程中学到的,Hydra 会在 lerobot/configs 目录中查找)。现在尝试运行以下命令。

python lerobot/scripts/train.py policy=act_pusht env=pusht

注意这与教程开始时失败的命令很相似,只是:

  • 现在我们使用 policy=act_pusht 指向我们的新配置文件。
  • 我们可以删除 dataset_repo_id=lerobot/pusht,因为这个更改已经包含在我们的新配置文件中。

太好了! 你现在正在为 PushT 环境训练 ACT。

本教程的要点是,当为不同的环境和数据集训练策略时,你需要了解策略配置中哪些部分是特定于这些环境和数据集的,并相应地进行更改。

祝编码愉快! 🤗

中文版本

本教程解释如何恢复使用训练脚本开始的训练运行。如果你不了解我们的训练脚本和配置系统是如何工作的,请先阅读 4_train_policy_with_script.md。

基本训练恢复

让我们以训练 ACT 用于 ALOHA 任务之一为例。这里有一个可以实现这一目标的命令:

python lerobot/scripts/train.py \
    hydra.run.dir=outputs/train/run_resumption \
    policy=act \
    dataset_repo_id=lerobot/aloha_sim_transfer_cube_human \
    env=aloha \
    env.task=AlohaTransferCube-v0 \
    training.log_freq=25 \
    training.save_checkpoint=true \
    training.save_freq=100

这里我们使用 ACT 的默认数据集和环境,并且我们特意将日志频率和检查点频率设置为较低的数值,以便我们可以测试恢复功能。你应该能够看到一些日志记录,并在 1 分钟内得到第一个检查点。请在第一个检查点之后中断训练。

要恢复训练,我们只需要运行训练脚本,提供运行目录和恢复选项:

python lerobot/scripts/train.py \
    hydra.run.dir=outputs/train/run_resumption \
    resume=true

你应该从日志中看到你的训练从中断的地方继续进行。

注意,使用 resume=true 时,会加载训练输出目录中最后一个检查点的配置文件。因此,我们没有提供之前命令中的所有其他配置参数并不重要(尽管可能会有警告通知你,你的命令与检查点的配置不同)。

现在你应该知道如何在训练运行被中断或你想要延长已完成的训练运行时恢复训练。

祝编码愉快! 🤗

中文版本

本教程演示如何在 LeRobotDataset 中使用图像变换进行数据增强。我们将展示如何在从数据集加载数据时对观察图像应用 torchvision 变换。

基本图像变换

首先,让我们创建一个没有任何变换的基本数据集:

from lerobot.common.datasets.lerobot_dataset import LeRobotDataset

dataset_repo_id = "lerobot/aloha_static_tape"

# 创建一个没有变换的 LeRobotDataset
dataset = LeRobotDataset(dataset_repo_id)
# 这等同于 `dataset = LeRobotDataset(dataset_repo_id, image_transforms=None)`

接下来,我们可以使用 torchvision 定义一些图像变换:

from torchvision.transforms import v2

# 定义变换
transforms = v2.Compose(
    [
        v2.ColorJitter(brightness=(0.5, 1.5)),  # 亮度调整
        v2.ColorJitter(contrast=(0.5, 1.5)),    # 对比度调整
        v2.RandomAdjustSharpness(sharpness_factor=2, p=1),  # 锐度调整
    ]
)

# 创建一个带有变换的数据集
transformed_dataset = LeRobotDataset(dataset_repo_id, image_transforms=transforms)

要比较原始图像和变换后的图像,我们可以:

from pathlib import Path
from torchvision.transforms import ToPILImage

# 从每个数据集获取第一帧
first_idx = dataset.episode_data_index["from"][0].item()
original_frame = dataset[first_idx][dataset.camera_keys[0]]
transformed_frame = transformed_dataset[first_idx][transformed_dataset.camera_keys[0]]

# 保存图像
output_dir = Path("outputs/image_transforms")
output_dir.mkdir(parents=True, exist_ok=True)

to_pil = ToPILImage()
to_pil(original_frame).save(output_dir / "original_frame.png", quality=100)
to_pil(transformed_frame).save(output_dir / "transformed_frame.png", quality=100)

变换后的图像将被保存到 outputs/image_transforms 目录中。

这些图像变换可以帮助增加训练数据的多样性,提高模型的鲁棒性。在这个例子中,我们应用了亮度调整、对比度调整和锐度调整,但你可以根据需要添加更多的变换。

祝编码愉快! 🤗

如何从0搭建具身智能Lerobot SO-ARM100机械臂并完成自定义抓取任务
m0_53134931的博客
01-07 3947
从0搭建具身智能机械臂免费教程来啦！！！！
【ubuntu环境 LeRobot具身智能机械臂项目】
weixin_38504456的博客
12-23 617
在此之前已学习基础知识与基本技能，包括ROS2基本操作，空间坐标转换，强化学习与模仿学习理论知识，pytorch配置，C++与Python复习，ubuntu物理机安装等。详见 https://github.com/huggingface/lerobot/blob/66f87365988cb5424435ea03b428426b4ede98cb/examples/7_get_started_with_real_robot.md。按照教程和视频进行，记录遇到的两个报错和解决方式。开通两个端口的访问权限。
从零开始，手把手教你搭建Lerobot机械臂
石臻臻的杂货铺(szzdzhp001)
02-27 7251
SO-ARM100是一款具备 6 自由度、支持 3D 打印、极具性价比的开源机械臂。Lerobot是个开源机器人的解决方案，可基于act的强化学习框架训练SO-ARM100模仿人的操作，当然也可以是其他机械臂。如果没人指导，还是有点麻烦的，好在AI还能帮点忙，不然要退货了。目前简单抓取动作的成功率还行，看看能不能训个叠衣服的机械臂！还有做了些好玩的视频，分享在小红书账号上，感兴趣的可以看看。希望这篇教程对你有所帮助，快去动手试试吧！说不定还能给蚂蚁机器人助个力，哈哈。
LeRobot - 让现实机器人更易学
AI工程化、开源分享、文档翻译、代码笔记
09-19 7036
一、关于 LeRobot 特点 模拟环境中预训练模型的示例 致谢 教程 - Getting Started with Real-World Robots 二、安装 三、Walkthrough 1、可视化数据集 2、`LeRobotDataset`的格式 3、评估预先训练的策略 4、训练你自己的政策 复制最先进的（SOTA） 四、贡献 1、添加新数据集 2、添加预训练策略 3、通过分析改进您的代码
使用 SO-100 运行 LeRobot框架
最新发布
weixin_42396076的博客
04-12 1660
配置步骤还将归零偏移设置为 0，所以如果你装配错误，你可以随时更新归零偏移以补偿 ± 2048 步（± 180 度）的偏移。接下来，你需要校准你的 SO-100 机器人，以确保领导者机械臂和跟随者机械臂在相同物理位置时具有相同的位置值。太棒了 :hugs:！第一条机械臂的装配可能超过 1 小时，但一旦你习惯了，你可以在 1 小时内装配第二条机械臂。在装配之前，你首先需要配置电机。如果你想使用 Hugging Face 集成的功能上传你的数据集并且你之前没有这样做过，请确保你已使用写权限的令牌登录，可以在。
LeRobot 项目使用教程
gitblog_00152的博客
08-09 1374
LeRobot 项目使用教程 lerobot???? LeRobot: State-of-the-art Machine Learning for Real-World Robotics in Pytorch项目地址:https://gitcode.com/gh_mirrors/le/lerobot 1. 项目的目录结构及介绍 LeRobot 项目的目录结构如下： lerobot/ ├── data/...
探秘未来机器人编程：拥抱变化的LeRobot库
gitblog_00070的博客
05-09 1621
探秘未来机器人编程：拥抱变化的LeRobot库 项目地址:https://gitcode.com/gh_mirrors/le/lerobot 在人工智能与机器学习的浪潮中，我们正见证着技术如何重塑机器人领域。如今，一个名为LeRobot的开源项目应运而生，它将前沿的机器学习算法带入实际的机器人应用中，致力于降低入门门槛，鼓励共享和合作。本文将带你深入理解LeRobot的核心价值，领略其技术魅力，并...
LeRobot 教程
01-20
为了开始使用 LeRobot 库，首先需要安装必要的依赖项并设置环境。这通常涉及到 Python 和 PyTorch 的安装以及特定硬件的支持包。具体步骤可以参见官方文档或 GitHub 仓库中的 README 文件。 #### 使用教程视频 有一...
Windows lerobot
02-21
对于希望了解有关 Windows 平台上的勒机器人 (Lerobot) 的技术文档、教程以及安装配置指南的用户来说，有多种资源可以提供帮助。 #### 获取官方技术支持资料 微软官方网站提供了丰富的开发者和技术支持资源。通过...
Lerobot ros
03-16
在使用LeRobot之前，需完成基本的ROS环境配置。这包括安装ROS核心组件以及必要的依赖包。例如，在Ubuntu系统下可以通过以下命令安装ROS Melodic版本： ```bash sudo apt update && sudo apt install ros-melodic-...
LeRobot 开源项目教程
gitblog_00833的博客
08-09 2911
???? LeRobot 开源项目教程 项目地址:https://gitcode.com/gh_mirrors/le/lerobot 项目介绍 ???? LeRobot 是一个旨在简化机器人项目启动的开源库，类似于 Transformers 库在自然语言处理（NLP）中的作用。LeRobot 提供了预训练模型和与物理模拟器的无缝集成，支持多种机器人硬件，从教育机械臂到复杂的人形机器人。该项目由 Hugging...
Robotframework入门教程（一）.pdf
02-27
Robotframework⼊门教程（⼀） 最近⼯作中⽤Robot Framework框架来做⾃动化，所以，花时间学习了⼀下，⽹上好的⽂档不多，⼤多都是复制粘贴如何安装环境。要么就是介绍了⼀堆RIDE 的界⾯，活活把这么强⼤的⼀个⼯具讲成了个photoshop，我⽬前⽤了1个多⽉，这个⼯具很强⼤，简单写两句。 ==安装== ⾸先其实RIDE是个好⼯具，但是安装起来真⼼费劲，当时我的MAC上安装的时候google了两天，⼀个问题接⼀个问题。 我这边呢就不⽤RIDE了，想⽤呢⾃⼰想辙安去。 安装命令： pip install robotframework ==第⼀个testcase== RF的特点什么的就不多说了，⽹上有的是，撸起袖⼦就是⼲。 新建demo.robot⽂件，内容如下。 *** Test Cases *** First Case Log Hello World! warn Second Case ${res} Evaluate 1+2+3 Should Be Equal ${res} 6 Third Case ${res} Evaluate 'i'*3 Length Should Be ${res} 运⾏ robot demo.robot。将得到如下 上⾯的例⼦有三条case，第⼀条调⽤内置关键字Log， 第⼀个参数是"Hello World! " ，第⼆个参数是"warn"。就是简单打印⼀条log，后⾯的是log的等级，默 认输出info以上的log到console，截图中可以看到first case中打印了 Hello World！等级为WARN。 第⼆条case，调⽤内置关键字Evaluate，参数是"1+2+3"，结果赋值给变量res（RF的语法是⽤$和⼤括号代表标量变量，还有其他类型的变量以后再说）然后调 ⽤Should Be Equal校验结果是否等于6，因为默认是字符串格式，所以second case 执⾏结果是FAIL。 第三条case，和第⼆条类似，同样调⽤Evalutate 赋值给变量res为"iii",校验变量长度为3，执⾏结果为PASS。 最后三⾏显⽰这次执⾏结果⽣成的⽂件，output.xml,log.html,report.html。打开log⽂件如下，结果报告有什么优点就不说了，⾃⼰去看。output.xml先放放以后 再说。 前⾯说过RF中默认的都是格式是String，那么怎么给关键字传其他的类型，答案是⽤变量。修改second case如下： Second Case ${res} Evaluate 1+2+3 Should Be Equal ${res} ${6} 再次执⾏robot demo.robot 这次的结果
lerobot 文档翻译
滴水成川
02-10 164
通过以下步骤，您将能够实现类似于视频中展示的高成功率任务，例如抓取乐高积木并将其放入容器中。随后，您将训练一个神经网络来模仿这些轨迹，并将其部署，使您的机器人能够自主运行。使用收集的数据，您可以训练一个神经网络，使其能够模仿您的示范。这样，机器人将根据学习到的策略执行任务，您可以观察其性能并进行调整。，或将其复制粘贴到 Python 文件中，来了解我们的类和函数。机器人设计，但其中的信息也可适用于其他类型的机器人，如。机器人将在您的控制下移动，并记录轨迹数据。首先，通过运行以下命令，安装为使用。
探索双手机器人操作中的主动视觉
yorkhunter的博客
10-17 1182
24年9月来自 UC Berkeley 和 UC Davis 的论文“Active Vision Might Be All You Need: Exploring Active Vision in Bimanual Robotic Manipulation”。
视频远程监控平台EasyCVR集成后播放只有一帧画面的原因排查与解决
AI与流媒体视频技术
03-06 761
分发的视频流格式包括：RTMP、RTSP、HTTP-FLV、WS-FLV、HLS、WebRTC、HTTP-FMP4、WS-FMP4等。
LeRobot安装教程
傻傻的小白
01-18 660
使用Git从github仓库中远程下载项目：选择一个文件夹用于存放下载下来的项目（可以新建一个空文件夹），然后在该文件夹内打开GitBashHere,输入以下命令。如果遇到Git报错：Failedtoconnecttogithub.comport443。从图中可以看出，是切换到lerobot文件夹后，才使用pip命令进行安装的。myenv为自己新建环境的名字，自己定义名称。打开AnacondaPrompt。
LeRobot源码剖析——对机器人各个动作策略的统一封装：包含ALOHA ACT、Diffusion Policy、VLA模型π0
结构之法 算法之道
03-17 6094
过去2年多的深入超过此前7年，全靠夜以继日的勤奋，一天当两天用，抠论文 抠代码 和大模型及具身同事讨论，是目前日常而具身库里，idp3 π0 lerobot值得反复研究，故，近期我一直在抠π0及lerobot的源码本文一开始是此文《LeRobot——Hugging Face打造的机器人开源库：包含对顶层script、与底层基础层dataset的源码分析》的第四部分，考虑到为避免该文的篇幅过长，故把该文的第四部分独立出来，成本文该模块包含以下策略该模块主要包含以下组件可能马上就有同学疑问了，那这个模块和π0的
推荐文章：探索机器人智能的新大陆 —— LeRobot 开源框架深度解析
gitblog_00614的博客
08-09 1697
推荐文章：探索机器人智能的新大陆 —— ???? LeRobot 开源框架深度解析 lerobot???? LeRobot: State-of-the-art Machine Learning for Real-World Robotics in Pytorch项目地址:https://gitcode.com/gh_mirrors/le/lerobot 在人工智能与机器人技术的交叉口，有一座桥梁正在迅速搭...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值