Introdução ao uso do braço robótico StarAI com LeRobot

Follower Viola	Leader Violin	Follower Cello

Adquira agora!!! 🖱️

Introdução aos produtos

1. Open-Source e amigável para desenvolvedores É uma solução de braço robótico 6+1 DoF open-source e amigável para desenvolvedores da Fishion Star Technology Limited.
2. Integração com LeRobot Projetado para integração com a plataforma LeRobot, que fornece modelos PyTorch, conjuntos de dados e ferramentas para aprendizado por imitação em tarefas robóticas do mundo real — incluindo coleta de dados, simulação, treinamento e implantação.
3. Recursos de aprendizado abrangentes Fornece recursos de aprendizado open-source abrangentes, como guias de montagem e calibração e exemplos de tarefas personalizadas de preensão, para ajudar os usuários a começar rapidamente e desenvolver aplicações robóticas.
4. Compatível com Nvidia Suporta implantação na plataforma reComputer Mini J4012 Orin NX 16GB.

Principais recursos

• Pronto para uso — sem necessidade de montagem. Basta tirar da caixa e mergulhar no mundo da IA.
• 6+1 graus de liberdade e alcance de 470 mm — projetado para versatilidade e precisão.
• Alimentado por dois servos brushless em barramento — suave, silencioso e potente, com carga útil de até 300 g.
• Garra paralela com abertura máxima de 66 mm — pontas de dedos modulares para flexibilidade de substituição rápida.
• Tecnologia exclusiva Hover Lock — congele instantaneamente o braço líder em qualquer posição com um único pressionar.

Especificações

Item	Follower Arm | Viola	Leder Arm |Violin	Follower Arm |Cello
Degrees of Freedom	6+1	6+1	6+1
Reach	470mm	470mm	670mm
Repeatability	2mm	-	2mm
Working Payload	300g (with 70% Reach)	-	750g (with 70% Reach)
Servos	RX8-U50H-M x2 RA8-U25H-M x4 RA8-U26H-M x1	RX8-U50H-M x2 RA8-U25H-M x4 RA8-U26H-M x1	RX18-U100H-M x3 RX8-U50H-M x3 RX8-U51H-M x1
Parallel Gripper Ki	✅	-	✅
Wrist Rotate	Yes	Yes	Yes
Hold at any Position	Yes	Yes (with handle button)	Yes
Wrist Camera Mount	Provides reference 3D printing files		Provides reference 3D printing files
Works with LeRobot	✅	✅	✅
Works with ROS 2	✅	✅	✅
Works with MoveIt2	✅	✅	✅
Works with Gazebo	✅	✅	✅
Communication Hub	UC-01	UC-01	UC-01
Power Supply	12V10A/120w XT30	12V10A/120w XT30	12V25A/300w XT60

Para mais informações sobre motores de servo, visite o seguinte link.

RA8-U25H-M

RX18-U100H-M

RX8-U50H-M

Configuração inicial do ambiente

Para Ubuntu x86:

• Ubuntu 22.04
• CUDA 12+
• Python 3.12
• Torch 2.6

Para Jetson Orin:

• Jetson JetPack 6.0+
• Python 3.12
• Torch 2.6

Instalação e depuração

Instalar LeRobot

Ambientes como pytorch e torchvision precisam ser instalados com base na sua versão do CUDA.

1. Instale o Miniconda: Para Jetson:

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh
chmod +x Miniconda3-latest-Linux-aarch64.sh
./Miniconda3-latest-Linux-aarch64.sh
source ~/.bashrc

Ou, para Ubuntu 22.04 x86:

mkdir -p ~/miniconda3
cd miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm ~/miniconda3/miniconda.sh
source ~/miniconda3/bin/activate
conda init --all

2. Crie e ative um novo ambiente conda para o lerobot

conda create -y -n lerobot python=3.12 && conda activate lerobot

3. Clone o Lerobot:

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

4. Ao usar o miniconda, instale o ffmpeg em seu ambiente:

conda install ffmpeg -c conda-forge

dica

Isso geralmente instala o ffmpeg 7.X para a sua plataforma, compilado com o codificador libsvtav1. Se o libsvtav1 não for suportado (verifique os codificadores suportados com ffmpeg -encoders), você pode:

• [Em qualquer plataforma] Instalar explicitamente o ffmpeg 7.X usando:

conda install ffmpeg=7.1.1 -c conda-forge

• [Somente no Linux] Instalar as dependências de compilação do ffmpeg e compilar o ffmpeg a partir do código-fonte com libsvtav1, certificando-se de usar o binário ffmpeg correspondente à sua instalação com which ffmpeg.

5. Instale o LeRobot:

cd ~/lerobot && pip install -e .

sudo apt remove brltty

Para dispositivos Jetson Jetpack (certifique-se de instalar Pytorch-gpu e Torchvision a partir da etapa 5 antes de executar esta etapa):

conda install -y -c conda-forge "opencv>=4.10.0.84"  # Install OpenCV and other dependencies through conda, this step is only for Jetson Jetpack 6.0+
conda remove opencv   # Uninstall OpenCV 
pip3 install opencv-python==4.10.0.84  # Then install opencv-python via pip3
conda install -y -c conda-forge ffmpeg
conda uninstall numpy
pip3 install numpy==1.26.0  # This should match torchvision

6.Install Fashionstar Motor Dependencies:

pip install lerobot_teleoperator_bimanual_leader
pip install lerobot_robot_bimanual_follower

7. Verifique o Pytorch e o Torchvision

Como instalar o ambiente lerobot via pip desinstalará o Pytorch e o Torchvision originais e instalará as versões de CPU do Pytorch e do Torchvision, você precisa realizar uma verificação em Python.

import torch
print(torch.cuda.is_available())

Se o resultado impresso for False, você precisará reinstalar o Pytorch e o Torchvision de acordo com o tutorial oficial do site.

Se você estiver usando um dispositivo Jetson, instale o Pytorch e o Torchvision de acordo com este tutorial.

Desembalando o braço robótico

O kit do braço robótico inclui

• Braço líder
• Braço seguidor
• Controlador (manete)
• Garra paralela
• Ferramentas de instalação (parafusos, chave sextavada)
• Braçadeira em C ×2
• Placa de depuração UC-01 ×2

Interruptor da placa de depuração UC-01：

Configurar porta do braço

Entre no diretório ~/lerobot:

cd ~/lerobot

Execute o seguinte comando no terminal para encontrar as portas USB associadas aos seus braços：

lerobot-find-port

dica

Lembre-se de remover o USB, caso contrário a interface não será detectada.

Por exemplo：

1. Exemplo de saída ao identificar a porta do braço líder (por exemplo, /dev/tty.usbmodem575E0031751 no Mac, ou possivelmente /dev/ttyUSB0 no Linux):
2. Exemplo de saída ao identificar a porta do braço seguidor (por exemplo, /dev/tty.usbmodem575E0032081no Mac, ou possivelmente /dev/ttyUSB1 no Linux):

dica

Se a porta serial ttyUSB0 não puder ser identificada, tente as seguintes soluções:

Liste todas as portas USB.

lsusb

Depois de identificada, verifique as informações da ttyusb.

sudo dmesg | grep ttyUSB

A última linha indica uma desconexão porque o brltty está ocupando a USB. Remover o brltty resolverá o problema.

sudo apt remove brltty

Por fim, use o comando chmod.

sudo chmod 777 /dev/ttyUSB*

Talvez você precise conceder acesso às portas USB executando:

sudo chmod 666 /dev/ttyUSB*

Calibrar

Para vídeos que cobrem o braço robótico StarAI desde o unboxing até a teleoperação, você pode consultar:

Mova o braço robótico para a posição inicial do braço robótico (conforme mostrado na figura abaixo) e coloque-o em modo de espera, depois reconecte a fonte de alimentação.

Para a posição inicial da nova versão do braço robótico, deve-se prestar atenção especial para garantir que os servos das juntas 3, 4 e 5 estejam estritamente alinhados com as posições na figura.

Novo braço líder de violino	Antigo braço líder de violino	Braço seguidor de viola	Braço seguidor de violoncelo

Por exemplo:

Braço líder de violino	Braço seguidor de viola

dica

Tomando o PC (Linux) e a placa Jetson como exemplos, o primeiro dispositivo USB inserido será mapeado para ttyUSB0, e o segundo dispositivo USB inserido será mapeado para ttyUSB1.

Preste atenção às interfaces de mapeamento do líder e do seguidor antes de executar o código.

Braço robótico líder

Conecte o líder a /dev/ttyUSB0, ou modifique o parâmetro --teleop.port e, em seguida, execute:

lerobot-calibrate     --teleop.type=lerobot_teleoperator_violin --teleop.port=/dev/ttyUSB0 --teleop.id=my_awesome_staraiviolin_arm

Após a inicialização, você verá os valores do codificador de cada junta. Você precisa calibrar manualmente cada junta uma por uma: gire cada junta até suas posições máxima e mínima. Para juntas sem batentes de limite, o intervalo de rotação não deve exceder 180° no sentido horário ou 180° no sentido anti-horário. Depois de calibrar todas as juntas, pressione Enter para salvar as configurações.

Braço robótico seguidor

Conecte o seguidor a /dev/ttyUSB1, ou modifique o parâmetro --teleop.port e, em seguida, execute:

Viola:

lerobot-calibrate     --robot.type=lerobot_robot_viola --robot.port=/dev/ttyUSB1 --robot.id=my_awesome_staraiviola_arm

Violoncelo:

lerobot-calibrate     --robot.type=lerobot_robot_cello --robot.port=/dev/ttyUSB1 --robot.id=my_awesome_staraicello_arm

Após a inicialização, você verá os valores do codificador de cada junta. Você precisa calibrar manualmente cada junta uma por uma: gire cada junta até suas posições máxima e mínima. Para juntas sem batentes de limite, o intervalo de rotação não deve exceder 180° no sentido horário ou 180° no sentido anti-horário. Depois de calibrar todas as juntas, pressione Enter para salvar as configurações.

dica

Os arquivos de calibração serão salvos nos seguintes caminhos: ~/.cache/huggingface/lerobot/calibration/robots e ~/.cache/huggingface/lerobot/calibration/teleoperators.

Configuração de calibração de dois braços

Tutorial

Braço robótico líder

Conecte left_arm_port a /dev/ttyUSB0 e right_arm_port a /dev/ttyUSB2, ou modifique os parâmetros --teleop.left_arm_port e --teleop.right_arm_port e, em seguida, execute:

lerobot-calibrate     --teleop.type=lerobot_teleoperator_bimanual_leader  --teleop.left_arm_port=/dev/ttyUSB0  --teleop.right_arm_port=/dev/ttyUSB2  --teleop.id=bi_starai_violin_leader

Após a inicialização, você verá os valores do codificador de cada junta. Você precisa calibrar manualmente cada junta uma por uma: gire cada junta até suas posições máxima e mínima. Para juntas sem batentes de limite, o intervalo de rotação não deve exceder 180° no sentido horário ou 180° no sentido anti-horário. Depois de calibrar todas as juntas, pressione Enter para salvar as configurações.

Braço robótico seguidor

Conecte left_arm_port a /dev/ttyUSB1 e right_arm_port a /dev/ttyUSB3, ou modifique os parâmetros --robot.left_arm_port e --robot.right_arm_port e, em seguida, execute:

Vioa:

lerobot-calibrate     --robot.type=lerobot_robot_bimanual_follower  --robot.arm_name=starai_viola  --robot.left_arm_port=/dev/ttyUSB1  --robot.right_arm_port=/dev/ttyUSB3 --robot.id=bi_starai_viola_follower

Violoncelo:

lerobot-calibrate     --robot.type=lerobot_robot_bimanual_follower  --robot.arm_name=starai_cello  --robot.left_arm_port=/dev/ttyUSB1  --robot.right_arm_port=/dev/ttyUSB3 --robot.id=bi_starai_cello_follower

Após a inicialização, você verá os valores do codificador de cada junta. Você precisa calibrar manualmente cada junta uma por uma: gire cada junta até suas posições máxima e mínima. Para juntas sem batentes de limite, o intervalo de rotação não deve exceder 180° no sentido horário ou 180° no sentido anti-horário. Depois de calibrar todas as juntas, pressione Enter para salvar as configurações.

dica

A diferença entre as configurações de braço único e de dois braços está nos parâmetros --teleop.type e --robot.type. Além disso, configurações de dois braços exigem portas USB separadas para os braços esquerdo e direito, totalizando quatro portas USB: --teleop.left_arm_port, --teleop.right_arm_port, --robot.left_arm_port e --robot.right_arm_port.

Se estiver usando uma configuração de dois braços, você precisa modificar manualmente os tipos de arquivo do braço robótico --teleop.type e --robot.type, bem como as portas USB --teleop.left_arm_port, --teleop.right_arm_port, --robot.left_arm_port e --robot.right_arm_port, para se adaptar aos comandos de teleoperação, coleta de dados, treinamento e avaliação.

Teleoperar

Mova o braço para a posição mostrada no diagrama e coloque-o em espera.

Braço líder de violino	Braço seguidor de viola

Então você está pronto para teleoperar seu robô (não exibirá as câmeras)! Execute este script simples:

Violino&Viola:

lerobot-teleoperate \
    --robot.type=lerobot_robot_viola \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraiviola_arm \
    --teleop.type=lerobot_teleoperator_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm

Violino&Violoncelo:

lerobot-teleoperate \
    --robot.type=lerobot_robot_cello \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraicello_arm \
    --teleop.type=lerobot_teleoperator_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm

Dois braços

Violino&Viola:

lerobot-teleoperate \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_viola \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_viola_follower \
    --teleop.type=lerobot_teleoperator_bimanual_leader \
    --teleop.left_arm_port=/dev/ttyUSB0 \
    --teleop.right_arm_port=/dev/ttyUSB2 \
    --teleop.id=bi_starai_violin_leader

Violino&Violoncelo:

lerobot-teleoperate \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_cello \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_cello_follower \
    --teleop.type=lerobot_teleoperator_bimanual_leader \
    --teleop.left_arm_port=/dev/ttyUSB0 \
    --teleop.right_arm_port=/dev/ttyUSB2 \
    --teleop.id=bi_starai_violin_leader

O comando de operação remota detectará automaticamente os seguintes parâmetros:

1. Identificar quaisquer calibrações ausentes e iniciar o procedimento de calibração.
2. Conectar o robô e o dispositivo de operação remota e iniciar a operação remota.

Após o início do programa, a tecnologia Hover Lock permanece funcional.

Adicionar câmeras

Se estiver usando a câmera de profundidade Orbbec Gemini2

Adquira agora 🖱️

• 🚀 Etapa 1: Instale o ambiente de dependências do Orbbec SDK

1. Clone o repositório pyorbbec

   cd ~/
   git clone https://github.com/orbbec/pyorbbecsdk.git

2. Baixe e instale o arquivo .whl correspondente para o SDK
   Vá para pyorbbecsdk Releases,
   selecione e instale com base na sua versão do Python. Por exemplo:

   pip install pyorbbecsdk-x.x.x-cp310-cp310-linux_x86_64.whl

3. Instale as dependências no diretório pyorbbec

   cd ~/pyorbbecsdk
   pip install -r requirements.txt

   Force o downgrade da versão do numpy para 1.26.0

   pip install numpy==1.26.0

Mensagens de erro em vermelho podem ser ignoradas.

4. Clone o Orbbec SDK no diretório ~/lerobot/src/cameras

cd ~/lerobot/src/cameras
git clone https://github.com/ZhuYaoHui1998/orbbec.git

5. Modifique utils.py e init.py

• Encontre utils.py no diretório ~/lerobot/src/lerobot/cameras e adicione o seguinte código na linha 40:

elif cfg.type == "orbbec":
            from .orbbec.camera_orbbec import OrbbecCamera

            cameras[key] = OrbbecCamera(cfg)

• Encontre __init__.py no diretório ~/lerobot/src/lerobot/cameras e adicione o seguinte código na linha 18:

from .orbbec.configuration_orbbec import OrbbecCameraConfig

• 🚀 Etapa 2: Chamada de função e exemplos

Em todos os exemplos a seguir, substitua starai_viola pelo modelo real do braço robótico que você está usando (por exemplo, so100 / so101).

Adicionamos o hiperparâmetro focus_area. Como dados de profundidade muito distantes são sem sentido para o braço robótico (ele não consegue alcançar ou agarrar objetos), dados de profundidade menores ou maiores que o focus_area serão exibidos em preto. O focus_area padrão é (20, 600).
Atualmente, a única resolução suportada é largura: 640, altura: 880.

Violin&Viola:

lerobot-teleoperate \
    --robot.type=lerobot_starai_viola \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraiviola_arm \
    --robot.cameras="{ up: {type: orbbec, width: 640, height: 880, fps: 30, focus_area:[60,300]}}" \
    --teleop.type=starai_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm \
    --display_data=true

Violin&Cello:

lerobot-teleoperate \
    --robot.type=lerobot_starai_cello \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraicello_arm \
    --robot.cameras="{ up: {type: orbbec, width: 640, height: 880, fps: 30, focus_area:[60,300]}}" \
    --teleop.type=starai_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm \
    --display_data=true

Para tarefas subsequentes, como coleta de dados, treinamento e avaliação, o processo é o mesmo que para comandos RGB comuns. Você só precisa substituir a parte relevante no comando RGB comum por:

--robot.cameras="{ front: {type: orbbec, width: 640, height: 880, fps: 30, focus_area:(20,600)}}" \

Você também pode adicionar posteriormente uma câmera RGB monocular adicional.

Depois de conectar suas duas câmeras USB, execute o seguinte script para verificar os números de porta das câmeras. É importante lembrar que a câmera não deve ser conectada a um USB Hub; em vez disso, ela deve ser conectada diretamente ao dispositivo. A velocidade mais lenta de um USB Hub pode resultar na impossibilidade de ler os dados de imagem.

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

O terminal imprimirá as seguintes informações. Por exemplo, a câmera do laptop é o index 2 e a câmera USB é o index 4.

--- Detected Cameras ---
Camera #0:
  Name: OpenCV Camera @ /dev/video2
  Type: OpenCV
  Id: /dev/video2
  Backend api: V4L2
  Default stream profile:
    Format: 0.0
    Width: 640
    Height: 480
    Fps: 30.0
--------------------
Camera #1:
  Name: OpenCV Camera @ /dev/video4
  Type: OpenCV
  Id: /dev/video4
  Backend api: V4L2
  Default stream profile:
    Format: 0.0
    Width: 640
    Height: 360
    Fps: 30.0
--------------------

Finalizing image saving...
Image capture finished. Images saved to outputs/captured_images

Você pode encontrar as imagens capturadas por cada câmera no diretório outputs/images_from_opencv_cameras e verificar as informações de índice de porta correspondentes às câmeras em diferentes posições.

Depois de confirmar as câmeras externas, substitua as informações de câmera abaixo pelas informações reais da sua câmera, e você poderá exibir as câmeras no seu computador durante a operação remota:

Violin&Viola:

lerobot-teleoperate \
    --robot.type=lerobot_robot_viola \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraiviola_arm \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=lerobot_teleoperator_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm \
    --display_data=true

dica

Imagens no formato fourcc: "MJPG" são compactadas. Você pode tentar resoluções mais altas e também pode experimentar o formato YUYV. No entanto, este último reduzirá a resolução da imagem e o FPS, causando lentidão na operação do braço robótico. Atualmente, no formato MJPG, é possível suportar 3 câmeras com resolução de 1920*1080 mantendo 30FPS. Dito isso, ainda não é recomendado conectar 2 câmeras a um computador através do mesmo USB HUB.

Violin&Cello:

lerobot-teleoperate \
    --robot.type=lerobot_robot_cello \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraicello_arm \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=lerobot_teleoperator_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm \
    --display_data=true

dica

Imagens no formato fourcc: "MJPG" são compactadas. Você pode tentar resoluções mais altas e também pode experimentar o formato YUYV. No entanto, este último reduzirá a resolução da imagem e o FPS, causando lentidão na operação do braço robótico. Atualmente, no formato MJPG, é possível suportar 3 câmeras com resolução de 1920*1080 mantendo 30FPS. Dito isso, ainda não é recomendado conectar 2 câmeras a um computador através do mesmo USB HUB.

Dual-Arm

Violin&Viola:

lerobot-teleoperate \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_viola \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_viola_follower \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=lerobot_teleoperator_bimanual_leader \
    --teleop.left_arm_port=/dev/ttyUSB0 \
    --teleop.right_arm_port=/dev/ttyUSB2 \
    --teleop.id=bi_starai_violin_leader \
    --display_data=true

Violin&Cello:

lerobot-teleoperate \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_cello \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_cello_follower \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=lerobot_teleoperator_bimanual_leader \
    --teleop.left_arm_port=/dev/ttyUSB0 \
    --teleop.right_arm_port=/dev/ttyUSB2 \
    --teleop.id=bi_starai_violin_leader \
    --display_data=true

dica

Imagens no formato fourcc: "MJPG" são compactadas. Você pode tentar resoluções mais altas e também pode experimentar o formato YUYV. No entanto, este último reduzirá a resolução da imagem e o FPS, causando lentidão na operação do braço robótico. Atualmente, no formato MJPG, é possível suportar 3 câmeras com resolução de 1920*1080 mantendo 30FPS. Dito isso, ainda não é recomendado conectar 2 câmeras a um computador através do mesmo USB HUB.

dica

Se você encontrar um bug como este.

Você pode fazer o downgrade da versão do rerun para resolver o problema.

pip3 install rerun-sdk==0.23

Registrar o dataset

Depois que você estiver familiarizado com a teleoperação, poderá gravar seu primeiro conjunto de dados.

Se você quiser usar os recursos do Hub do Hugging Face para enviar seu conjunto de dados e ainda não fez isso antes, certifique-se de ter feito login usando um token com permissão de escrita, que pode ser gerado em Hugging Face settings:

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

Armazene o nome do seu repositório do Hugging Face em uma variável para executar estes comandos:

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

Grave 10 episódios e envie seu conjunto de dados para o hub:

Violin&Viola:

lerobot-record \
    --robot.type=lerobot_robot_viola \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraiviola_arm \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=lerobot_teleoperator_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm \
    --display_data=true \
    --dataset.repo_id=starai/record-test \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 \
    --dataset.num_episodes=10 \
    --dataset.push_to_hub=True \
    --dataset.single_task="Grab the black cube"

Violin&Cello:

lerobot-record \
    --robot.type=lerobot_robot_cello \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraicello_arm \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=lerobot_teleoperator_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm \
    --display_data=true \
    --dataset.repo_id=starai/record-test \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 \
    --dataset.num_episodes=10 \
    --dataset.push_to_hub=True \
    --dataset.single_task="Grab the black cube"

Dual-Arm

Violin&Viola:

lerobot-record \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_viola \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_viola_follower \
    --teleop.type=lerobot_teleoperator_bimanual_leader \
    --teleop.left_arm_port=/dev/ttyUSB0 \
    --teleop.right_arm_port=/dev/ttyUSB2 \
    --teleop.id=bi_starai_violin_leader \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --display_data=true \
    --dataset.repo_id=starai/record-test_bi_arm \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 \
    --dataset.num_episodes=10 \
    --dataset.push_to_hub=True \
    --dataset.single_task="Grab the black cube"

Violin&Cello:

lerobot-record \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_cello \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_cello_follower \
    --teleop.type=lerobot_teleoperator_bimanual_leader \
    --teleop.left_arm_port=/dev/ttyUSB0 \
    --teleop.right_arm_port=/dev/ttyUSB2 \
    --teleop.id=bi_starai_violin_leader \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --display_data=true \
    --dataset.repo_id=starai/record-test_bi_arm \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 \
    --dataset.num_episodes=10 \
    --dataset.push_to_hub=True \
    --dataset.single_task="Grab the black cube"

dica

Para diferenciar entre configurações de braço único e de dois braços, o --dataset.repo_id aqui é nomeado como starai/record-test_bi_arm.

dica

Se você não quiser usar o recurso de envio de conjuntos de dados para o Hugging Face Hub, pode escolher --dataset.push_to_hub=false. Além disso, substitua --dataset.repo_id=${HF_USER}/starai por um nome de pasta local personalizado, por exemplo, --dataset.repo_id=starai/record-test. Os dados serão armazenados em ~/.cache/huggingface/lerobot no diretório home do sistema.

Sem enviar para o Hub:

Violin&Viola:

lerobot-record \
    --robot.type=lerobot_robot_viola \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraiviola_arm \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=lerobot_teleoperator_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm \
    --display_data=true \
    --dataset.repo_id=starai/record-test \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 \
    --dataset.num_episodes=10 \
    --dataset.push_to_hub=False \
    --dataset.single_task="Grab the black cube"

Violin&Cello:

lerobot-record \
    --robot.type=lerobot_robot_cello \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraicello_arm \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=lerobot_teleoperator_violin \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=my_awesome_staraiviolin_arm \
    --display_data=true \
    --dataset.repo_id=starai/record-test \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 \
    --dataset.num_episodes=10 \
    --dataset.push_to_hub=False \
    --dataset.single_task="Grab the black cube"

Dual-Arm

Violin&Viola:

lerobot-record \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_viola \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_viola_follower \
    --teleop.type=lerobot_teleoperator_bimanual_leader \
    --teleop.left_arm_port=/dev/ttyUSB0 \
    --teleop.right_arm_port=/dev/ttyUSB2 \
    --teleop.id=bi_starai_violin_leader \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --display_data=true \
    --dataset.repo_id=starai/record-test_bi_arm \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 \
    --dataset.num_episodes=10 \
    --dataset.push_to_hub=False \
    --dataset.single_task="Grab the black cube"

Violin&Cello:

lerobot-record \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_cello \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_cello_follower \
    --teleop.type=lerobot_teleoperator_bimanual_leader \
    --teleop.left_arm_port=/dev/ttyUSB0 \
    --teleop.right_arm_port=/dev/ttyUSB2 \
    --teleop.id=bi_starai_violin_leader \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --display_data=true \
    --dataset.repo_id=starai/record-test_bi_arm \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30 \
    --dataset.num_episodes=10 \
    --dataset.push_to_hub=False \
    --dataset.single_task="Grab the black cube"

dica

Para diferenciar entre configurações de braço único e de dois braços, o --dataset.repo_id aqui é nomeado como starai/record-test_bi_arm.

• record fornece um conjunto de ferramentas para capturar e gerenciar dados durante as operações do robô:

1. Armazenamento de dados

• Os dados são armazenados no formato LeRobotDataset e salvos em disco durante o processo de gravação.

2. Checkpoint e retomada

• Checkpoints são criados automaticamente durante a gravação.
• Se ocorrer algum problema, você pode retomar executando novamente o mesmo comando com --resume=true. Ao retomar a gravação, você deve definir --dataset.num_episodes para o número adicional de episódios a serem gravados, e não para o número total de episódios desejado no conjunto de dados!
• Para iniciar a gravação do zero, exclua manualmente o diretório do conjunto de dados.

3. Parâmetros de gravação

Defina o fluxo de trabalho de gravação de dados usando parâmetros de linha de comando:

Parameter Description
- warmup-time-s: The initialization time.
- episode-time-s: The duration for each data collection session.
- reset-time-s: The preparation time between each data collection.
- num-episodes: The expected number of data sets to collect.
- push-to-hub: Determines whether to upload the data to HuggingFace Hub.

4. Controles de teclado durante a gravação

Use atalhos de teclado para controlar o fluxo de trabalho de gravação de dados:

• Pressione seta para a direita (→): interrompe prematuramente o episódio atual ou redefine o tempo e, em seguida, passa para o próximo.
• Pressione seta para a esquerda (←): cancela o episódio atual e o grava novamente.
• Pressione ESC: interrompe imediatamente a sessão, codifica o vídeo e envia o conjunto de dados.

dica

Se o teclado não funcionar, talvez você precise instalar outra versão do pynput.

pip install pynput==1.6.8

Reproduzir um episódio

Agora tente reproduzir o primeiro episódio no seu robô:

Viola:

lerobot-replay \
    --robot.type=lerobot_robot_viola \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraiviola_arm \
    --dataset.repo_id=starai/record-test \
    --dataset.episode=1 # choose the episode you want to replay

Cello:

lerobot-replay \
    --robot.type=lerobot_robot_cello \
    --robot.port=/dev/ttyUSB1 \
    --robot.id=my_awesome_staraicello_arm \
    --dataset.repo_id=starai/record-test \
    --dataset.episode=1 # choose the episode you want to replay

Braço Duplo

Viola:

lerobot-replay \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_viola \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_viola_follower \
    --dataset.repo_id=starai/record-test_bi_arm \
    --dataset.episode=0 # choose the episode you want to replay

Cello:

lerobot-replay \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_cello \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.id=bi_starai_cello_follower \
    --dataset.repo_id=starai/record-test_bi_arm \
    --dataset.episode=0 # choose the episode you want to replay

Treinar e Avaliar a Política

ACT

Consulte ACT

Treinar

Viola:

lerobot-train \
  --dataset.repo_id=starai/record-test \
  --policy.type=act \
  --output_dir=outputs/train/act_viola_test \
  --job_name=act_viola_test \
  --policy.device=cuda \
  --wandb.enable=False \
  --policy.repo_id=starai/my_policy \
  --steps=200000

Cello:

lerobot-train \
  --dataset.repo_id=starai/record-test \
  --policy.type=act \
  --output_dir=outputs/train/act_cello_test \
  --job_name=act_cello_test \
  --policy.device=cuda \
  --wandb.enable=False \
  --policy.repo_id=starai/my_policy \
  --steps=200000

Braço Duplo

Viola:

lerobot-train \
  --dataset.repo_id=starai/record-test_bi_arm \
  --policy.type=act \
  --output_dir=outputs/train/act_bi_viola_test \
  --job_name=act_bi_viola_test \
  --policy.device=cuda \
  --wandb.enable=False \
  --policy.repo_id=starai/my_policy \
  --steps=200000

Cello:

lerobot-train \
  --dataset.repo_id=starai/record-test_bi_arm \
  --policy.type=act \
  --output_dir=outputs/train/act_bi_cello_test \
  --job_name=act_bi_cello_test \
  --policy.device=cuda \
  --wandb.enable=False \
  --policy.repo_id=starai/my_policy \
  --steps=200000

1. policy.type oferece suporte à entrada diffusion,pi0,pi0fast
2. Fornecemos o conjunto de dados como um parâmetro: dataset.repo_id=starai/record-test.
3. Carregaremos a configuração a partir de configuration_act.py. É importante ressaltar que essa política irá se adaptar automaticamente aos estados dos motores do robô, às ações dos motores e ao número de câmeras, e será salva no seu conjunto de dados.
4. Fornecemos wandb.enable=true para usar o Weights and Biases para visualizar gráficos de treinamento. Isso é opcional, mas se você o utilizar, certifique-se de ter feito login executando wandb login.

Avaliar

Execute o seguinte comando para registrar 10 episódios de avaliação:

Viola:

lerobot-record  \
  --robot.type=lerobot_robot_viola \
  --robot.port=/dev/ttyUSB1 \
  --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
  --robot.id=my_awesome_staraiviola_arm \
  --display_data=false \
  --dataset.repo_id=starai/eval_record-test \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/train/act_viola_test/checkpoints/last/pretrained_model
  # <- Teleop optional if you want to teleoperate in between episodes \
  # --teleop.type=lerobot_teleoperator_violin \
  # --teleop.port=/dev/ttyUSB0 \
  # --teleop.id=my_awesome_leader_arm \

Cello:

lerobot-record  \
  --robot.type=lerobot_robot_cello \
  --robot.port=/dev/ttyUSB1 \
  --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
  --robot.id=my_awesome_staraicello_arm \
  --display_data=false \
  --dataset.repo_id=starai/eval_record-test \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/train/act_viola_test/checkpoints/last/pretrained_model
  # <- Teleop optional if you want to teleoperate in between episodes \
  # --teleop.type=lerobot_teleoperator_violin \
  # --teleop.port=/dev/ttyUSB0 \
  # --teleop.id=my_awesome_leader_arm \

Braço Duplo

Viola:

lerobot-record  \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_viola \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --robot.id=bi_starai_viola_follower \
    --display_data=false \
    --dataset.repo_id=starai/eval_record-test_bi_arm \
    --dataset.single_task="test" \
    --policy.path=outputs/train/act_bi_viola_test/checkpoints/last/pretrained_model

Cello:

lerobot-record  \
    --robot.type=lerobot_robot_bimanual_follower \
    --robot.arm_name=starai_cello \
    --robot.left_arm_port=/dev/ttyUSB1 \
    --robot.right_arm_port=/dev/ttyUSB3 \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --robot.id=bi_starai_cello_follower \
    --display_data=false \
    --dataset.repo_id=starai/eval_record-test_bi_arm \
    --dataset.single_task="test" \
    --policy.path=outputs/train/act_bi_cello_test/checkpoints/last/pretrained_model

Como você pode ver, este é quase o mesmo comando usado anteriormente para registrar o conjunto de dados de treinamento, com algumas alterações:

1. O parâmetro --policy.path, que indica o caminho para o arquivo de pesos da sua política treinada (por exemplo, outputs/train/act_viola_test/checkpoints/last/pretrained_model). Se você tiver enviado os pesos do seu modelo para o Hub, também poderá usar o repositório do modelo (por exemplo, ${HF_USER}/starai).

2. O nome do conjunto de dados de avaliação dataset.repo_id começa com eval_. Essa operação irá registrar vídeos e dados especificamente para a fase de avaliação, que serão salvos em uma pasta começando com eval_, como starai/eval_record-test.

3. Se você encontrar File exists: 'home/xxxx/.cache/huggingface/lerobot/xxxxx/starai/eval_xxxx' durante a fase de avaliação, exclua a pasta que começa com eval_ e execute o programa novamente.

4. Ao encontrar mean is infinity. You should either initialize with stats as an argument or use a pretrained model, certifique-se de que palavras-chave como up e front no parâmetro --robot.cameras estejam estritamente consistentes com as usadas durante a fase de coleta de dados.

SmolVLA

Consulte SmolVLA

pip install -e ".[smolvla]"

Treinar

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

Avaliar

lerobot-record \
  --robot.type=starai_viola \
  --robot.port=/dev/ttyUSB1 \
  --robot.id=my_awesome_staraiviola_arm \
  --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video2, width: 1280, height: 720, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video4, width: 1280, height: 720, fps: 30, fourcc: "MJPG"}}" \
  --dataset.single_task="Grasp a lego block and put it in the bin." \ # <- Use the same task description you used in your dataset recording
  --dataset.repo_id=${HF_USER}/eval_DATASET_NAME_test \ 
  --dataset.episode_time_s=50 \
  --dataset.num_episodes=10 \
  # <- Teleop optional if you want to teleoperate in between episodes \
  # --teleop.type=so100_leader \
  # --teleop.port=/dev/ttyACM0 \
  # --teleop.id=my_red_leader_arm \
  --policy.path=HF_USER/FINETUNE_MODEL_NAME # <- Use your fine-tuned model

Libero

Consulte Libero

LIBERO é um benchmark projetado para estudar o aprendizado contínuo de robôs. A ideia é que os robôs não serão apenas pré-treinados uma vez em uma fábrica; eles precisarão continuar aprendendo e se adaptando com seus usuários humanos ao longo do tempo. Essa adaptação contínua é chamada de aprendizado ao longo da vida na tomada de decisão (LLDM), e é um passo fundamental para construir robôs que se tornem ajudantes verdadeiramente personalizados.

• Artigo do LIBERO
• Repositório original do LIBERO

LIBERO inclui cinco conjuntos de tarefas:

• LIBERO-Spatial (libero_spatial) – tarefas que exigem raciocínio sobre relações espaciais.

• LIBERO-Object (libero_object) – tarefas centradas na manipulação de diferentes objetos.

• LIBERO-Goal (libero_goal) – tarefas condicionadas a objetivos em que o robô deve se adaptar a alvos em mudança.

• LIBERO-90 (libero_90) – 90 tarefas de horizonte curto da coleção LIBERO-100.

• LIBERO-Long (libero_10) – 10 tarefas de horizonte longo da coleção LIBERO-100.

Juntas, essas suítes cobrem 130 tarefas, que vão desde simples manipulações de objetos até cenários complexos de múltiplas etapas. O LIBERO foi projetado para crescer ao longo do tempo e servir como um benchmark compartilhado onde a comunidade pode testar e aprimorar algoritmos de aprendizado ao longo da vida.

Treinar

lerobot-train \
  --policy.type=smolvla \
  --policy.repo_id=${HF_USER}/libero-test \
  --dataset.repo_id=HuggingFaceVLA/libero \
  --env.type=libero \
  --env.task=libero_10 \
  --output_dir=./outputs/ \
  --steps=100000 \
  --batch_size=4 \
  --eval.batch_size=1 \
  --eval.n_episodes=1 \
  --eval_freq=1000 \

Avaliação

Para instalar o LIBERO, depois de seguir as instruções oficiais do LeRobot, basta fazer: pip install -e ".[libero]"

Avaliação de uma única suíte

lerobot-eval \
  --policy.path="your-policy-id" \
  --env.type=libero \
  --env.task=libero_object \
  --eval.batch_size=2 \
  --eval.n_episodes=3

• --env.task seleciona a suíte (libero_object, libero_spatial, etc.).

• --eval.batch_size controla quantos ambientes são executados em paralelo.

• --eval.n_episodes define quantos episódios serão executados no total.

Avaliação de múltiplas suítes

lerobot-eval \
  --policy.path="your-policy-id" \
  --env.type=libero \
  --env.task=libero_object,libero_spatial \
  --eval.batch_size=1 \
  --eval.n_episodes=2

• Passe uma lista separada por vírgulas para --env.task para avaliação de múltiplas suítes.

Pi0

Consulte Pi0

pip install -e ".[pi]"

Treinar

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 

Avaliar

lerobot-record \
  --robot.type=starai_viola \
  --robot.port=/dev/ttyUSB1 \
  --robot.id=my_awesome_staraiviola_arm \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
  --dataset.single_task="Grasp a lego block and put it in the bin." \ # <- Use the same task description you used in your dataset recording
  --robot.id=my_awesome_staraiviola_arm \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --policy.path=outputs/pi0_training/checkpoints/last/pretrained_model

Pi0.5

Consulte Pi0.5

pip install -e ".[pi]"

Treinar

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

Avaliar

lerobot-record \
  --robot.type=starai_viola \
  --robot.port=/dev/ttyUSB1 \
  --robot.id=my_awesome_staraiviola_arm \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},front: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
  --dataset.single_task="Grasp a lego block and put it in the bin." \ # <- Use the same task description you used in your dataset recording
  --robot.id=my_awesome_staraiviola_arm \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --policy.path=outputs/pi05_training/checkpoints/last/pretrained_model

GR00T N1.5

Consulte GR00T N1.5

Retome o treinamento a partir de um checkpoint específico.

Viola:

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

Cello:

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

FAQ

• Se você estiver usando o tutorial deste documento, por favor, execute git clone no repositório GitHub recomendado: https://github.com/servodevelop/lerobot.git.

• Se a teleoperação funcionar normalmente, mas a teleoperação com uma câmera não exibir a interface de imagem, consulte aqui.

• Se você encontrar um problema com o libtiff durante a teleoperação do conjunto de dados, atualize a versão do libtiff.

  conda install libtiff==4.5.0  # for Ubuntu 22.04, use libtiff==4.5.1

• Após instalar o LeRobot, ele pode desinstalar automaticamente a versão GPU do PyTorch, portanto, você precisa instalar manualmente o torch-gpu.

• Para Jetson, instale primeiro o PyTorch e o Torchvision antes de executar conda install -y -c conda-forge ffmpeg, caso contrário, haverá um problema de incompatibilidade de versão ao compilar o torchvision.

• Treinar 50 episódios de dados ACT em um laptop com 3060 8GB leva aproximadamente 6 horas, enquanto treinar 50 episódios em um computador com 4090 ou A100 leva cerca de 2–3 horas.

• Durante a coleta de dados, garanta a estabilidade da posição e do ângulo da câmera, bem como da iluminação do ambiente, e minimize o fundo instável e os pedestres capturados pela câmera. Caso contrário, mudanças significativas no ambiente de implantação podem fazer com que o braço robótico não consiga agarrar objetos normalmente.

• O num-episodes no comando de coleta de dados deve garantir coleta de dados suficiente e não deve ser pausado manualmente no meio. Isso ocorre porque a média e a variância dos dados são calculadas somente após a conclusão da coleta, o que é necessário para o treinamento.

• Se o programa indicar que não consegue ler os dados de imagem da câmera USB, certifique-se de que a câmera USB não esteja conectada por meio de um hub. A câmera USB deve estar conectada diretamente ao dispositivo para garantir altas taxas de transmissão de imagem.

Citação

StarAI Robot Arm ROS2 Moveit2: star-arm-moveit2

lerobot-starai github: lerobot-starai

STEP: STEP

URDF: URDF

Huggingface Project: Lerobot

ACT ou ALOHA: Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware

VQ-BeT: VQ-BeT: Behavior Generation with Latent Actions

Diffusion Policy: Diffusion Policy

TD-MPC: TD-MPC

Suporte Técnico e Discussão de Produtos

Obrigado por escolher nossos produtos! Estamos aqui para oferecer diferentes tipos de suporte para garantir que sua experiência com nossos produtos seja a mais tranquila possível. Oferecemos vários canais de comunicação para atender a diferentes preferências e necessidades.