Transformadores de acción de fragmentos (ACT): Guía completa para el aprendizaje de imitación de robots (2026)
Master ACT (Action Chunking Transformers): arquitectura, capacitación en datos reales de robots, ajuste de tamaño de pieza y implementación en OpenArm y Mobile ALOHA. Incluye código PyTorch, guía de hiperparámetros y especificaciones de formato de conjunto de datos.
[← Guías]
Una inmersión en ACT
¿Qué es el "cumplimiento de acciones" y por qué es importante
El clonamiento conductual estándar predice una sola acción siguiente a partir de la observación actual. Esto funciona en teoría pero se descompone en la práctica: pequeños errores de predicción se acumulan con el tiempo, haciendo que el robot se desplace hacia estados nunca vistos durante el entrenamiento. Este problema de error compuesto es la limitación fundamental de la clonación conductual ingenua.
Action chunking resuelve esto prediciendo una secuencia de acciones futuras a la vez
La intuición es sencilla: cuando se alcanza una taza, no se decide cada milisegundo de forma independiente. se planifica un movimiento de alcance suave como una sola unidad. Crucialmente, los trozos superpuestos se mezclan a través del ensamblaje temporal, que promedia las predicciones de los trozos adyacentes para suavizar aún más la trayectoria y reducir el nerviosismo en los límites de los trozos.
ACT (Action Chunking with Transformers), introducido por Tony Zhao et al. en Stanford en 2023, combinó esta idea de acción chunking con una arquitectura de transformador CVAE (Conditional Variational Codificador Automático). El resultado fue el algoritmo de aprendizaje de imitación más eficiente de datos disponible: 50 demostraciones a menudo son suficientes para tareas simples de pick-and-place con tasas de éxito de más del 80%.
Abstracción temporal: reducción del horizonte efectivo
Una tarea de manipulación típica en el control de 50 Hz requiere 250
Es por eso que ACT trabaja con tan pocas demostraciones: el problema de aprendizaje es más simple. En lugar de aprender un mapeo de la observación a una sola acción de 7-DOF (para un brazo robótico típico), el modelo aprende un mapeo de la observación a una trayectoria de acción de 100 × 7.
ACT Arquitectura de la profundidad
ACT utiliza un Codificador Automático de variación condicional (CVAE) con una columna vertebral de encoder y decodificador Transformer.
El marco de la CVAE
Un CVAE añade una variable latente z a la línea de encoder y decodificador estándar. Durante el entrenamiento, el encoder observa tanto el estado actual como la secuencia de acción de verdad de la tierra, comprimiéndolos en una distribución sobre z. El decodificador toma una muestra de esta distribución más la observación actual y reconstruye la secuencia de acción.
Durante la inferencia, el codificador se descarta. El decodificador recibe una muestra del prior (una distribución normal estándar) y la observación actual, luego genera la parte de acción. El término de divergencia KL en la pérdida asegura que los posteriores permanecen cerca del anterior, por lo que la muestreo del anterior en el momento de la prueba produce secuencias de acción razonables.
La estructura CVAE tiene un propósito crítico: capta variabilidad intra-demonstration. Incluso para una sola tarea, la trayectoria exacta varía entre las demostraciones (ángulo de agarre ligeramente diferente, tiempo, trayectoria de aproximación). La variable latente z capta esta variación, lo que permite al decodificador producir trayectorias diversas pero válidas.
Arquitectura de codificación
El codificador ACT procesa entradas multimodal:
- ** Imágenes de la cámara**: Pasadas a través de una columna vertebral visual (ResNet-18 por defecto, opcional ViT).
- **Posiciones de articulación (qpos) **: Los ángulos de articulación del robot actuales, típicamente 6
7 DOF por brazo más estado de agarre. - **Secuencia de acción (solo de entrenamiento) **: La parte de la verdad de base de las acciones futuras de k, utilizada por el codificador CVAE para calcular la distribución posterior.
Las entradas se tokenizan y se introducen en un codificador Transformer. La salida es una representación latente que se proyecta a la media y la varianza de la distribución posterior q((
Arquitectura de decodificador
El decodificador es un decodificador estándar de Transformer con consultas de acción aprendibles. Hay consultas de k (una por paso de tiempo en la parte), cada una iniciada como una incorporación aprendida. El decodificador atende cruzando los tokens de observación codificados y el z latente muestrado, luego saca k vectores de acción a través de una cabeza de proyección lineal.
Cada acción prevista es un vector que contiene objetivos de posición conjuntos (6
Función de pérdida
# ACT loss computation (simplified)
L_reconstruction = L1_loss(predicted_actions, target_actions) # [batch, chunk_size, action_dim]
L_kl = KL_divergence(posterior_mean, posterior_logvar, prior) # regularize latent space
L_total = L_reconstruction + beta * L_kl # beta typically 10-20
El peso β en el término KL controla el compromiso entre la precisión de la reconstrucción y la regularidad latente del espacio. Demasiado bajo: el modelo ignora el anterior y genera acciones inconsistentes en el momento de la prueba. Demasiado alto: el modelo se derrumba para significar el comportamiento y pierde la expresividad.
Intuición matemática: selección del tamaño del trozo
El tamaño de la pieza k es el hiperparámetro más importante en ACT. Determina cuántas acciones futuras predice el modelo en cada paso.
La relación de frecuencia de control
A 50 Hz de control (el estándar para la mayoría de los brazos de robot), mapas del tamaño de los trozos directamente al horizonte de predicción:
| Chunk Size | Prediction Horizon | Best For |
|---|---|---|
| 25 | 0.5 seconds | Very fast reactive tasks, contact transitions |
| 50 | 1.0 second | Quick pick-and-place, single-arm tasks under 3 seconds |
| 100 | 2.0 seconds | Default — most tabletop manipulation tasks |
| 150 | 3.0 seconds | Slow precision tasks (insertion, assembly) |
| 200 | 4.0 seconds | Long-horizon smooth motions (pouring, wiping) |
El tamaño ideal de la pieza debe cubrir aproximadamente un submovimiento completo. Para una tarea de pick-and-place: el movimiento de alcance a agarre toma ~ 1,5 segundos, por lo que el chunk_size=75
Ensamblaje temporal
Durante el despliegue, ACT genera una nueva pieza en cada paso de tiempo (o cada pocos pasos de tiempo).
# Temporal ensembling (exponential weighting)
# w controls the blending — lower w gives more weight to recent predictions
w = 0.01 # default temporal ensembling weight
for t in range(episode_length):
new_chunk = policy.predict(observation_t) # shape: [chunk_size, action_dim]
for i in range(chunk_size):
all_predictions[t + i].append(new_chunk[i])
# Weighted average with exponential decay
weights = [np.exp(-w * j) for j in range(len(all_predictions[t]))]
action_t = np.average(all_predictions[t], weights=weights, axis=0)
El peso temporal de ensamblaje w (normalmente 0.01) controla la rapidez con que se descompone la predicción anterior.
Requisitos de recogida de datos para ACT
ACT es muy eficiente en datos, pero la calidad de los datos es primordial.
Cuenta de episodios mínimo
| Task Category | Episodes Needed | Expected Success Rate | Collection Time |
|---|---|---|---|
| Simple pick-and-place | 50–100 | 85%+ | 2–4 hours |
| Bimanual coordination | 100–200 | 80%+ | 4–8 hours |
| Precisión insertion (peg-in-hole) | 200–400 | 70%+ | 1–2 days |
| Complex multi-step tasks | 500+ | 60%+ | 2–5 days |
| Dexterous manipulation | 500–1,000 | 50%+ | 1–2 weeks |
Lista de control de calidad de los datos
- Demostraciones consistentes: Use un operador (o operadores con estilos muy similares). ACT asume una distribución de acción unimodal
estilos mixtos confunden el modelo. - ** Zona de colocación fija de objetos**: los objetos deben comenzar en aproximadamente la misma zona (dentro de una variación de ~ 5 cm). ACT no se generaliza bien a grandes cambios espaciales a menos que se entrenen explícitamente en ellos.
- Estados de inicio y fin limpios: Cada episodio debe comenzar desde la misma posición de inicio y terminar limpio (el pegatín cerrado en el objeto, o el objeto colocado en el objetivo).
- ** Timing coherente**: Intenta ejecutar la tarea a una velocidad similar en todas las demostraciones.
- ** Estabilidad de la cámara**: Las cámaras deben estar rigidamente montadas. Cualquier cambio de cámara entre episodios degrada significativamente el rendimiento.
Formatos de datos HDF5
RCSV entrega todos los datos recogidos en formato HDF5, que es el estándar para el entrenamiento ACT. Cada episodio se almacena como un único archivo HDF5 con la siguiente estructura:
# HDF5 episode structure for ACT training
episode_0.hdf5
├── observations/
│ ├── qpos # [T, 7] — joint positions (6 DOF + gripper)
│ ├── qvel # [T, 7] — joint velocities
│ ├── images/
│ │ ├── cam_high # [T, 480, 640, 3] — overhead camera
│ │ └── cam_wrist # [T, 480, 640, 3] — wrist camera
│ └── effort # [T, 7] — joint torques (optional)
├── action # [T, 7] — target joint positions
└── attrs/
├── sim # False (real robot data)
├── compress # True
└── num_timesteps # T
Para obtener servicios de recogida de datos listos para ACT, consulte Servicios de datos de RCSV. Proporcionamos configuraciones calibradas de múltiples cámaras, operadores capacitados, control de calidad y entrega en formato HDF5 o LeRobot Parquet.
Recomendaciones de configuración de la cámara
El rendimiento de ACT depende en gran medida de la configuración de la cámara.
- **Cámara de la cabeza (necesaria) **: Montada a 0,8
1,2 m sobre el espacio de trabajo, apuntando directamente hacia abajo. Proporciona una vista global de la escena y las posiciones de los objetos. Resolución: 640×480 mínimo. - **Camera de muñeca (fuertemente recomendada) **: Montada en la muñeca o antebrazo del robot. Proporciona una visión de cerca durante el agarre y la inserción. Es crítica para tareas de precisión en las que la cámara superior no puede resolver detalles finos.
- **Cámara lateral (opcional) **: Proporciona información de profundidad que puede perderse en las vistas de la cabeza y la muñeca.
Utilice cámaras USB 3.0 (Logitech C920 o Intel RealSense D405) con exposición fija y balance de blanco.
Entrenamiento a través del camino
En esta sección se desarrolla una formación de una política de ACT utilizando tanto el marco LeRobot como una implementación directa de PyTorch.
Formación con LeRobot (recomendado)
Hugging Face es el marco más accesible para el entrenamiento ACT en 2026.
# Step 1: Install LeRobot
pip install lerobot
# Step 2: Convert HDF5 data to LeRobot format
python -m lerobot.scripts.convert_dataset \
--raw-dir ./my_episodes/ \
--repo-id my-org/pick-place-task \
--raw-format hdf5_aloha
# Step 3: Train ACT policy
python -m lerobot.scripts.train \
policy=act \
dataset_repo_id=my-org/pick-place-task \
training.num_epochs=2000 \
training.batch_size=8 \
policy.chunk_size=100 \
policy.n_action_steps=100 \
policy.dim_model=512
# Step 4: Evaluate
python -m lerobot.scripts.eval \
--pretrained-policy-name-or-path outputs/train/act_pick-place-task/checkpoints/last/pretrained_model \
--env-name real_world \
--n-episodes 20
El entrenamiento generalmente se converge en 2
Configuración de entrenamiento directo PyTorch
Para los equipos que necesitan más control sobre el ciclo de entrenamiento o que deseen integrar ACT en una línea de tuberías personalizada:
# ACT training configuration — direct PyTorch implementation
import torch
from act.policy import ACTPolicy
from act.train import train_bc
config = {
# Architecture
'chunk_size': 100, # action chunk length (timesteps)
'hidden_dim': 512, # transformer hidden dimension
'dim_feedforward': 3200, # feedforward network dimension
'num_encoder_layers': 4, # transformer encoder layers
'num_decoder_layers': 7, # transformer decoder layers
'nheads': 8, # attention heads
'latent_dim': 32, # CVAE latent dimension
# Training
'lr': 1e-5, # learning rate (Adam)
'weight_decay': 1e-4, # L2 regularization
'num_epochs': 2000, # total training epochs
'batch_size': 8, # batch size (8 fits on 24 GB VRAM)
'kl_weight': 10, # beta for KL divergence term
'seed': 42,
# Data
'camera_names': ['cam_high', 'cam_wrist'],
'image_size': [480, 640], # H, W
'action_dim': 7, # 6 DOF + gripper
'state_dim': 7, # joint positions
# Augmentation
'color_jitter': True, # random brightness/contrast
'random_crop': True, # spatial augmentation
}
# Initialize and train
policy = ACTPolicy(config)
optimizer = torch.optim.AdamW(policy.parameters(), lr=config['lr'], weight_decay=config['weight_decay'])
train_bc(policy, optimizer, dataloader, config)
Consejos de formación
- Tasa de aprendizaje: Comience en 1e-5. ACT es sensible a la tasa de aprendizaje
demasiado alto (1e-4) causa inestabilidad en el entrenamiento, demasiado bajo (1e-6) converge demasiado lentamente. - ** Tamaño del lote**: Use 8 para 24 GB de VRAM (RTX 4090). Reducir a 4 para 12 GB de VRAM (RTX 3060). Los lotes más grandes (16
32) en A100 mejoran la estabilidad. - Epochs: Treno para 2000 épocas como mínimo. ACT a menudo muestra una mejora repentina alrededor de la época 1000
1500 después de una larga meseta. - Punto de control: Salvar cada 500 épocas. Evaluar todos los puntos de control guardados
el último punto de control no siempre es el mejor debido a la sobreajuste. - ** Normalización de la acción**: Normaliza las acciones a [-1, 1] utilizando las estadísticas del conjunto de datos. Acciones no normalizadas con diferentes escalas por falla de entrenamiento de causa conjunta.
Guía de ajuste de hiperparámetro
ACT tiene menos hiperparámetros que la Política de difusión, pero tres parámetros requieren un ajuste cuidadoso para cada nueva tarea.
Tamaño de pieza (pieza_tamaño)
El parámetro más impactante.
- Medir la duración media de un solo submovimiento en su tarea (por ejemplo, llegar a un objeto: 1,5 s).
- Multiplicar por frecuencia de control: 1,5 s × 50 Hz = 75 pasos temporales.
- Rondear hasta el más cercano 25: chunk_size = 100.
- Si la tarea tiene fases muy distintas (alcanzar, agarrar, retraer), la pieza debe cubrir al menos una fase completa.
Signos de que el tamaño de tu pieza es incorrecto:
- Demasiado pequeño: el robot duda en las transiciones, movimiento de jerky, se queda atascado en medio de movimiento.
- Demasiado grande: el robot exageradamente predice el final de la tarea, hace movimientos prematuros, desperdicia la capacidad de entrenamiento en predicciones futuras innecesarias.
Peso KL (kl_peso / β)
Controla la regularización de CVAE.
- β = 0: No hay regularización de la CVAE. El modelo degenera a clonación conductual estándar (sin variable latente).
- β = 10 (por defecto): buen equilibrio para la mayoría de las tareas. El espacio latente capta la variabilidad de la demostración sin colapsar.
- β = 20
50 : Regularización más fuerte, produce trayectorias más consistentes (menos variables). - β > 100: Demasiado fuerte. El modelo ignora los datos y produce un comportamiento promedio. Evita.
Número de consultas (número de consultas)
En el ACT original, num_queries es igual a chunk_size (una consulta por paso de tiempo). Algunas implementaciones permiten desacoplarlas, utilizando menos consultas con una capa de muestreo. A menos que tenga una razón específica para cambiar esto, mantenga num_queries = chunk_size.
El columna vertebral visual
ResNet-18 es el estándar y funciona bien para la mayoría de las tareas.
- ViT (DINOv2): Mejor para tareas que requieren una comprensión visual de granos finos (lectura de etiquetas, alineación precisa).
- ResNet-50: Mejora marginal respecto a ResNet-18 para la mayoría de las tareas de manipulación, pero duplica el uso de memoria.
- EfficientNet: buen compromiso para el despliegue móvil con computación limitada.
Recomendaciones de hardware
ACT ha sido validado en una serie de plataformas robóticas.
| Robot Platform | Price | Configuration | Best ACT Use Case | Lease from RCSV |
|---|---|---|---|---|
| OpenArm 1 | $4,500 | 6-DOF, leader-follower, open-source | Single-arm ACT research, entry-level imitation learning | from $800/mo |
| DK1 Bimanual | $12,000 | Dual 6-DOF arms, ALOHA-compatible | Bimanual ACT (original ALOHA workflow), folding, assembly | from $1,500/mo |
| Unitree G1 | $16,000 | 23-DOF humanoid, dual arms + locomotion | Whole-body ACT, mobile manipulation, loco-manipulation | from $2,500/mo |
| Unitree Go2 | $2,800 | Robot Cuadrúpedo, arm attachment option | Locomotion + arm manipulation, outdoor tasks | from $800/mo |
Requisitos de cálculo
| GPU | VRAM | Max Tamaño de Lote | Training Time (200 eps) | Inference Latencia |
|---|---|---|---|---|
| RTX 3060 | 12 GB | 4 | 8–16 hours | ~20 ms |
| RTX 4090 | 24 GB | 8 | 2–8 hours | ~12 ms |
| A100 | 40/80 GB | 16–32 | 1–3 hours | ~8 ms |
| H100 | 80 GB | 32–64 | <1 hour | ~5 ms |
ACT es uno de los algoritmos de aprendizaje de imitación más eficientes en la computación. Un RTX 3060 de consumo es suficiente para la capacitación y la implementación en tiempo real, lo que lo hace accesible a pequeños laboratorios e investigadores individuales.
Los modos y soluciones comunes de fallos
La formación en ACT es relativamente sencilla, pero los fallos en el despliegue son comunes.
1. El robot se desvía de la trayectoria en medio de la tarea
Causa: Demostraciones insuficientes o calidad de demostración inconsistente.
Fix: Recolectar 50 demostraciones más centrándose en la región exacta donde se produce la deriva. Asegúrese de que todas las demostraciones sigan la misma estrategia. Compruebe que las posiciones de la cámara no han cambiado.
2. Movimientos de desviación o oscilación
Causa: Ensamblaje temporal de peso demasiado alto, o tamaño de pieza demasiado pequeño.
Fix: Reducir el peso temporal de ensamblaje (intentar 0.005 en lugar de 0.01). Aumentar el tamaño de la pieza en 25
3. El robot se congela en las transiciones de captura/liberación
** Causa**: comandos de agarre ambiguos en los datos de demostración. Algunos demos agarrar temprano, otros tarde, creando una distribución bimodal que ACT promedia en "medio abierto".
Fix: Recoge demostraciones con un tiempo de agarre consistente.
4. Los niveles de entrenamiento son bajos pero el rendimiento es pobre
** Causa**: peso KL demasiado alto (β > 50), causando el colapso posterior. El modelo aprende a ignorar la variable latente y predice el comportamiento promedio.
Fix: Reducir el peso de KL a 10 o menos.
5. Trabaja en objetos de formación pero no en nuevos objetos
** Causa**: ACT no generaliza a nuevos objetos por defecto. Es un algoritmo de una sola tarea.
Fix: Recoge demostraciones con objetos diversos (combinaciones, tamaños, formas). Utilice el aumento de imagen (jitar de color, cosecha aleatoria). Para una generalización de objetos verdadera, considere cambiar a un modelo VLA (ver nuestra guía de aprendizaje de imitación)
6. Se rompe la coordinación bimanual
Las armas se predicen de forma independiente, perdiendo el tiempo de coordinación.
Fix: Asegúrese de que las acciones de ambos brazos estén en el mismo vector de acción (14-DOF: 7 por brazo). No entrenar políticas separadas por brazo. Aumentar el tamaño de la pieza para cubrir el movimiento coordinado completo.
ACT vs. Política de difusión: cuándo usar cuál
| Dimension | ACT | Diffusion Policy |
|---|---|---|
| Data efficiency | 50–200 demos | 100–500 demos |
| Multi-modal actions | Limited (CVAE helps but not fully multimodal) | Excellent (denoising naturally captures multiple modes) |
| Inference speed | 50+ Hz (single forward pass) | 10–30 Hz (iterative denoising) |
| Trayectoria smoothness | Good (temporal ensembling) | Excellent (inherent to diffusion process) |
| Training time | 2–8 hours (RTX 4090) | 4–16 hours (RTX 4090) |
| Hyperparameter sensitivity | Low (mainly chunk_size and kl_weight) | Medium (noise schedule, denoising steps, network architecture) |
| Language conditioning | Not supported natively | Not supported natively (extensions exist) |
| Framework support | LeRobot, robomimic | LeRobot, robomimic, diffusion_policy repo |
| Best for | Fast prototyping, single-strategy tasks, limited data budgets | Multi-strategy tasks, contact-rich manipulation, diverse operator data |
Regla de la regla general: Comience con ACT. Se entrena más rápido, requiere menos datos y le permite validar rápidamente su línea de recopilación de datos.
Despliegue en robots reales
Una vez entrenado, implementar una política ACT implica cargar el modelo y ejecutarlo en un bucle de control.
# ACT deployment on real robot (pseudocode)
import torch
import numpy as np
from act.policy import ACTPolicy
# Load trained policy
policy = ACTPolicy.load("checkpoints/act_epoch_2000.pt")
policy.eval()
policy.cuda()
# Initialize robot and cameras
robot = RobotInterface(port="/dev/ttyUSB0", hz=50)
cameras = CameraInterface(names=["cam_high", "cam_wrist"])
# Action buffer for temporal ensembling
all_actions = {}
temporal_weight = 0.01
for t in range(max_steps):
# Get observation
images = cameras.get_images() # dict of [H, W, 3] arrays
qpos = robot.get_joint_positions() # [7]
# Predict action chunk
with torch.no_grad():
obs = preprocess(images, qpos) # normalize, resize, to_tensor
action_chunk = policy(obs) # [chunk_size, action_dim]
action_chunk = action_chunk.cpu().numpy()
# Temporal ensembling
for i in range(len(action_chunk)):
if (t + i) not in all_actions:
all_actions[t + i] = []
all_actions[t + i].append(action_chunk[i])
if t in all_actions:
preds = np.array(all_actions[t])
weights = np.exp(-temporal_weight * np.arange(len(preds)))[::-1]
action = np.average(preds, weights=weights, axis=0)
else:
action = action_chunk[0]
# Execute action
robot.set_joint_positions(action[:6])
robot.set_gripper(action[6])
robot.step()
robot.go_home()
Tópicos avanzados
ACT con VLA Preentrenamiento
El trabajo reciente (2025
ACT para la manipulación deficiente
La aplicación de ACT a manos hábiles (como la Mano de Orca con 17 DOF) requiere ajustes:
- Aumentar la acción_dim para que coincida con la mano DOF (por ejemplo, 23 para el brazo 6-DOF + 17-DOF mano).
- Aumentar el tamaño de la pieza a 150
200 Los movimientos de manipulación hábiles son más lentos y más complejos. - Utilice la cámara de muñeca como la entrada visual principal
la cámara superior no puede resolver las configuraciones de los dedos. - Recolectar más de 500 demostraciones
el espacio de acción de mayor dimensión requiere más datos.
Acta de tareas múltiples
El ACT estándar es una tarea única. Para la operación de múltiples tareas, en la práctica funcionan dos enfoques:
- ** ACT con tarea: añadir una tarea integrada (un hot o aprendida) a la entrada del codificador. Entrenar en datos mixtos de múltiples tareas. Funciona para 3
5 tareas relacionadas. - ACT con condiciones de lenguaje: reemplaza la tarea integrada con una instrucción de lenguaje codificada por un modelo CLIP o SigLIP congelado. Más flexible pero requiere más datos por tarea. Consulte herramientas como [LeRobot]
T20 ) y [robomimic] T21 ) para implementaciones.
Preguntas frecuentes
¿Qué es el Acción de Cuncing con Transformadores (ACT)?
ACT es un algoritmo de aprendizaje de imitación de robots introducido por Tony Zhao et al. en Stanford en 2023. Predece una secuencia (pieza) de acciones futuras
¿Cuántas demostraciones necesita ACT?
50
¿Qué tamaño de pieza debería usar?
Comience con 100 a 50 Hz (2 segundos). Para tareas rápidas menores a 3 segundos, reduce a 50. Para tareas de precisión lenta, aumente a 150
¿Puede ACT manejar múltiples estrategias válidas?
La variable latente CVAE de ACT proporciona cierta multi-modalidad, pero está diseñada fundamentalmente para distribuciones de acción unimodal. Si su tarea tiene estrategias válidas realmente diferentes (por ejemplo, agarrar de izquierda a derecha), ACT las promediará, produciendo una trayectoria media fallida. Utilice [Política de difusión]
¿Qué formato de datos espera ACT?
HDF5 es el formato estándar. Cada episodio contiene posiciones conjuntas (qpos), velocidades conjuntas (qvel), imágenes de cámara y acciones de objetivo. El servicio de recopilación de datos de RCSV (T23
Recoge datos de entrenamiento de ACT-Preparado desde $2,500
RCSV proporciona una recopilación de datos de extremo a extremo para el entrenamiento de ACT: configuraciones calibradas de múltiples cámaras, teleoperadores capacitados, control de calidad y entrega en formato HDF5 o LeRobot Parquet.
[Servicios de recogida de datos] [