手把手教你用ACT算法实现机器人动作模仿（附Python代码）

手把手教你用ACT算法实现机器人动作模仿（附Python代码）

在机器人学习领域，动作模仿一直是个令人着迷的挑战。想象一下，如果机器人能像人类一样观察并复制动作，那将开启多少可能性？从工业生产到家庭服务，从医疗辅助到危险环境作业，这种能力都能带来革命性的改变。而ACT算法（Action Chunking with Transformers）正是实现这一愿景的关键技术之一。

ACT算法结合了条件变分自编码器（CVAE）和Transformer架构的优势，能够处理多模态输入（如视觉和关节状态），并输出连续的动作序列。不同于传统的模仿学习方法，ACT通过"动作分块"策略将长序列分解为可管理的片段，显著提高了动作生成的稳定性和准确性。对于想要快速上手ACT算法的开发者来说，本文将提供从数据准备到模型部署的完整实现路径。

1. 环境准备与数据预处理

在开始实现ACT算法之前，我们需要搭建合适的开发环境并准备训练数据。这一步看似基础，却直接影响后续模型训练的效果和效率。

1.1 安装必要的Python库

首先确保你的Python环境（建议3.8+）已安装以下核心库：

pip install torch torchvision numpy matplotlib pip install einops # 用于简化张量操作 pip install tqdm # 进度条显示

对于GPU加速，建议安装对应版本的CUDA工具包。可以通过以下命令验证PyTorch是否正确识别了GPU：

import torch print(torch.cuda.is_available()) # 应返回True print(torch.cuda.device_count()) # 显示可用GPU数量

1.2 数据收集与预处理

ACT算法需要两种主要输入数据：视觉观察（通常来自多个摄像头）和关节状态。假设我们使用的是类似lerobot的开源数据集，数据预处理流程如下：

1. 图像处理：

   • 将原始图像(480×640×3)调整为统一尺寸(224×224)
   • 应用标准化：mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
   • 多视角图像拼接或分别处理

2. 关节状态归一化：

   • 将原始关节角度映射到[-1,1]范围
   • 处理缺失值或异常值

import torchvision.transforms as T # 定义图像预处理流水线 image_transform = T.Compose([ T.Resize(224), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # 关节状态归一化示例 def normalize_joints(joints, min_vals, max_vals): return 2 * (joints - min_vals) / (max_vals - min_vals) - 1

注意：数据预处理参数应与实际数据集统计量一致。建议先分析整个数据集的均值和方差，再确定标准化参数。

2. ACT模型架构实现

ACT的核心在于其创新的模型架构，巧妙结合了CVAE和Transformer的优势。下面我们将分模块实现这一架构。

2.1 编码器实现

编码器负责将输入数据压缩到潜在空间，其关键组件包括：

• 关节状态嵌入层：将原始关节角度映射到高维空间
• 视觉特征提取器：通常使用预训练的CNN（如ResNet）
• Transformer编码器：处理序列数据并提取全局特征

import torch.nn as nn from torchvision.models import resnet18 class ACTEncoder(nn.Module): def __init__(self, joint_dim=14, latent_dim=32, hidden_dim=512): super().__init__() # 关节状态嵌入 self.joint_embed = nn.Linear(joint_dim, hidden_dim) # 视觉特征提取（使用预训练ResNet18） self.visual_backbone = resnet18(pretrained=True) self.visual_backbone.fc = nn.Identity() # 移除最后的全连接层 # Transformer编码器 encoder_layer = nn.TransformerEncoderLayer( d_model=hidden_dim, nhead=8, dim_feedforward=hidden_dim*4) self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=6) # 潜在变量投影 self.latent_proj = nn.Linear(hidden_dim, latent_dim*2) # μ和logσ² def forward(self, images, joints): # 处理视觉输入 visual_feats = self.visual_backbone(images) # [batch, 512] # 处理关节状态 joint_feats = self.joint_embed(joints) # [batch, hidden_dim] # 组合特征并添加CLS token cls_token = torch.zeros_like(joint_feats[:, :1]) + 0.1 # 可学习的初始化 combined = torch.cat([cls_token, joint_feats, visual_feats.unsqueeze(1)], dim=1) # Transformer处理 encoded = self.transformer(combined) # 提取CLS token对应的特征并投影到潜在空间 cls_feature = encoded[:, 0] latent_params = self.latent_proj(cls_feature) mu, logvar = latent_params.chunk(2, dim=-1) return mu, logvar

2.2 解码器实现

解码器负责从潜在变量生成动作序列，其关键创新在于：

• 多模态特征融合：结合视觉、关节状态和潜在变量
• 自回归动作生成：使用Transformer解码器逐步预测动作

class ACTDecoder(nn.Module): def __init__(self, joint_dim=14, latent_dim=32, hidden_dim=512, action_chunk_size=10): super().__init__() self.action_chunk_size = action_chunk_size # 输入嵌入层 self.latent_embed = nn.Linear(latent_dim, hidden_dim) self.joint_embed = nn.Linear(joint_dim, hidden_dim) # Transformer解码器 decoder_layer = nn.TransformerDecoderLayer( d_model=hidden_dim, nhead=8, dim_feedforward=hidden_dim*4) self.transformer = nn.TransformerDecoder(decoder_layer, num_layers=6) # 动作预测头 self.action_head = nn.Linear(hidden_dim, joint_dim) # 位置编码（用于动作序列） self.pos_embed = nn.Parameter( torch.randn(1, action_chunk_size, hidden_dim)) def forward(self, latent_z, joints, visual_feats): # 嵌入各种输入 z_embed = self.latent_embed(latent_z).unsqueeze(1) # [batch, 1, hidden] joint_embed = self.joint_embed(joints).unsqueeze(1) # [batch, 1, hidden] # 组合特征作为memory memory = torch.cat([z_embed, joint_embed, visual_feats], dim=1) # 生成查询位置编码 query_pos = self.pos_embed.expand(latent_z.size(0), -1, -1) # Transformer解码 decoded = self.transformer(query_pos, memory) # 预测动作 actions = self.action_head(decoded) # [batch, chunk_size, joint_dim] return actions

3. 训练策略与技巧

ACT算法的训练需要特别注意损失函数设计和训练技巧，这对最终性能有决定性影响。

3.1 损失函数设计

ACT使用两种主要损失：

1. 重构损失：衡量预测动作与真实动作的差异
2. KL散度：规范潜在空间分布

def act_loss(pred_actions, true_actions, mu, logvar): # 重构损失（MSE） recon_loss = nn.functional.mse_loss(pred_actions, true_actions) # KL散度（负号是因为我们要最小化KL） kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) kl_loss = kl_loss / mu.size(0) # 取平均 # 总损失 total_loss = recon_loss + 0.1 * kl_loss # kl_weight=0.1 return total_loss, recon_loss, kl_loss

3.2 训练循环实现

一个完整的训练循环应包括以下步骤：

1. 数据加载与批处理
2. 前向传播与潜在变量采样
3. 损失计算与反向传播
4. 模型参数更新

def train_epoch(model, dataloader, optimizer, device): model.train() total_loss = 0 for batch_idx, (images, joints, actions) in enumerate(dataloader): # 数据转移到设备 images = images.to(device) joints = joints.to(device) actions = actions.to(device) # 清零梯度 optimizer.zero_grad() # 编码器前向传播 mu, logvar = model.encoder(images, joints) # 重参数化采样 std = torch.exp(0.5 * logvar) eps = torch.randn_like(std) z = mu + eps * std # 解码器前向传播 pred_actions = model.decoder(z, joints, images) # 计算损失 loss, recon_loss, kl_loss = act_loss( pred_actions, actions, mu, logvar) # 反向传播 loss.backward() optimizer.step() total_loss += loss.item() if batch_idx % 100 == 0: print(f"Batch {batch_idx}: Loss={loss.item():.4f} " f"(Recon={recon_loss.item():.4f}, KL={kl_loss.item():.4f})") return total_loss / len(dataloader)

提示：训练过程中可以逐渐增加kl_weight，从0开始线性增加到0.1，这被称为KL退火策略，能帮助模型先专注于学习重构。

4. 推理优化与部署

训练好的ACT模型需要针对实际应用场景进行优化，特别是在实时性要求高的机器人控制场景。

4.1 推理流程优化

推理阶段可以省略编码器，直接使用解码器生成动作：

class ACTInference: def __init__(self, model_path, device="cuda"): # 加载预训练模型 self.model = torch.load(model_path).to(device) self.device = device def predict(self, images, joints): # 使用零向量替代潜在变量 batch_size = images.size(0) z = torch.zeros(batch_size, 32).to(self.device) # 生成动作 with torch.no_grad(): actions = self.model.decoder(z, joints, images) return actions.cpu().numpy()

4.2 实际部署考虑

将ACT模型部署到实际机器人系统时，需要考虑：

• 延迟优化：使用TensorRT或ONNX Runtime加速
• 内存占用：量化模型权重（FP16或INT8）
• 安全性：动作滤波和碰撞检测

# 示例：将模型导出为ONNX格式 def export_onnx(model, output_path): dummy_z = torch.randn(1, 32) dummy_joints = torch.randn(1, 14) dummy_images = torch.randn(1, 3, 224, 224) torch.onnx.export( model.decoder, (dummy_z, dummy_joints, dummy_images), output_path, input_names=["z", "joints", "images"], output_names=["actions"], dynamic_axes={ "z": {0: "batch"}, "joints": {0: "batch"}, "images": {0: "batch"}, "actions": {0: "batch"} } )

5. 进阶技巧与问题排查

在实际项目中应用ACT算法时，开发者常会遇到各种挑战。以下是一些实用技巧：

5.1 提升动作质量的技巧

• 数据增强：对训练数据应用随机旋转、平移和颜色抖动
• 课程学习：先训练短动作序列，再逐步增加长度
• 多任务学习：同时预测末端执行器位置和关节角度

# 数据增强示例 augment_transform = T.Compose([ T.RandomRotation(10), T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), T.RandomPerspective(distortion_scale=0.1), T.Resize(224), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])

5.2 常见问题与解决方案

在机器人实验室的实际测试中，我们发现ACT算法对超参数相当敏感。特别是kl_weight的选择，过高会导致动作过于保守，过低则可能生成不合理的动作。经过多次实验，0.05到0.1之间的值通常能取得较好平衡。另一个关键点是动作分块大小（action_chunk_size），对于大多数机械臂任务，10到20步的分块效果最佳。