Introducción a reBot Arm B601-DM basado en LeRobot y reBot 102 Leader

traj_sim_geodesic

Brazo robótico de 6 GDL · Soporte multi-motor · Solucionador de cinemática · Planificación de trayectorias · Totalmente de código abierto

Consigue uno ahora 🖱️

reBot Arm B601-DM es un proyecto de brazo robótico de código abierto lanzado por Seeed, dedicado a reducir el umbral para aprender inteligencia incorporada. Abrimos sin reservas todos los diseños estructurales y el código, haciendo que la tecnología robótica sea accesible para todos.

LeRobot se compromete a proporcionar modelos, conjuntos de datos y herramientas para robótica en el mundo real en PyTorch. Su objetivo es reducir la barrera de entrada a la robótica, permitiendo que todos contribuyan y se beneficien del intercambio de conjuntos de datos y modelos preentrenados. LeRobot integra metodologías de vanguardia validadas para aplicaciones en el mundo real, centrándose en el aprendizaje por imitación y el aprendizaje por refuerzo. Ha proporcionado un conjunto de modelos preentrenados, conjuntos de datos con demostraciones recopiladas por humanos y entornos de simulación, lo que permite a los usuarios comenzar sin necesidad de ensamblar robots.

📖 Introducción al proyecto

reBot-DevArm (reBot Arm B601 DM y reBot Arm B601 RS) es un proyecto de brazo robótico dedicado a reducir el umbral para aprender inteligencia incorporada. Nos centramos en el "Verdadero código abierto" — no solo código, abrimos sin reservas todo lo siguiente:

🦾 Brazos robóticos de código abierto con dos versiones de motor: Proporcionamos todos los archivos de código abierto para las versiones de motor RoboStride y Damiao con la misma apariencia.
🛠️ Planos de hardware: Archivos fuente de piezas de chapa metálica y piezas impresas en 3D.
🔩 BOM (Lista de materiales): Detallada hasta la especificación de cada tornillo y enlace de compra.
💻 Software y algoritmos: Python SDK, ROS1/2, Isaac Sim, LeRobot, etc.

Construye tu brazo robótico reBot

Ofrecemos cinco opciones de kit:
- Kit de motores del cuerpo del brazo robótico: Incluye solo los motores y arneses de cables necesarios para el brazo robótico.
- Kit de piezas estructurales del cuerpo del brazo robótico: Incluye solo los componentes mecánicos estructurales.
- Kit completo de pinza: Incluye motores, arneses de cables y piezas estructurales para la pinza.
- Kit completo de brazo: Incluye todos los componentes para el cuerpo del brazo robótico y la pinza.
- Brazo robótico preensamblado: Un brazo robótico completamente ensamblado.

El kit de robot inteligente reBot-DevArm y reComputer Jetson AI combina a la perfección el control de brazo robótico de alta precisión con una potente plataforma de computación de IA, proporcionando una solución integral de desarrollo de robots. Este kit se basa en la plataforma Jetson Orin o AGX Orin, combinada con reBot-DevArm y el framework de IA LeRobot, ofreciendo a los usuarios un sistema de robot inteligente aplicable a múltiples escenarios como educación, investigación y automatización industrial.

Este wiki proporciona tutoriales de depuración para reBot-DevArm e implementa la recopilación de datos y el entrenamiento dentro del framework LeRobot.

precaución

Los tutoriales de Seeed Studio se actualizan estrictamente de acuerdo con la documentación oficial. Si encuentras problemas de software o de entorno que no se puedan resolver, primero consulta las Preguntas frecuentes (FAQ) al final del artículo, o contacta con atención al cliente para unirte al grupo de discusión SeeedStudio LeRobot. También puedes hacer preguntas aquí: LeRobot GitHub o en el Discord Channel.

🔧 Características de la Serie reBot B601-DM:

Código abierto y bajo costo reBot Arm es una solución de brazo robótico de código abierto y bajo costo de Seeed Studio, dedicada a reducir el umbral para aprender inteligencia incorporada.
Integración con la plataforma LeRobot Diseñado para la integración con la plataforma LeRobot. Esta plataforma proporciona modelos PyTorch, conjuntos de datos y herramientas para el aprendizaje por imitación de tareas de robots reales (incluida la recopilación de datos, simulación, entrenamiento y despliegue).
Abundantes recursos de aprendizaje Proporciona completos recursos de aprendizaje de código abierto, incluidos guías de ensamblaje y calibración, tutoriales de prueba y recopilación de datos, documentación de entrenamiento y despliegue para ayudar a los usuarios a comenzar rápidamente y desarrollar aplicaciones robóticas.
Compatible con la plataforma Nvidia Admite el despliegue mediante la plataforma reComputer Mini J4012 Orin NX 16GB.

Entorno inicial del sistema

Para Ubuntu x86:

Ubuntu 22.04
CUDA 12+
Python 3.10
Torch 2.6

Para Jetson Orin:

Jetson JetPack 6.0 y 6.1, no compatible con 6.2
Python 3.10
Torch 2.3+

Instalar LeRobot

Necesitas instalar pytorch, torchvision y otros entornos según tu versión de CUDA.

1. Instalar Miniforge

cd ~
wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh

~/miniforge3/bin/conda init bash
source ~/.bashrc

2. Clonar el repositorio Lerobot

mkdir ~/rebot_lerobot
cd ~/rebot_lerobot
git clone https://github.com/Seeed-Projects/lerobot.git

3. Clonar paquetes de funciones

Clona dos paquetes de funciones dependientes en el directorio rebot_lerobot:

tip

Para las funciones detalladas de los paquetes de funciones, consulta:

cd ~/rebot_lerobot

# Clone rebot 102 leader function package
git clone https://github.com/Seeed-Projects/lerobot-teleoperator-rebot-arm-102.git

# Clone rebot b601 follower function package
git clone https://github.com/Seeed-Projects/lerobot-robot-seeed-b601.git

4. Crear entorno Conda e instalar LeRobot

El repositorio lerobot ya tiene un pyproject.toml. Crea un entorno conda e instala todas las dependencias.

cd ~/rebot_lerobot

# Create conda environment (Python 3.12)
conda create -y -n lerobot python=3.12

# Activate environment
conda activate lerobot

# Install lerobot main project (editable mode)
pip install -e ./lerobot

# Add local dependency packages (editable install)
pip install -e ./lerobot-teleoperator-rebot-arm-102
pip install -e ./lerobot-robot-seeed-b601
pip install motorbridge

5. Instalar ffmpeg

ffmpeg es una dependencia de decodificación de vídeo, instálalo mediante conda:

conda install ffmpeg -c conda-forge

tip

Notas de versión:

De forma predeterminada, se instalará ffmpeg 7.X (compatible con el codificador libsvtav1)
Si encuentras problemas de compatibilidad de versión, puedes especificar ffmpeg 7.1.1:
```
conda install ffmpeg=7.1.1 -c conda-forge
```
Puedes comprobar si el codificador libsvtav1 es compatible mediante ffmpeg -encoders | grep svtav1

6. Configuración especial para dispositivos Jetson JetPack 6.0+

(Omite este paso para PC) Para dispositivos Jetson JetPack 6.0+ (asegúrate de haber instalado Pytorch-gpu y Torchvision según este tutorial paso 5 antes de ejecutar este paso):

conda install -y -c conda-forge "opencv>=4.10.0.84"  # Install OpenCV and other dependencies via conda, for Jetson Jetpack 6.0+ only
conda remove opencv   # Uninstall OpenCV
pip3 install opencv-python==4.10.0.84  # Install specific OpenCV version using pip3
conda install -y -c conda-forge ffmpeg
conda uninstall numpy
pip3 install numpy==1.26.0  # This version must be compatible with torchvision

7. Comprobar Pytorch y Torchvision

tip

Si estás utilizando un dispositivo Jetson, instala Pytorch y Torchvision según este tutorial.

Dado que instalar el entorno lerobot mediante pip desinstalará el Pytorch y Torchvision originales e instalará las versiones para CPU, necesitas realizar una comprobación en Python.

python3

import torch
print(torch.cuda.is_available())#Should output True

Si la salida es True, puedes escribir exit() para salir de Python y continuar con los siguientes pasos. Si la salida es False, necesitas reinstalar Pytorch y Torchvision según el tutorial oficial.

Calibrar el brazo robótico

A continuación, debes conectar la fuente de alimentación y el cable de datos a tu robot reBot B601-DM para la calibración, a fin de garantizar que los brazos líder y seguidor tengan los mismos valores de posición cuando se encuentren en la misma posición física. Esta calibración es esencial porque permite que una red neuronal entrenada en un robot reBot B601-DM funcione en otro. Si necesitas recalibrar el brazo robótico, elimina por completo los archivos en ~/.cache/huggingface/lerobot/calibration/robots o ~/.cache/huggingface/lerobot/calibration/teleoperators y vuelve a calibrar el brazo robótico. De lo contrario, aparecerá un mensaje de error. La información de calibración del brazo robótico se almacenará en los archivos JSON de este directorio.

Primero, debes otorgar permisos de interfaz ejecutando los siguientes comandos:

sudo chmod 666 /dev/ttyUSB*  # Leader arm
sudo chmod 666 /dev/ttyACM*  # Follower arm (serial bridge)

Calibrar el brazo seguidor

El B601-DM solo necesita calibrarse una vez después del montaje. Aquí está el comando de calibración. Consulta la figura para la posición cero (pinza completamente cerrada).

sudo chmod 666 /dev/ttyACM*  # follower arm (serial bridge)

lerobot-calibrate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao

Calibrar el brazo líder

Los pasos de calibración son cruciales y afectarán directamente si el brazo robótico funciona con normalidad. Sigue estrictamente el proceso.

rebot 102 leader

tip

Notas de calibración del reBot 102 leader:

Cuando comienza la calibración, la posición actual de cada servo en el reBot Arm 102 se restablecerá a cero
joint_ranges (límites de las articulaciones) se toman del archivo de configuración config_rebot_arm_102_leader.py, no de los datos de calibración
Si una articulación siempre parece atascada cerca de un límite, primero revisa la configuración de joint_ranges
Las direcciones de las articulaciones se definen en el archivo de configuración. Si las direcciones no coinciden, modifica la configuración en lugar de recalibrar
reBot 102 leader utiliza un módulo USB-a-UART, que normalmente se asigna a /dev/ttyUSB*
Usa ls /dev/ttyUSB* para comprobar el número de puerto real

Si es la primera conexión, es posible que obtengas un error indicando que no se puede encontrar /dev/ttyACM0. Esto se debe a que brltty está ocupando el puerto serie. Ejecuta los siguientes pasos:

sudo dmesg | grep ttyUSB #Check the last line shows "disconnected"
sudo apt remove brltty #Remove brltty

Siguiendo las indicaciones, mueve el brazo líder a la posición cero mostrada arriba,

sudo chmod 666 /dev/ttyUSB0

lerobot-calibrate \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader

Mantenlo quieto y luego presiona Enter hasta que la calibración se complete. Después de la calibración, introduce el siguiente comando para probar el brazo líder.

python ./lerobot-teleoperator-rebot-arm-102/examples/read_raw_angles.py \
      --port /dev/ttyUSB0

#If you observe terminal output similar to the following printing continuously, and when at the zero position shown above, all joint output values are 0, then leader calibration is complete.
#shoulder_pan=    0.00  shoulder_lift=    0.00  elbow_flex=    0.00  wrist_flex=    0.00  wrist_yaw=    0.00  wrist_roll=    0.00  gripper=    0.00

Teleoperación

peligro

Durante la teleoperación, si el brazo robótico maestro-esclavo sufre una desconexión de energía, un mal contacto de alimentación o un desprendimiento de la línea de señal, primero debes detener el código del programa y devolver el brazo robótico a su posición cero inicial. Solo entonces vuelve a conectar la fuente de alimentación y reinicia el programa. Esto evita que el desorden de datos provoque que el brazo robótico se descontrole y cause posibles riesgos de seguridad.

Primero otorga permisos a los puertos serie:

sudo chmod 666 /dev/ttyUSB*  # Leader arm
sudo chmod 666 /dev/ttyACM*  # Follower arm (serial bridge)

Ejecuta la teleoperación:

lerobot-teleoperate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --teleop.joint_directions='{"shoulder_pan":-1,"shoulder_lift":-1,"elbow_flex":1,"wrist_flex":1,"wrist_yaw":1,"wrist_roll":-1,"gripper":-4}'

Añadir cámaras

Si se utiliza RealSense D435i/D405

Las cámaras de profundidad RealSense pueden proporcionar percepción RGB-D para LeRobot y son adecuadas para tareas como reconocimiento de objetos, reconstrucción de nubes de puntos y manipulación sobre mesa. Los modelos recomendados aquí son RealSense D405 y RealSense D435i.

RealSense D405

La RealSense D405 es una cámara de profundidad estéreo de corto alcance diseñada para tareas de alta precisión a corta distancia, como la manipulación robótica sobre mesa, con un rango de trabajo típico de 7 cm a 50 cm.

RealSense D435i

La RealSense D435i combina percepción de profundidad, imagen RGB y una IMU, lo que la hace adecuada para aplicaciones de rango medio a corto, como reconstrucción 3D, SLAM y percepción del entorno robótico.

1. Cambiar a la rama de cámara

El soporte actual para cámaras está disponible en la rama DepthCameraSupport:

git checkout DepthCameraSupport
git pull origin DepthCameraSupport

Confirma la rama actual:

git branch --show-current

Salida esperada:

DepthCameraSupport

2. Instalar LeRobot en modo editable

Si solo utilizas RealSense:

pip install -e ".[realsense]"

3. Otorgar permisos

sudo chmod a+rw /dev/bus/usb/*/*

4. Detectar cámaras

lerobot-find-cameras realsense

Este paso mostrará:

Modelo de la cámara
Número de serie
Información USB
Configuración de flujo predeterminada

5. Ejemplo de RealSense

Prueba con dos cámaras RealSense:

lerobot-teleoperate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
  --robot.cameras='{
    d435i_color: {
      type: realsense_d435i_color,
      serial_number_or_name: "419522072950",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      color_stream_format: rgb8,
      rotation: 0,
      warmup_s: 1
    },
    d435i_depth: {
      type: realsense_d435i_depth,
      serial_number_or_name: "419522072950",
      width: 640,
      height: 480,
      fps: 30,
      max_depth_m: 2.0,
      depth_alpha: 0.2,
      rotation: 0,
      warmup_s: 5
    },
    d405_color: {
      type: realsense_d405_color,
      serial_number_or_name: "409122273421",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      color_stream_format: rgb8,
      rotation: 0,
      warmup_s: 1
    },
    d405_depth: {
      type: realsense_d405_depth,
      serial_number_or_name: "409122273421",
      width: 640,
      height: 480,
      fps: 30,
      depth_alpha: 0.03,
      rotation: 0,
      warmup_s: 5
    }
  }' \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true

6. Notas sobre los parámetros

depth_alpha controla el factor de escala de la imagen de profundidad y se puede ajustar según el resultado de la visualización y el rango de distancia objetivo.
Si conectas tres o más cámaras de profundidad, se recomienda reducir fps a 15 para mejorar la estabilidad general.
Se recomienda mantener la resolución en 640x480 para lograr un mejor equilibrio entre estabilidad y rendimiento en tiempo real.

Si se utiliza la cámara de profundidad Orbbec Gemini2

Consigue uno ahora 🖱️

proporciona flujos sincronizados de RGB y profundidad con una alineación precisa de profundidad a color. Combinada con la percepción de profundidad estéreo y una IMU de 6 ejes integrada, es muy adecuada para tareas robóticas como detección de objetos, percepción 3D, mapeo y navegación. Su diseño compacto y la compatibilidad completa con el SDK de Orbbec la hacen adecuada tanto para investigación como para despliegues en el mundo real.

Gemini 336 es un nuevo miembro de la serie Gemini 330. Hereda el sólido rendimiento de profundidad de Gemini 335 y mejora aún más la calidad de la imagen de profundidad en áreas interiores reflectantes, regiones oscuras en escenas de alto rango dinámico y entornos exteriores brillantes. Para aplicaciones robóticas, puede proporcionar datos de profundidad más estables y de alta calidad para tareas como percepción, localización y manipulación.

1. Cambiar a la rama de cámara

El soporte actual para cámaras está disponible en la rama DepthCameraSupport:

git checkout DepthCameraSupport
git pull origin DepthCameraSupport

Confirma la rama actual:

git branch --show-current

Salida esperada:

DepthCameraSupport

2. Instalar LeRobot en modo editable

Si solo utilizas Orbbec:

pip install -e ".[orbbec]"

3. Conceder permisos

sudo chmod a+rw /dev/bus/usb/*/*

4. Detectar cámaras

lerobot-find-cameras orbbec

Este paso generará:

Modelo de cámara
Número de serie
Información USB
Configuración de flujo predeterminada

5. Ejemplo de Orbbec

Prueba de Orbbec única:

lerobot-teleoperate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
    --robot.cameras="{
    orbbec_color: {
      type: orbbec_color,
      serial_number_or_name: "CP9JA530003A",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      rotation: 0,
      warmup_s: 1
    },
    orbbec_depth: {
      type: orbbec_depth,
      serial_number_or_name: "CP9JA530003A",
      width: 640,
      height: 400,
      fps: 30,
      depth_alpha: 0.2,
      rotation: 0,
      warmup_s: 5
    }
  }" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true

6. Notas sobre parámetros

depth_alpha controla el factor de escala de la imagen de profundidad. Un buen punto de partida es 0.2, luego puedes ajustarlo finamente según el resultado mostrado.
Si conectas tres o más cámaras de profundidad, se recomienda reducir fps a 15 para una mejor estabilidad.
Se recomienda mantener la resolución en 640x480 para una visualización y transferencia de datos más estables.

7. Problemas comunes

Si ves el siguiente error:

No Orbbec camera found for 'XXXX'

normalmente significa que el número de serie en la configuración no coincide con el dispositivo conectado actualmente. Ejecuta:

lerobot-find-cameras orbbec

Luego confirma el serial real y actualiza serial_number_or_name en tu comando.

💡 Autor y contribución

Autor: Zhang Jiaquan, Wang Wenzhao - South China Normal University

Para instanciar una cámara, necesitas un identificador de cámara. Este identificador puede cambiar si reinicias tu computadora o vuelves a conectar tu cámara, un comportamiento que depende principalmente de tu sistema operativo.

Para encontrar los índices de las cámaras conectadas a tu sistema, ejecuta el siguiente script:

lerobot-find-cameras opencv # or realsense for Intel Realsense cameras

La terminal imprimirá la información relevante de la cámara.

--- Detected Cameras ---
Camera #0:
  Name: OpenCV Camera @ 0
  Type: OpenCV
  Id: 0
  Backend api: AVFOUNDATION
  Default stream profile:
    Format: 16.0
    Width: 1920
    Height: 1080
    Fps: 15.0
--------------------
(more cameras ...)

Puedes encontrar las imágenes tomadas por cada cámara en el directorio ~/lerobot/outputs/captured_images.

aviso

Al usar cámaras Intel RealSense en macOS, podrías obtener este error: "Error finding RealSense cameras: failed to set power state". Esto se puede resolver ejecutando el mismo comando con permisos de sudo. Ten en cuenta que el uso de cámaras RealSense en macOS es inestable.

Después de eso, podrás mostrar las cámaras en tu computadora mientras realizas la teleoperación ejecutando el siguiente código. Esto es útil para preparar tu configuración antes de grabar tu primer conjunto de datos.

lerobot-teleoperate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true

tip

Las imágenes en el formato fourcc: "MJPG" están comprimidas. Puedes probar resoluciones más altas y también puedes intentar el formato YUYV. Sin embargo, este último reducirá la resolución de la imagen y los FPS, lo que provocará retrasos en el funcionamiento del brazo robótico. Actualmente, bajo el formato MJPG, se pueden soportar 3 cámaras a una resolución de 1920*1080 manteniendo 30FPS. Sin embargo, aún no se recomienda conectar 2 cámaras a una computadora a través del mismo HUB USB.

Si tienes más cámaras, puedes cambiar el parámetro --robot.cameras para añadirlas. Debes prestar atención al formato de index_or_path, que está determinado por el último dígito del ID de la cámara que se muestra con python -m lerobot.find_cameras opencv.

Por ejemplo, si quieres añadir una cámara:

lerobot-teleoperate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true

Recopilación de conjuntos de datos

peligro

Durante la teleoperación, si el brazo robótico maestro-esclavo sufre una desconexión de energía, un mal contacto de alimentación o un desprendimiento de la línea de señal, primero debes detener el código del programa y devolver el brazo robótico a su posición cero de origen. Solo entonces vuelve a conectar la fuente de alimentación y reinicia el programa. Esto evita que el desorden de datos provoque que el brazo robótico se descontrole y cause posibles riesgos de seguridad.

Si quieres guardar el conjunto de datos localmente

lerobot-record \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true \
    --dataset.repo_id=seeed_rebot_b601_dm/test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.push_to_hub=false \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 

Entre ellos, repo_id se puede modificar de forma personalizada, y push_to_hub=false. Finalmente, el conjunto de datos se guardará en el directorio ~/.cache/huggingface/lerobot en la carpeta de inicio, donde se creará la carpeta seeed_rebot_b601_dm/test mencionada anteriormente.

Si quieres usar las funciones de Hugging Face Hub para subir tu conjunto de datos

Si quieres usar las funciones de Hugging Face Hub para subir tu conjunto de datos y no lo has hecho antes, asegúrate de haber iniciado sesión usando un token con permisos de escritura, que se puede generar desde la configuración de Hugging Face:

huggingface-cli login --token ${HUGGINGFACE_TOKEN} --add-to-git-credential

Almacena el nombre de tu repositorio de Hugging Face en una variable para ejecutar estos comandos:

HF_USER=$(huggingface-cli whoami | head -n 1)
echo $HF_USER

Graba 5 episodios y sube tu conjunto de datos al Hub:

lerobot-record \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true \
    --dataset.repo_id=${HF_USER}/record-test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.push_to_hub=true \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 

Verás muchas líneas que aparecen como esta:

INFO 2024-08-10 15:02:58 ol_robot.py:219 dt:33.34 (30.0hz) dtRlead: 5.06 (197.5hz) dtWfoll: 0.25 (3963.7hz) dtRfoll: 6.22 (160.7hz) dtRlaptop: 32.57 (30.7hz) dtRphone: 33.84 (29.5hz)

Función de grabación

La función record proporciona un conjunto de herramientas para capturar y gestionar datos durante el funcionamiento del robot.

1. Almacenamiento de datos

Los datos se almacenan usando el formato LeRobotDataset y se guardan en disco durante la grabación.
De forma predeterminada, el conjunto de datos se envía a tu página de Hugging Face después de la grabación.
Para desactivar la subida, usa: --dataset.push_to_hub=False.

2. Puntos de control y reanudación

Los puntos de control se crean automáticamente durante la grabación.
Para reanudar después de una interrupción, vuelve a ejecutar el mismo comando con: --resume=true

⚠️ Nota importante: Al reanudar, establece --dataset.num_episodes en el número de episodios adicionales que se van a grabar (no en el número total de episodios objetivo del conjunto de datos).

Para empezar a grabar desde cero, elimina manualmente el directorio del conjunto de datos.

3. Parámetros de grabación

Configura el flujo de grabación de datos usando argumentos de línea de comandos:

Parámetro	Descripción	Predeterminado
--dataset.episode_time_s	Duración por episodio de datos (segundos)	60
--dataset.reset_time_s	Tiempo de reinicio del entorno después de cada episodio (segundos)	60
--dataset.num_episodes	Número total de episodios a grabar	50

4. Controles de teclado durante la grabación

Controla el flujo de grabación de datos usando atajos de teclado:

Tecla	Acción
→ (Flecha derecha)	Detener anticipadamente el episodio actual/reinicio; pasar al siguiente.
← (Flecha izquierda)	Cancelar el episodio actual; volver a grabarlo.
ESC	Detener la sesión inmediatamente, codificar los videos y subir el conjunto de datos.

tip

Si las pulsaciones de tu teclado no responden, es posible que necesites degradar tu versión de pynput, por ejemplo instalando la versión 1.6.8.

pip install pynput==1.6.8

Consejos para recopilar datos

Sugerencia de tarea: Agarra objetos en diferentes ubicaciones y colócalos en un contenedor.
Escala: Registra ≥50 episodios (10 episodios por ubicación).
Consistencia:
- Mantén las cámaras fijas.
- Mantén un comportamiento de agarre idéntico.
- Asegúrate de que los objetos manipulados sean visibles en las transmisiones de la cámara.
Progresión:
- Comienza con agarres fiables antes de añadir variaciones (nuevas ubicaciones, técnicas de agarre, ajustes de cámara).
- Evita aumentos rápidos de complejidad para prevenir fallos.

💡 Regla general: Deberías ser capaz de realizar la tarea tú mismo solo mirando las imágenes de la cámara en la pantalla.

Si quieres profundizar en este tema importante, puedes consultar la entrada del blog que escribimos sobre qué hace que un conjunto de datos sea bueno.

Solución de problemas

Problema específico de Linux: Si las teclas Flecha derecha/Flecha izquierda/ESC no responden durante la grabación:

Verifica que la variable de entorno $DISPLAY esté configurada (consulta pynput limitations).

Visualizar el conjunto de datos

echo ${HF_USER}/rebot_test  

Si subiste los datos, también puedes visualizarlos localmente con el siguiente comando:

lerobot-dataset-viz \
  --repo-id ${HF_USER}/rebot_test \
  --episode-index 0 \
  --display-compressed-images=false

Si usaste --dataset.push_to_hub=false y no subiste los datos, también puedes visualizarlos localmente con:

lerobot-dataset-viz \
  --repo-id seeed_rebot_b601_dm/test \
  --episode-index 0 \
  --display-compressed-images=false

Aquí, seeed_rebot_b601_dm/test es el nombre personalizado de repo_id definido durante la recopilación de datos.

Reproducir un episodio

tip

Inestable, se puede omitir o probar.

Ahora, intenta reproducir el primer conjunto de datos en tu robot:

lerobot-replay \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.can_adapter=damiao \
    --robot.id=follower1 \
    --dataset.repo_id=seeed_rebot_b601_dm/test \
    --dataset.episode=0

En este punto, el robot debería realizar las mismas acciones que cuando lo teleoperaste durante la grabación.

Entrenamiento y evaluación

ACT

Consulta el tutorial oficial ACT

Entrenamiento

Para entrenar una política que controle tu robot, usa el script python -m lerobot.scripts.train. Algunos parámetros son obligatorios. Aquí tienes un comando de ejemplo:

Si quieres entrenar en un conjunto de datos local, asegúrate de que el repo_id coincida con el nombre usado durante la recopilación de datos y añade --policy.push_to_hub=false.

lerobot-train \
  --dataset.repo_id=seeed_rebot_b601_dm/test \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --job_name=act_rebot_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.push_to_hub=false\
  --steps=300000 

O usa datos almacenados de forma remota

lerobot-train \
  --dataset.repo_id=${HF_USER}/rebot_test \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --job_name=act_rebot_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --steps=300000 

Explicación del comando

Especificación del conjunto de datos: Proporcionamos el conjunto de datos mediante el parámetro --dataset.repo_id=${HF_USER}/rebot_test.
Pasos de entrenamiento: Modificamos el número de pasos de entrenamiento usando --steps=300000. El algoritmo usa por defecto 800000 pasos, y puedes ajustarlo según la dificultad de tu tarea y observando la pérdida durante el entrenamiento.
Tipo de política: Proporcionamos la política con policy.type=act. Del mismo modo, puedes cambiar entre políticas como [act, diffusion, pi0, pi0fast, pi0fast, sac, smolvla]. Esto cargará la configuración desde configuration_act.py. Es importante destacar que esta política se adaptará automáticamente a los estados de los motores, las acciones de los motores y el número de cámaras de tu robot (por ejemplo, laptop y phone), ya que esta información ya está almacenada en tu conjunto de datos.
Selección de dispositivo: Proporcionamos policy.device=cuda porque estamos entrenando en una GPU Nvidia, pero puedes usar policy.device=mps para entrenar en Apple Silicon.
Herramienta de visualización: Proporcionamos wandb.enable=true para visualizar las gráficas de entrenamiento usando Weights and Biases. Esto es opcional, pero si lo usas, asegúrate de haber iniciado sesión ejecutando wandb login.

Evaluación

Puedes usar la función record de lerobot/record.py pero con un checkpoint de política como entrada. Por ejemplo, ejecuta este comando para registrar 10 episodios de evaluación:

lerobot-record \
  --robot.type=seeed_b601_dm_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.can_adapter=damiao \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --robot.id=follower1 \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/train/act_rebot_test/checkpoints/last/pretrained_model

El parámetro --policy.path indica la ruta al archivo de pesos de los resultados del entrenamiento de tu política (por ejemplo, outputs/train/act_rebot_test/checkpoints/last/pretrained_model). Si subes el archivo de pesos de los resultados del entrenamiento del modelo a Hub, también puedes usar el repositorio del modelo (por ejemplo, ${HF_USER}/act_rebot_test).
El nombre del conjunto de datos dataset.repo_id comienza con eval_. Esta operación registrará por separado vídeos y datos durante la evaluación, que se guardarán en la carpeta que comienza con eval_, como seeed/eval_test123.
Si encuentras File exists: 'home/xxxx/.cache/huggingface/lerobot/xxxxx/seeed/eval_xxxx' durante la fase de evaluación, elimina primero la carpeta que comienza con eval_ y luego ejecuta de nuevo el programa.
Cuando te encuentres con mean is infinity. You should either initialize with stats as an argument or use a pretrained model, ten en cuenta que palabras clave como front y side en el parámetro --robot.cameras deben ser estrictamente coherentes con las usadas al recopilar el conjunto de datos.

SmolVLA

Consulta el tutorial oficial SmolVLA

pip install -e ".[smolvla]"

Entrenamiento

lerobot-train \
  --policy.path=lerobot/smolvla_base \ # <- Use pretrained fine-tuned model
  --dataset.repo_id=${HF_USER}/mydataset \
  --batch_size=64 \
  --steps=20000 \
  --output_dir=outputs/train/my_smolvla \
  --job_name=my_smolvla_training \
  --policy.device=cuda \
  --wandb.enable=true

Evaluación

lerobot-record \
  --robot.type=seeed_b601_dm_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.can_adapter=damiao \
  --robot.id=follower1 \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --dataset.single_task="Put lego brick into the transparent box" \
  --dataset.repo_id=seeed/eval_test123 \
  --dataset.episode_time_s=50 \
  --dataset.num_episodes=10 \
  # <- Teleop optional if you want to teleoperate in between episodes \
  # --teleop.type=rebot_arm_102_leader \
  # --teleop.port=/dev/ttyUSB0 \
  # --teleop.id=rebot_arm_102_leader \
  --policy.path=HF_USER/FINETUNE_MODEL_NAME

Pi0

Consulta el tutorial oficial Pi0

pip install -e ".[pi]"

Entrenamiento

lerobot-train \
  --policy.type=pi0 \
  --dataset.repo_id=seeed/eval_test123 \
  --job_name=pi0_training \
  --output_dir=outputs/pi0_training \
  --policy.pretrained_path=lerobot/pi0_base \
  --policy.compile_model=true \
  --policy.gradient_checkpointing=true \
  --policy.dtype=bfloat16 \
  --steps=20000 \
  --policy.device=cuda \
  --batch_size=32 \
  --wandb.enable=false 

Evaluación

lerobot-record \
  --robot.type=seeed_b601_dm_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.can_adapter=damiao \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --robot.id=follower1 \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/pi0_training/checkpoints/last/pretrained_model

Pi0.5

Consulta el tutorial oficial Pi0.5

pip install -e ".[pi]"

Entrenamiento

lerobot-train \
    --dataset.repo_id=seeed/eval_test123 \
    --policy.type=pi05 \
    --output_dir=outputs/pi05_training \
    --job_name=pi05_training \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.compile_model=true \
    --policy.gradient_checkpointing=true \
    --wandb.enable=false \
    --policy.dtype=bfloat16 \
    --steps=3000 \
    --policy.device=cuda \
    --batch_size=32

Evaluación

lerobot-record \
  --robot.type=seeed_b601_dm_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.can_adapter=damiao \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --robot.id=follower1 \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/pi05_training/checkpoints/last/pretrained_model

GR00T N1.5

Consulta la documentación oficial: GR00T N1.5

El entrenamiento debería tardar varias horas. Encontrarás los checkpoints en el directorio outputs/train/act_rebot_test/checkpoints.

Para reanudar el entrenamiento desde un checkpoint, aquí tienes un comando de ejemplo para reanudar desde el checkpoint last de la política act_rebot_test:

lerobot-train \
  --config_path=outputs/train/act_rebot_test/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

Preguntas frecuentes (FAQ)

Si estás siguiendo este tutorial de documentación, por favor haz git clone del repositorio de GitHub recomendado https://github.com/Seeed-Projects/lerobot.git. El repositorio recomendado en esta documentación es una versión estable verificada; el repositorio oficial de LeRobot se actualiza continuamente a la última versión, lo que puede causar problemas imprevistos como diferentes versiones de conjuntos de datos, diferentes comandos, etc.
Si te encuentras con:
```
Could not connect on port "/dev/ttyUSB0" or "/dev/ttyACM0"
```
Y puedes ver que el dispositivo existe al ejecutar ls /dev/ttyUSB* o ls /dev/ttyACM*, significa que olvidaste otorgar permisos al puerto serie. Introduce sudo chmod 666 /dev/ttyUSB* /dev/ttyACM* en la terminal para solucionarlo.
Si te encuentras con:
```
No valid stream found in input file. Is -1 of the desired media type?
```
Instala ffmpeg 7.1.1 usando conda install ffmpeg=7.1.1 -c conda-forge.
Entrenar ACT con 50 conjuntos de datos lleva aproximadamente 6 horas en un portátil con una RTX 3060 (8GB), y alrededor de 2-3 horas en ordenadores con GPUs RTX 4090 o A100.
Durante la recopilación de datos, asegúrate de que la posición de la cámara, el ángulo y la iluminación ambiental sean estables. Reduce la cantidad de fondo inestable y de peatones capturados por la cámara, ya que cambios excesivos en el entorno de despliegue pueden hacer que el brazo robótico no pueda agarrar correctamente.
Para el comando de recopilación de datos, asegúrate de que el parámetro num-episodes esté configurado para recopilar suficientes datos. No pauses manualmente a mitad de camino, ya que la media y la varianza de los datos se calculan solo después de que la recopilación de datos se haya completado, y son necesarias para el entrenamiento.
Si el programa indica que no puede leer datos de imagen desde la cámara USB, asegúrate de que la cámara USB no esté conectada a través de un hub. La cámara USB debe estar conectada directamente al dispositivo para garantizar una alta velocidad de transmisión de imágenes.

tip

Si encuentras problemas de software o de dependencias de entorno que no puedas resolver, además de consultar la sección de Preguntas Frecuentes (FAQ) al final de este tutorial, informa del problema de inmediato en la plataforma LeRobot o en el canal de Discord de LeRobot.

Referencias

Wiki en inglés de Seeed Studio: Cómo usar el brazo robótico SO100Arm en Lerobot

Proyecto TheRobotStudio: SO-ARM10x

Proyecto Huggingface: LeRobot

Dnsty: Jetson Containers

Soporte técnico y debate sobre el producto

¡Gracias por elegir nuestros productos! Estamos aquí para ofrecerte diferentes tipos de soporte y garantizar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para adaptarnos a diferentes preferencias y necesidades.

📖 Introducción al proyecto​

Construye tu brazo robótico reBot​

🔧 Características de la Serie reBot B601-DM:​

Entorno inicial del sistema​

Instalar LeRobot​

1. Instalar Miniforge​

2. Clonar el repositorio Lerobot​

3. Clonar paquetes de funciones​

4. Crear entorno Conda e instalar LeRobot​

5. Instalar ffmpeg​

6. Configuración especial para dispositivos Jetson JetPack 6.0+​

7. Comprobar Pytorch y Torchvision​

Calibrar el brazo robótico​

Calibrar el brazo seguidor​

Calibrar el brazo líder​

Teleoperación​

Añadir cámaras​

RealSense D405​

RealSense D435i​

1. Cambiar a la rama de cámara​

2. Instalar LeRobot en modo editable​

3. Otorgar permisos​

4. Detectar cámaras​

5. Ejemplo de RealSense​

6. Notas sobre los parámetros​

1. Cambiar a la rama de cámara​

2. Instalar LeRobot en modo editable​

3. Conceder permisos​

4. Detectar cámaras​

5. Ejemplo de Orbbec​

6. Notas sobre parámetros​

7. Problemas comunes​

Recopilación de conjuntos de datos​

Visualizar el conjunto de datos​

Reproducir un episodio​

Entrenamiento y evaluación​

Preguntas frecuentes (FAQ)​

Referencias​

Soporte técnico y debate sobre el producto​

📖 Introducción al proyecto

Construye tu brazo robótico reBot

🔧 Características de la Serie reBot B601-DM:

Entorno inicial del sistema

Instalar LeRobot

1. Instalar Miniforge

2. Clonar el repositorio Lerobot

3. Clonar paquetes de funciones

4. Crear entorno Conda e instalar LeRobot

5. Instalar ffmpeg

6. Configuración especial para dispositivos Jetson JetPack 6.0+

7. Comprobar Pytorch y Torchvision

Calibrar el brazo robótico

Calibrar el brazo seguidor

Calibrar el brazo líder

Teleoperación

Añadir cámaras

RealSense D405

RealSense D435i

1. Cambiar a la rama de cámara

2. Instalar LeRobot en modo editable

3. Otorgar permisos

4. Detectar cámaras

5. Ejemplo de RealSense

6. Notas sobre los parámetros

1. Cambiar a la rama de cámara

2. Instalar LeRobot en modo editable

3. Conceder permisos

4. Detectar cámaras

5. Ejemplo de Orbbec

6. Notas sobre parámetros

7. Problemas comunes

Recopilación de conjuntos de datos

Visualizar el conjunto de datos

Reproducir un episodio

Entrenamiento y evaluación

Preguntas frecuentes (FAQ)

Referencias

Soporte técnico y debate sobre el producto