Guia rápido

Todos os comandos do LeRobot em um só lugar. Se você esqueceu como usar um comando específico ou deseja conhecer um novo, pode fazer isso aqui.

Lembre-se de alterar as portas/nomes/ids para os seus próprios valores em todos os comandos listados abaixo!

Outra ótima maneira de visualizar todos os comandos e configurá-los para o seu ambiente específico é usar este Jupyter Notebook.

Configuração e instalação

Para a instalação, consulte Instalação do LeRobot.

Ferramentas úteis

Encontrar porta

Use isso para identificar em quais portas seriais seus robôs estão conectados. Siga as instruções no terminal: você será solicitado a desconectar o cabo USB e pressionar Enter. O script, então, detectará e exibirá a porta serial correta para aquele robô.

lerobot-find-port

Encontrar câmeras

Encontre rapidamente os índices das câmeras e verifique sua saída. Este comando imprime as informações das câmeras no terminal e salva quadros de teste de cada câmera detectada em outputs/captured_images

lerobot-find-cameras

Calibração

Na maioria dos casos, você precisará realizar a calibração apenas uma vez para cada robô e dispositivo de teleoperação. Antes de realizar a calibração, verifique se todas as juntas estão aproximadamente na posição intermediária.

lerobot-calibrate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm

Certifique-se de usar os mesmos IDs usados durante a calibração nos outros scripts. É assim que o LeRobot localiza os arquivos de calibração.

Teleoperação

Teleoperando com duas câmeras e exibindo os dados com Rerun.

lerobot-teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --display_data=true

Gravando um conjunto de dados

O conjunto de dados é enviado automaticamente para o Hugging Face Hub em repo_id. Certifique-se de que você está conectado à sua conta do HF com a CLI (você pode obter um token em https://huggingface.co/settings/tokens) e armazene seu nome de usuário em HF_USER, que os comandos abaixo utilizam:

lerobot-record \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --dataset.repo_id=${HF_USER}/so101_dataset_test \
    --dataset.num_episodes=30 \
    --dataset.single_task="put the red brick in a bowl" \
    --dataset.streaming_encoding=true \
    --display_data=true

Enquanto você coleta o conjunto de dados, pode controlar o processo pelo teclado:

• Pressione Seta para a direita (→) ou n: Salva o episódio e move para o próximo.
• Pressione Seta para a esquerda (←) ou r: Exclui o episódio atual e tenta novamente.
• Pressione Escape (ESC) ou q: parar, codificar vídeos e enviar.

lerobot-record adiciona a data e a hora da sessão ao final de --dataset.repo_id, portanto ${HF_USER}/so101_dataset_test é salvo como ${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS. Encontre o nome completo no seu perfil do Hugging Face ou com ls ~/.cache/huggingface/lerobot/${HF_USER}, e use-o nos comandos de treinamento abaixo. Adicione --dataset.no_stamp=true para manter o nome exato.

Profundidade de gravação

As câmeras Intel RealSense (type: intelrealsense) gravam um fluxo de profundidade quando você define use_depth: true. A profundidade é quantizada em códigos de 12 bits e armazenada como um vídeo próprio.

lerobot-record \
    ... \
    --robot.cameras="{ head: {type: intelrealsense, serial_number_or_name: \"0123456789\", width: 640, height: 480, fps: 30, use_depth: true} }" \
    --dataset.repo_id=${HF_USER}/so101_depth_test \
    --dataset.single_task="put the red brick in a bowl" \
    --dataset.depth_encoder.depth_min=0.01 \
    --dataset.depth_encoder.depth_max=10.0 \
    --dataset.depth_encoder.shift=0.0 \
    --dataset.depth_encoder.use_log=true

Parâmetros de codificação de vídeo

Os fluxos RGB e de profundidade são codificados de forma independente por meio das chaves --dataset.rgb_encoder.* e --dataset.depth_encoder.*.

lerobot-record \
    ... \
    --dataset.rgb_encoder.vcodec=h264 \
    --dataset.rgb_encoder.pix_fmt=yuv420p \
    --dataset.rgb_encoder.crf=23 \
    --dataset.depth_encoder.vcodec=hevc \
    --dataset.depth_encoder.extra_options='{"x265-params": "lossless=1"}'

Treinamento

Dependendo do seu hardware, o treinamento da política pode levar algumas horas. É assim que você treina uma política simples de ACT:

lerobot-train \
    --dataset.repo_id=${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS \
    --policy.type=act \
    --output_dir=outputs/train/act_so101_test \
    --job_name=act_so101_test \
    --policy.device=cuda \
    --trackio.enable=true \
    --policy.repo_id=${HF_USER}/policy_test \
    --steps=20000

• Tipos de política comuns: act, diffusion, multi_task_dit, smolvla, pi0, pi05, pi0_fast, groot, xvla. Cada política possui sua própria página sob Policies na barra lateral, e o Compute & Hardware Guide mostra quais delas se adequam à sua GPU.
• Dispositivos: cuda (NVIDIA), mps (Apple Silicon), cpu

--policy.type cria uma nova política desse tipo e a treina do zero no seu conjunto de dados (algumas políticas ainda partem de backbones de visão ou linguagem pré-treinados, conforme definido em suas configurações). Para fazer o ajuste fino de um modelo existente, passe --policy.path com um checkpoint local ou um id de repositório do Hub: o tipo e a configuração da política são lidos a partir dele, portanto --policy.type não é necessário.

lerobot-train \
    --dataset.repo_id=${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS \
    --policy.path=username/the_policy_to_finetune \
    --policy.device=cuda \
    --policy.repo_id=${HF_USER}/policy_finetuned_test \
    --output_dir=outputs/train/finetuned_so101_test \
    --steps=20000

Na GPU local? Adicione --job.target=<flavor> (por exemplo, a10g-small) a qualquer um dos comandos e o lerobot-train o executará nos Hugging Face Jobs — ele faz o upload de um dataset apenas local para você e envia o modelo treinado. Liste os sabores com hf jobs hardware. Para acompanhar as métricas do job, adicione --trackio.enable=true --trackio.space_id=<user>/<space>: o banco de dados local do Trackio no pod não sobrevive ao job.

Para retomar, aponte --config_path para um checkpoint e adicione --resume=true. Ele aceita um caminho local ou um id de repositório do Hub (o checkpoint mais recente é obtido) e funciona localmente ou em um job adicionando --job.target=<flavor>:

lerobot-train --config_path=${HF_USER}/policy_test --resume=true --job.target=a10g-small

Inferência

Inference significa executar a política/modelo treinado em um robô. Para isso, usamos lerobot-rollout. Você precisará fornecer um caminho para sua política. Pode ser um caminho local ou um id de repositório do Hugging Face, por exemplo ${HF_USER}/policy_test do comando de treinamento acima. Use a mesma porta, --robot.id, configuração de câmera e descrição da tarefa usadas na coleta do dataset. --duration está em segundos; se não for especificado, a política executa até que você a interrompa.

Na v0.5.x e versões anteriores, lerobot-rollout não existe e você precisa usar lerobot-record no lugar. Mais informações aqui.

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USER}/policy_test \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --task="put the red brick in a bowl" \
    --duration=60