Entrenar un robot suele implicar una cadena de tareas dispersas: grabar demostraciones, subir archivos, descargar datasets, entrenar una política y devolver el checkpoint al hardware. ¿Qué pasaría si todo ese recorrido pudiera ejecutarse desde un mismo agente y sin copiar continuamente los mismos gigabytes?
Hugging Face muestra una integración entre Strands Agents, Strands Robots, LeRobot y los nuevos Storage Buckets para construir ese ciclo de forma continua. La propuesta permite registrar episodios, sincronizarlos, leerlos directamente desde la nube, entrenar una política y desplegarla en un robot físico.
Un ciclo completo para robots con IA
El flujo parte de Robot(), una fábrica de Strands Robots que unifica simulación, hardware y herramientas de LeRobot. En el ejemplo se utiliza un SO-100, aunque el catálogo también contempla brazos, humanoides, bases móviles y manos.
La misma instancia del robot puede grabar una demostración y luego leer ese dataset para entrenamiento. En lugar de conectar herramientas independientes, un agente recibe instrucciones en lenguaje natural y decide cuándo preparar la escena, iniciar la grabación, ejecutar una política y detener el episodio.
El ciclo básico se parece a esto:
from strands import Agent
from strands_robots import Robot
sim = Robot("so100")
agent = Agent(tools=[sim])
agent("Graba una demostración de recoger el cubo y sincronízala con mi bucket")
for batch in sim.stream_dataset(
"mi-org/robot-fave/cube_pick",
repo_type="bucket"
).dataloader(batch_size=64):
...
Por defecto, Robot("so100") trabaja en simulación, una opción segura para probar el flujo sin conectar hardware. El ejemplo puede utilizar una política simulada, que produce un dataset válido aunque no necesariamente útil para aprender una tarea real.
Storage Buckets evita transferencias innecesarias
Los datasets de LeRobot contienen archivos Parquet con estados y acciones, además de archivos MP4 con las imágenes de las cámaras. Cuando una colección crece durante horas o días, volver a subir y descargar todo el dataset puede ser costoso y lento.
Los Hugging Face Storage Buckets funcionan como una capa de trabajo mutable dentro del mismo espacio hf://. A diferencia de un repositorio de datasets versionado, un bucket permite modificar archivos en el lugar y no conserva revisiones históricas.
La ventaja está en Xet, el sistema de almacenamiento que divide los archivos en fragmentos definidos por su contenido. Si solo cambia una parte del dataset, la siguiente sincronización puede enviar únicamente los fragmentos nuevos o modificados.
Según las mediciones citadas por Hugging Face, cambiar el 1 % de un archivo de 500 MB movió 5,5 MB; modificar el 5 % movió 27,5 MB, y cambiar el 10 % transfirió 55 MB. El ahorro exacto depende de cómo estén organizados los datos, pero el principio es sencillo: no necesitas pagar por transferir de nuevo los bytes que ya existen.
from strands_robots import sync_dataset_to_bucket
sync_dataset_to_bucket(
"/tmp/cube_pick",
"mi-org/robot-fave",
run_id="run-021"
)
La sincronización guarda el dataset en una ruta como hf://buckets/mi-org/robot-fave/run-021. Usar un run_id diferente para cada campaña permite rastrear cada colección y evita sobrescribir accidentalmente una anterior.
Un bucket es una capa de trabajo, no un reemplazo para un dataset revisado y versionado.
Cuando una versión queda aprobada, todavía es posible publicarla con push_to_hub(), donde sí se conservan las revisiones.
Entrenamiento por streaming, sin descargar todo
El siguiente cuello de botella suele aparecer al entrenar. Si el dataset ocupa cientos de gigabytes, las GPU pueden permanecer inactivas mientras esperan que termine la descarga completa.
La integración utiliza StreamingLeRobotDataset para leer los datos directamente desde el bucket. Los estados y las acciones llegan desde los archivos Parquet, mientras que los cuadros de video se decodifican bajo demanda desde los MP4. Solo se guarda localmente una pequeña carpeta meta/ con el esquema, las estadísticas y el índice de episodios.
reader = sim.stream_dataset(
"mi-org/robot-fave/cube_pick",
repo_type="bucket",
shuffle=False,
max_num_shards=1,
buffer_size=1
)
print(reader.num_episodes, reader.num_frames, reader.fps)
for frame in reader:
image = frame["observation.images.front"]
state = frame["observation.state"]
action = frame["action"]
break
Para entrenar con PyTorch, el lector ofrece un DataLoader convencional. El sistema puede barajar los datos mediante un buffer acotado y distribuir la decodificación de video entre varios procesos.
for batch in reader.dataloader(batch_size=64, num_workers=4):
loss, _ = policy(batch)
loss.backward()
También es posible utilizar directamente el entrenador de LeRobot:
lerobot-train --policy.type=act \
--dataset.repo_id=mi-org/robot-fave/cube_pick \
--dataset.repo_type=bucket \
--dataset.streaming=true \
--num_workers=4
El parámetro streaming=true es obligatorio cuando el dataset utiliza repo_type=bucket. Para dispositivos periféricos con recursos limitados, drop_videos=True permite omitir la decodificación de video y trabajar solo con datos propioceptivos, como posiciones y velocidades articulares.
De una política entrenada al robot físico
Strands Robots mantiene el mismo ciclo para distintos proveedores de entrenamiento. Un Trainer recibe una especificación con el dataset, el directorio de salida, el modelo base y el número de pasos.
from strands_robots import create_policy
from strands_robots.training import TrainSpec, create_trainer
trainer = create_trainer("lerobot_local", device="cuda")
spec = TrainSpec(
dataset_root="/tmp/cube_pick",
output_dir="/tmp/cube_pick_ft",
base_model="",
steps=500,
extra={"policy_type": "act"}
)
result = trainer.train(spec)
policy = create_policy(result.checkpoint_dir)
El mismo ciclo también contempla proveedores como groot y cosmos3, aunque cada uno exige sus propios campos, modelos base y recetas de ajuste. La recomendación es ejecutar trainer.validate(spec) antes de entrenar para conocer exactamente qué configuración falta.
Una vez cargado el checkpoint, desplegarlo en un SO-101 físico requiere cambiar el modo del robot y configurar el puerto y las cámaras:
robot = Robot(
"so100",
mode="real",
port="/dev/ttyACM0",
cameras={
"front": {
"type": "opencv",
"index_or_path": "/dev/video0",
"fps": 30
}
}
)
Ese brazo puede ejecutar la política y grabar nuevas demostraciones en el mismo formato de LeRobot. Después, los episodios regresan al bucket para alimentar la siguiente ronda de entrenamiento.
Lo que necesitas para probarlo
La configuración base requiere Python 3.12 o superior, Linux o macOS, un proveedor compatible con Strands Agents y la instalación de Strands Robots con los extras de simulación y LeRobot:
uv pip install -U "strands-robots[sim-mujoco,lerobot]>=0.5.1"
Para crear y sincronizar buckets se necesita una cuenta de Hugging Face, un token con permisos de escritura y la CLI correspondiente:
pip install -U "huggingface-hub>=1.6.0,<2.0.0"
hf auth login
El entrenamiento requiere además lerobot[training] y, para inferencia visual o entrenamiento a escala, una GPU NVIDIA. La grabación y la lectura por streaming pueden probarse sin GPU utilizando simulación y una política ficticia.
El repositorio de Strands Robots incluye un notebook que recorre el flujo completo: grabar, renderizar, sincronizar, transmitir, entrenar y cargar el checkpoint. También existe un ejemplo orientado a que el agente gestione la recolección y el streaming.
Seguridad y operación en producción
Un agente que puede controlar robots y escribir en almacenamiento compartido necesita límites claros. Los datos no confiables podrían incluir instrucciones maliciosas que intenten modificar el comportamiento del agente, un riesgo conocido como inyección de prompts.
También existe un límite de confianza entre la recolección y el entrenamiento. Si un proceso puede escribir episodios que luego consume una política, una demostración manipulada podría terminar influyendo en un brazo físico. Conviene separar las credenciales de escritura y lectura, utilizar buckets privados y mantener cada campaña bajo su propio run_id.
La opción de sobrescritura es útil para el trabajo diario, pero elimina el historial. Para conservar un artefacto auditable hay que publicar el resultado en un repositorio versionado. Además, trust_remote_code=True solo debería habilitarse para organizaciones y checkpoints de confianza, preferiblemente en formatos como safetensors cuando estén disponibles.
El futuro práctico de la robótica entrenada con datos
La importancia de esta integración no está únicamente en ahorrar transferencias. Está en convertir la recolección, el entrenamiento y el despliegue en un ciclo operativo que un equipo pueda repetir todos los días.
Los datos mantienen el formato de LeRobot, por lo que pueden ser utilizados por las herramientas del ecosistema sin conversiones. Y como la fábrica Robot() sirve tanto para simulación como para hardware, el código puede crecer desde una prueba local hasta una flota de robots que recopila episodios en paralelo.
La IA robótica deja de parecer una demostración aislada y empieza a comportarse como un sistema de mejora continua: observa, registra, entrena, prueba y vuelve a observar. La clave será acompañar esa velocidad con controles de seguridad, trazabilidad y revisión humana antes de que una nueva política llegue al brazo físico.
Fuente original
https://huggingface.co/blog/amazon/strands-lerobot-streaming-data-loop