🎓 Aprender mediante demostraciones

En el módulo 5.3 hiciste que el seguidor copiara al líder en tiempo real. Ahora la idea es dar un paso más: grabar estas demostraciones y entrenar una red neuronal que aprende la relación «lo que veo y dónde están mis articulaciones → cuál es el siguiente movimiento». Después de entrenarla, controla al seguidor sin que nadie esté en el líder. Esto se llama aprendizaje por imitación.

Cómo leer: las flechas verdes muestran una vuelta del ciclo; el bloque brillante (entrenar) es el único que necesita GPU. La flecha cian es lo que marca la diferencia entre quienes lo logran y quienes abandonan: la evaluación indica en qué situación falla la política, y la corrección consiste en grabar más ejemplos exactamente de esa situación.

Por qué aprender

Programar a mano un «agarrar y soltar» funciona hasta que el cubo se mueve 3 cm. La política aprendida observa la cámara en cada instante y corrige la trayectoria. Así es como los laboratorios entrenan brazos robóticos hoy, y el SO-101 con LeRobot pone este método a tu alcance.

Conceptos clave

Cada demostración grabada es un episodio. El comando lerobot-record conecta el líder, el seguidor y las cámaras, y en cada cuadro guarda tres cosas: las imágenes, la posición actual de las articulaciones del seguidor (el estado) y la posición que indicó el líder (la acción). Entre un episodio y otro hay un tiempo de reinicio para que puedas ordenar la mesa.

Cómo leer: cada columna es un cuadro. La fila de arriba muestra lo que vio la cámara (el cubo se acerca, lo agarran y aparece en la caja). Las filas de abajo son los números que la red aprenderá a relacionar: dada la imagen y el estado, predecir la acción. La instrucción de texto se aplica a todo el episodio.

Paso a paso de la primera grabación

Objetivo: grabar episodios de la tarea «poner el cubo en la caja» con una cámara frontal. Cambia los puertos, los id y tu usuario de Hugging Face (sin los signos < >).

# Grabar demostraciones con el par SO-101 (Linux; en Windows el puerto es COM3, COM4...)
HF_USER=<seu_usuario_hf>          # reemplaza con tu usuario de Hugging Face
DATASET=cubo-na-caixa-teste        # nombre del dataset

lerobot-record \
  --robot.type=so101_follower --robot.port=/dev/ttyACM0 --robot.id=seguidor \
  --robot.cameras="{ frente: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
  --teleop.type=so101_leader --teleop.port=/dev/ttyACM1 --teleop.id=lider \
  --dataset.repo_id=${HF_USER}/${DATASET} \
  --dataset.single_task="Pon el cubo rojo en la caja gris." \
  --dataset.num_episodes=2 \
  --dataset.episode_time_s=20 \
  --dataset.reset_time_s=10 \
  --dataset.push_to_hub=false \
  --display_data=true

Por qué aprender

La política nunca será mejor que las demostraciones. Quien graba con calma y constancia entrena una vez; quien graba apurado entrena cinco veces y no entiende por qué no funciona.

Conceptos clave

LeRobot guarda cada dataset en una carpeta con un formato estándar: tablas con el estado y la acción, videos de las cámaras y un archivo de metadatos. Este mismo formato se puede subir a Hugging Face Hubdonde entrenas en una máquina con GPU (o en Colab) sin copiar archivos manualmente, y donde otras personas pueden usar tus datos, si quieres.

Cómo leer: el nombre de arriba es el repo_id. Las tablas (centro) son ligeras; los videos (derecha, en cian) ocupan casi todo el espacio. Si el dataset quedó demasiado pesado, reduce la resolución o el número de cámaras, no el número de episodios.

Objetivo: iniciar sesión, revisar un episodio grabado y subir el dataset al Hub como privado. Ejecútalo en el mismo entorno Python donde instalaste LeRobot.

hf auth login                       # pega el token de escritura (una vez por máquina)
lerobot-dataset-viz --repo-id <seu_usuario_hf>/<dataset> --episode-index 0

# Abre el dataset local, muestra el tamaño y lo sube al Hub como privado.
import sys
from lerobot.datasets.lerobot_dataset import LeRobotDataset

repo_id = sys.argv[1]                    # ej.: <tu_usuario_hf>/<dataset>
ds = LeRobotDataset(repo_id)             # lee de ~/.cache/huggingface/lerobot/
print("episodios:", ds.num_episodes, "| quadros:", ds.num_frames, "| fps:", ds.fps)
print("colunas:", list(ds.features))
ds.push_to_hub(private=True)             # privado: solo tú puedes verlo
print("enviado: https://huggingface.co/datasets/" + repo_id)

Por qué aprender

Separar "dónde grabas" de "dónde entrenas" resuelve el problema de quienes no tienen GPU en casa: graban en la laptop junto al brazo y entrenan en Colab o en el laboratorio. Además, un dataset bien documentado se convierte en material de clase para todo el grupo.

Conceptos clave

A ACT (Action Chunking with Transformers) es la política recomendada para empezar: es pequeña, se entrena rápido y funciona bien con 50 episodios de una tarea. Su truco está en el nombre: en vez de predecir un movimiento a la vez, predice un fragmento (chunk) de varios movimientos seguidos, lo que hace que el brazo se mueva con más suavidad y menos vacilación.

Cómo leer: a la izquierda está todo lo que la red ve en un instante. A la derecha, las barras representan movimientos futuros: los segmentos sólidos se ejecutan; los contornos se descartan porque, para entonces, la cámara ya tendrá información nueva. La flecha cian cierra el ciclo, como en el ciclo percibir-pensar-actuar del 1.1.

Objetivo: entrenar una ACT con tu dataset en una máquina con GPU NVIDIA. En una Mac con chip Apple, cambia cuda por mps; sin GPU, usa Colab (hay un cuaderno listo en la documentación de LeRobot).

# Entrenar la política ACT (consulta las opciones con: lerobot-train --help)
HF_USER=<seu_usuario_hf>
DATASET=<dataset>

lerobot-train \
  --dataset.repo_id=${HF_USER}/${DATASET} \
  --policy.type=act \
  --policy.device=cuda \
  --output_dir=outputs/train/act-${DATASET} \
  --job_name=act-${DATASET} \
  --batch_size=8 \
  --steps=20000 \
  --wandb.enable=false \
  --policy.push_to_hub=false

Por qué aprender

Saber interpretar el entrenamiento evita desperdiciar tiempo de GPU: aprendes a detenerlo cuando la loss se estabiliza, a probar checkpoints intermedios y a distinguir entre "faltan datos" y "falta entrenamiento".

Conceptos clave

Evaluar consiste en dejar que la política controle el seguidor, sin el líder, y contar cuántas veces acierta. En la versión actual de LeRobot esto se hace con lerobot-rollout; las versiones anteriores usaban el propio lerobot-record con la política indicada. Comprueba cuál corresponde a tu instalación con --help.

Objetivo: ejecutar la política entrenada durante 30 segundos en el seguidor, con la misma cámara y la misma instrucción de la grabación.

# Ejecutar la política en el brazo real (consulta las opciones con: lerobot-rollout --help)
POLITICA=outputs/train/act-<dataset>/checkpoints/last/pretrained_model

lerobot-rollout \
  --strategy.type=base \
  --policy.path=${POLITICA} \
  --robot.type=so101_follower --robot.port=/dev/ttyACM0 --robot.id=seguidor \
  --robot.cameras="{ frente: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
  --task="Pon el cubo rojo en la caja gris." \
  --duration=30

Hoja de evaluación (20 intentos)

Cuando aparezca el patrón de falla (por ejemplo, "siempre falla cuando el cubo está a la izquierda"), graba 10 a 20 episodios nuevos en esa zona y vuelve a entrenar. LeRobot también tiene un modo en el que tomas el control con el líder cuando la política falla y esa corrección se convierte en un episodio nuevo (--strategy.type=dagger); es la forma más eficiente de mejorar después de la primera versión.

Por qué aprender

Sin una evaluación numérica, todo proyecto de IA "casi funciona". Con la hoja sabes exactamente dónde estás, comparas versiones y tienes algo concreto para mostrar en la presentación del proyecto final.

Conceptos clave

ACT aprende una tarea e ignora el texto. Un VLA (modelo Visión-Lenguaje-Acción, presentado en el 5.1) también recibe la instrucción escrita y puede realizar tareas diferentes según lo que le pidas: "pon el cubo en la caja" o "pon la pelota en la caja". Estos modelos ya vienen preentrenados en muchos robots; tú solo haces el ajuste fino con tus episodios.

Cómo leer: la diferencia entre un VLA y ACT es la caja cian. Con el texto, el mismo modelo elige qué objeto agarrar. El texto no se convierte en código ni en una lista de pasos: condiciona directamente los movimientos de las articulaciones.

Objetivo: ajustar SmolVLA a partir del modelo base lerobot/smolvla_base usando tu dataset. Primero graba episodios con instrucciones diferentes (por ejemplo, la mitad "cubo" y la otra mitad "pelota").

# Instalar el extra de SmolVLA en el mismo entorno de LeRobot
pip install "lerobot[smolvla]"

# Ajuste fino a partir del modelo base (consulta las flags en la documentación actual)
lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=<seu_usuario_hf>/<dataset> \
  --policy.device=cuda \
  --output_dir=outputs/train/smolvla-<dataset> \
  --batch_size=16 \
  --steps=20000 \
  --wandb.enable=false \
  --policy.push_to_hub=false

Por qué aprender

El proyecto final (5.6) necesita un brazo que obedezca diferentes pedidos. Con ACT entrenas una política por tarea y el modelo de lenguaje elige cuál ejecutar; con un VLA, una sola política recibe el pedido en texto. Conocer ambos métodos te permite elegir según el hardware que tienes.

Conceptos clave