Transformador de acción de fragmentos (ACT): Guía completa para la formación y la implementación de políticas de ACT (2026)
Guía completa de ACT: entiende el proceso de acción, entrenar las políticas de ACT sobre los datos de robots, implementar en OpenArm o Mobile ALOHA. Cubre el conjunto temporal, la sintonización del tamaño de los fragmentos y la integración de LeRobot. 2026 actualizada.
[← Guías]
Guía para practicantes de la acción de la descomposición
¿Qué es el "Chunking de Acción"?
El chunking de acción es una técnica en el aprendizaje de imitación en la que la política predice una secuencia de acciones futuras
En el BC estándar, la política predice una acción por paso de control. Cada error de predicción desplaza al robot a un estado que la política nunca ha visto, causando que la siguiente predicción sea peor, etc. En una trayectoria de 200 pasos a 50 Hz (4 segundos de manipulación), incluso un 1% por paso compuesto de error a una probabilidad de ~87% de alejarse de la distribución de demostración. El desglose de acción reduce esto mediante el compromiso con planes de pasos de k (normalmente 50
Tamaño del pedazo: el hiperparámetro más importante
El tamaño de la pieza k determina el equilibrio entre la suavidad de la trayectoria y la reactividad ambiental. Los trozos más grandes producen movimientos más suaves, pero no pueden reaccionar a eventos inesperados (objeto desplazado, obstáculo aparecido) hasta que la pieza actual termine de ejecutar. Los trozos más pequeños reaccionan más rápido, pero pierden la ventaja de la suavidad y reintroducen el error de composición.
Puntos de partida recomendados por tipo de tarea:
- Pickup y ubicación de la mesa: k=50
100 (1 2 segundos). El entorno es estático; la suavidad es más valiosa que la reactividad. - ** Ensamblaje e inserción:** k=30
60. Las fases ricas en contactos requieren una reorganización más frecuente para ajustar los errores de alineación. - ** Coordinación bimanual:** k=50
80. Dos brazos necesitan piezas coordinadas; piezas demasiado cortas rompen la coordinación. - ** Manipulación móvil:** k=20
40 para la base, k=50 80 para el brazo. - Tascas dinámicas (captura, esquivar): k=10
20. La reactividad es crítica; acepta cierta pérdida de suavidad.
Por qué funciona el desgaste de acciones: el argumento de la suavidad temporal
Una política de BC de un solo paso trata cada paso de forma independiente. Incluso si el modelo captura perfectamente la distribución condicional P
Al predecir k pasos simultáneamente, el modelo debe producir un segmento de trayectoria internamente coherente. La pérdida de entrenamiento penaliza conjuntamente todo el trozo, obligando a la red a aprender primitivas de movimiento suave en lugar de predicciones aisladas de marco por marco. Esto es análogo a cómo los modelos de lenguaje producen texto más coherente cuando se generan múltiples tokens a la vez en comparación con la muestreo de un token a la vez.
2. Arquitectura de ACT
ACT utiliza un autoencodador de variación condicional (CVAE) con una columna vertebral de transformador. La arquitectura tiene tres componentes principales: un encodador de CVAE (utilizado solo durante el entrenamiento), un decodador de transformador (utilizado durante el entrenamiento y la inferencia) y una columna vertebral de visión.
Encodificador CVAE (sólo para formación)
Durante la formación, el codificador procesa la demostración completa
El codificador es un transformador que atende a la secuencia de acción completa y la observación actual. Saque una media y una variación de registro que parametriza un gaussiano, de la cual z se muestra a través del truco de reparameterización. Un término de divergencia KL (pondurado por beta, típicamente 10
En la inferencia, z se establece en zero (la media previa), lo que hace determinista la política. La estructura de CVAE es puramente una ayuda de formación: sin ella, el modelo promedia en diferentes estilos de demostración, produciendo movimientos que son la media de todos los enfoques y, por lo tanto, ninguno de ellos (medio de modo). Con el CVAE, el modelo aprende a decodificar cada estilo por separado, y el z de media cero en la inferencia produce la ejecución más "típica".
Decodificador de transformadores (entrenamiento + inferencia)
El decodificador toma tres entradas: la z latente (o cero), los tokens de observación de la columna vertebral de la visión + la propriocepción y las consultas posicionales k aprendizables (una por acción en el trozo).
Detalles de arquitectura de la implementación original del ACT:
- Cosas de codificación: 4 (procesos de observación + z en fichas de contexto)
- ** Capas de decodificación:** 7 (más profundo porque hace más trabajo: genera la pieza de acción completa)
- Dimensión oculta: 512
- Tas de atención: 8
- Dimensión de la entrada: 2,048
- Parámetros totales: ~40M (excluyendo la columna vertebral de la visión)
- Resultados de acción: k objetivos de posición conjunta (por ejemplo, k=100 pasos x 14 juntas para ALOHA bimanual)
El columna vertebral de la visión
Cada vista de la cámara se procesa de forma independiente a través de un ResNet-18, produciendo un mapa de características (15x20x512 de una entrada de 480x640) que se aplania en 300 tokens por cámara.
La configuración mínima de la cámara viable es de 2 vistas: una cámara montada en la muñeca (detalle de manipulación de cerca) y una cámara sobrecargada (contexto espacial). Tres cámaras (1 muñeca + 2 terceras personas en diferentes ángulos) es el estándar RCSV y mejora constantemente la tasa de éxito en 5
3. Requisitos de datos
ACT aprende de las demostraciones de teleoperación humanas almacenadas en pares sincronizados (observación, acción).
Tamaños mínimos de conjunto de datos por complejidad de tarea
| Task Type | Demostraciones Needed | Approx. Collection Time | Notes |
|---|---|---|---|
| Simple pick-and-place (fixed location) | 20–30 | 30 minutes | Lowest bar for proof-of-concept |
| Pick-and-place with pose variation | 50–80 | 1–2 hours | Must cover workspace uniformly |
| Multi-step manipulation | 100–150 | 3–4 hours | Each phase needs coverage |
| Bimanual coordination | 150–250 | 5–8 hours | Coordination patterns require more examples |
| Contact-rich assembly (insertion, screwing) | 200–400 | 8–16 hours | Force-sensitive phases need dense coverage |
Lista de control de calidad de los datos
- No hay pausas: Las manifestaciones deben fluir continuamente.
- Velocidad constante: La mezcla de demostraciones rápidas y lentas desperdicia la capacidad latente de CVAE en variación de velocidad.
- Clean start/end: Cada episodio comienza con una postura neutral similar y termina claramente.
- Sólo el éxito: Eliminar todas las demostraciones fallidas. ACT trata todos los datos de formación como demostraciones de expertos.
- Consistencia de la cámara: Utilice monturas rígidas. Incluso 5 mm de desplazamiento de la cámara entre sesiones degrada la precisión de captura.
Formatos de datos: HDF5 y RLDS
El formato estándar para los datos de entrenamiento de ACT es HDF5, con cada episodio almacenado como un grupo que contiene conjuntos de datos para imágenes (n_cameras x H x W x 3, uint8), posiciones conjuntas (qpos, float64), velocidades conjuntas (qvel, float64), y acciones (float64).
Para la compatibilidad entre plataformas, el formato RLDS (Reinforcement Learning Datasets)
# HDF5 episode structure for ACT training
import h5py
import numpy as np
with h5py.File("episode_0042.hdf5", "r") as f:
# Camera images: (T, H, W, 3) uint8
cam_high = f["/observations/images/cam_high"][:] # overhead camera
cam_wrist = f["/observations/images/cam_wrist"][:] # wrist camera
# Joint state: (T, n_joints) float64
qpos = f["/observations/qpos"][:] # joint positions (radians)
qvel = f["/observations/qvel"][:] # joint velocities (rad/s)
# Actions: (T, action_dim) float64
actions = f["/action"][:] # target joint positions
print(f"Episode length: {len(qpos)} steps")
print(f"Control frequency: {f.attrs['control_freq']} Hz")
print(f"Camera resolution: {cam_high.shape[1]}x{cam_high.shape[2]}")
# Typical output:
# Episode length: 400 steps
# Control frequency: 50 Hz
# Camera resolution: 480x640
4. Formación ACT con LeRobot
[LeRobot] (
Instalación
# Clone and install LeRobot
git clone https://github.com/huggingface/lerobot.git
cd lerobot
pip install -e ".[act]"
# Verify GPU is available
python -c "import torch; print(f'CUDA: {torch.cuda.is_available()}, Device: {torch.cuda.get_device_name(0)}')"
Comando de entrenamiento
# Full ACT training command
python lerobot/scripts/train.py \
--policy.name=act \
--dataset.repo_id=svrc/openarm_pick_place \
--policy.chunk_size=50 \
--policy.n_obs_steps=1 \
--policy.dim_model=512 \
--policy.n_heads=8 \
--policy.n_encoder_layers=4 \
--policy.n_decoder_layers=7 \
--policy.latent_dim=32 \
--policy.kl_weight=10.0 \
--training.learning_rate=1e-5 \
--training.batch_size=8 \
--training.num_epochs=5000 \
--training.eval_freq=500 \
--training.save_freq=1000 \
--device=cuda \
--output_dir=outputs/act_openarm_pick_place/
Referencia de hiperparámetro
| Hyperparameter | Default | Search Range | Effect of Increasing | When to Increase |
|---|---|---|---|---|
| chunk_size (k) | 100 | 20–200 | Smoother trajectories, less reactive | Smooth tasks (wiping, pouring) |
| latent_dim (z) | 32 | 16–64 | More expressive style capture | High demonstration variance |
| kl_weight (beta) | 10 | 1–100 | Stronger regularization | Small datasets (<50 demos) |
| learning_rate | 1e-5 | 5e-6–5e-5 | Faster convergence, instability risk | Large datasets (>200 demos) |
| temporal_ensemble_temp | 10 | 5–50 | Slower blending, more inertia | Smoother tasks |
| n_cameras | 2 | 1–4 | Richer spatial info, more compute | 3D reasoning tasks |
| backbone | ResNet-18 | ResNet-18/34/50 | Better visual features | Cluttered or varying-light scenes |
| num_epochs | 3000 | 1000–8000 | Better fit, overfitting risk | More demos or complex tasks |
Requisitos de la GPU
- Minimum: 16 GB de VRAM (RTX 4060 Ti, RTX 3090). Tamaño de lote 4
8. Tiempo de entrenamiento: 4 8 horas para 200 episodios. - Recomendado: 24 GB de VRAM (RTX 4090). Tamaño de lote 16. Tiempo de entrenamiento: 2
4 horas para 200 episodios. - ** Iteración rápida:** 40
80 GB (A100, H100). Tamaño de lote 32 64. Tiempo de entrenamiento: 30 90 minutos. Permite barridos rápidos de hiperparámetros.
5. Formación ACT con ACT+ (Repositorio original)
La implementación original de ACT del repositorio de Tony Zhao (tonyzhaozh/act) (
# Training with the original ACT repo
git clone https://github.com/tonyzhaozh/act.git
cd act
pip install -r requirements.txt
# Train on custom data
python train.py \
--task_name openarm_pick_place \
--ckpt_dir checkpoints/openarm_pp \
--policy_class ACT \
--kl_weight 10 \
--chunk_size 50 \
--hidden_dim 512 \
--batch_size 8 \
--dim_feedforward 2048 \
--num_epochs 5000 \
--lr 1e-5 \
--seed 0 \
--num_steps 400 \
--camera_names cam_high cam_wrist
LeRobot vs. original repo: LeRobot es mejor mantenido (comunidad activa, actualizaciones regulares, soporte multi-política) y maneja la carga y evaluación de datos automáticamente.
6. Despliegue en hardware real
La implementación de una política de ACT requiere cumplir con las restricciones de control en tiempo real: el bucle de inferencia debe ejecutarse a la frecuencia de control del robot (generalmente 50 Hz = 20 ms por ciclo) mientras procesa imágenes de la cámara y calcula las piezas de acción.
Arquitectura de bucle de inferencia
import torch
import numpy as np
from collections import deque
class ACTInferenceLoop:
def __init__(self, policy, chunk_size=50, temporal_temp=10.0, query_freq=5):
self.policy = policy
self.chunk_size = chunk_size
self.temporal_temp = temporal_temp
self.query_freq = query_freq # re-query every N steps
self.action_queue = deque(maxlen=chunk_size)
self.step_count = 0
def get_action(self, images, qpos):
"""Returns a single action with temporal ensembling."""
if self.step_count % self.query_freq == 0:
# Get new action chunk from policy
with torch.no_grad():
obs = {
"images": torch.tensor(images).unsqueeze(0).cuda(),
"qpos": torch.tensor(qpos).unsqueeze(0).cuda(),
}
chunk = self.policy(obs) # (1, chunk_size, action_dim)
chunk = chunk.squeeze(0).cpu().numpy()
self.action_queue.append({
"actions": chunk,
"generated_at": self.step_count
})
# Temporal ensembling: blend overlapping chunks
action = np.zeros_like(self.action_queue[0]["actions"][0])
total_weight = 0.0
for entry in self.action_queue:
offset = self.step_count - entry["generated_at"]
if offset < self.chunk_size:
weight = np.exp(-offset / self.temporal_temp)
action += weight * entry["actions"][offset]
total_weight += weight
action /= total_weight
self.step_count += 1
return action
Rápido de la velocidad de la velocidad
A 50 Hz de control, cada ciclo tiene un presupuesto de 20 ms.
- Cactura de la cámara + procesamiento previo: 2
5ms (cámaras USB3, redimensionar a 480x640) - Inferencia de ACT: 2
12ms (dependiente de la GPU; véase la tabla de referencia a continuación) - Interpolación de acción + envío de comando: 1
2ms - ** Verificación de seguridad:** 1 ms
- Margen: 0
14ms
Indicadores de referencia de inferencia por plataforma
| Hardware | ACT Inference (ms) | Max Control Rate (Hz) | Suitable For |
|---|---|---|---|
| NVIDIA A100 (80GB) | 1.8 | 555 | Cloud/datacenter inference |
| NVIDIA RTX 4090 | 2.5 | 400 | Desktop workstation |
| NVIDIA RTX 4070 | 4.2 | 238 | Budget desktop |
| Jetson AGX Orin 64GB | 12 | 83 | Onboard robot compute |
| Jetson Orin NX 16GB | 22 | 45 | Mid-range edge |
| Jetson Orin Nano 8GB | 40 | 25 | Minimum viable edge |
| Apple M3 Pro 18GB | 8 | 125 | Development/prototyping |
Detalles de la implementación del conjunto temporal
El conjunto temporal utiliza una ponderación de desintegración exponencial: para una predicción de un pedazo generado t pasos atrás, el peso es
Crítico consejo de despliegue: Siempre utilice ensamblaje temporal en la producción. Sin él, el robot exhibe nervios visibles en los límites de los fragmentos
7. OpenArm 1 + ACT: pasos específicos de configuración
El OpenArm 1 ($4,500 un solo brazo, $9,000 estación bimanual líder-seguidor) está diseñado para la recopilación de datos de aprendizaje de imitación y la implementación de ACT. Aquí está el camino completo de configuración:
Configuración de hardware
- Cámaras montadas: Unir la cámara de muñeca (Intel RealSense D405) al soporte de muñeca de OpenArm.
- ** Conectar servos:** OpenArm utiliza servos Feetech STS3215 (same como ALOHA). Conectar a través de la interfaz de serie U2D2. Verificar todas las 6 juntas respondiendo:
T8 . - Calibra los límites de las articulaciones: Ejecuta
T9 para registrar las posiciones de cero y los límites blandos de las articulaciones. - Teste de teleoperación: Con el brazo del líder conectado, ejecuta
T11 . El seguidor debe reflejar el movimiento del líder en tiempo real a 50 Hz.
Recopilación de datos para ACT
# Record demonstrations on OpenArm
python lerobot/scripts/control_robot.py record \
--robot-path lerobot/configs/robot/openarm.yaml \
--fps 50 \
--repo-id svrc/openarm_pick_place \
--num-episodes 50 \
--warmup-time-s 3 \
--episode-time-s 15 \
--reset-time-s 10 \
--push-to-hub 1
Implementación de ACT en OpenArm
# Deploy trained policy
python lerobot/scripts/control_robot.py replay \
--robot-path lerobot/configs/robot/openarm.yaml \
--policy-path outputs/act_openarm_pick_place/checkpoints/best/ \
--fps 50 \
--num-episodes 20
8. Fallas y soluciones comunes
Hemos entrenado y implementado políticas ACT en más de 20 tareas de manipulación en RCSV. Aquí están los patrones de falla que vemos con más frecuencia y sus remedios.
| Symptom | Root Cause | Fix |
|---|---|---|
| Policy outputs zero or constant actions | KL weight (beta) too high. Model ignores observations and outputs the mean action. | Reduce beta by 5–10x. Monitor KL divergence: it should stabilize at 0.5–5.0 nats, not near zero. |
| Jerky execution at chunk boundaries | Temporal ensemble temperature too low, or ensemble not implemented | Increase temperature from 10 to 20–30. Verify overlapping chunk execution in your control loop. |
| Good training loss, poor real-world performance | Camera mismatch between training and deployment | Check image resize pipeline, camera FOV, crop regions. Use identical camera mount positions. |
| Works for 2 seconds then drifts | Chunk size too large for task dynamics | Reduce chunk size by 50%. The policy is committing to outdated plans. |
| Inconsistent between evaluation runs | Too few demonstrations (<30) | Collect more data. With small datasets, performance is highly sensitive to train/val split. |
| KL divergence collapses to zero | Beta too low. Codificador encodes everything in z; decoder ignores observations. | Increase beta until KL stabilizes at 0.5–5.0 nats. |
| Mode averaging: robot moves to "average" of multiple strategies | Multi-modal demonstrations with single-mode CVAE | Standardize demonstration strategy, remove minority approaches, or switch to Diffusion Policy. |
| Sim-to-real gap: policy works in sim but fails on real robot | Contact dynamics, friction, and visual domain mismatch | Fine-tune on 50–100 real demonstrations. Apply domain randomization during sim training. |
9. Indicadores de referencia: ACT vs Política de difusión vs Cloning conductual
Los siguientes puntos de referencia son de resultados publicados y nuestras propias evaluaciones en RCSV sobre tareas de manipulación estandarizada utilizando las plataformas ALOHA y OpenArm.
| Dimension | ACT | Diffusion Policy | Behavioral Cloning (MLP) |
|---|---|---|---|
| Success rate (50 demos, pick-place) | 82–90% | 75–85% | 40–60% |
| Success rate (200 demos, pick-place) | 90–95% | 92–97% | 65–80% |
| Success rate (bimanual insertion) | 80–88% | 72–82% | 15–30% |
| Inference latency (RTX 4090) | 2.5ms | 15ms (DDIM) | 0.5ms |
| Inference latency (Jetson Orin Nano) | 40ms (25 Hz) | 180ms (5.5 Hz) | 5ms (200 Hz) |
| Training time (200 episodes, A100) | ~4 hours | ~8 hours | ~1 hour |
| Model size | ~40M params | ~80M params | ~5M params |
| Multi-modal handling | Limited (CVAE) | Excellent (diffusion) | None (mode averaging) |
| Trayectoria smoothness | Excellent | Very good | Poor (jerky) |
| Data efficiency (<50 demos) | Good | Moderate | Poor |
| Edge deployment feasibility | Excellent | Challenging | Trivial |
10. Cuándo utilizar ACT vs. otros métodos
Utilice ACT cuando:
- Tienes 50
200 demostraciones y necesitas un camino rápido para el despliegue. - Su tarea tiene una estrategia relativamente determinista (una forma clara de hacerlo).
- Estás desplegando en hardware de borde (Jetson) donde la velocidad de inferencia importa.
- Usted está haciendo una manipulación bimanual (ACT fue diseñado para ALOHA).
- Quieres la línea de entrenamiento más simple posible con un mínimo de ajuste de hiperparámetros.
- Necesitas control en tiempo real a 50 Hz en plataformas con limitaciones de computación.
Utilice la política de difusión cuando:
- Sus demostraciones contienen múltiples estrategias válidas para la misma tarea (operadores diferentes, captaciones ambigüas).
- Necesitas precisión sub-milimétrica en tareas de montaje o inserción.
- Tiene datos abundantes (200+ demostraciones) y presupuesto de cálculo.
- Puede tolerar una mayor latencia de inferencia (inferencia en la nube o GPU de escritorio).
Utilice VLAs (OpenVLA, pi0) cuando:
- Necesitas una ejecución multicomisión con lenguaje condicionado ("pick the red cup", "stack the blue blocks").
- Quieres aprovechar las representaciones pre-entrenadas del lenguaje de visión para la generalización.
- Estás haciendo manipulación móvil con grandes espacios estatales.
- Tiene acceso a la infraestructura de formación multi-GPU (4
8 A100s).
Quédate con Simple BC Cuando:
- Están haciendo prototipos y quieren la mayor iteración de entrenamiento posible.
- Su tarea es muy corta (<20 pasos) donde el error de composición no es un problema.
- Se está implementando en hardware extremadamente limitado (clase de microcontroladores).
Recoger datos de robots compatibles con ACT en el RCSV
RCSV proporciona una recopilación de datos de extremo a extremo para el entrenamiento de ACT: hardware calibrado de seguidores líderes, operadores capacitados, control de calidad y entrega en formato HDF5 de LeRobot.
Servicios de recogida de datos