介绍
彼得·阿比尔(Pieter Abbeel)是加州大学伯克利分校电气工程与计算机科学系教授，同时担任伯克利机器人学习实验室主任和伯克利人工智能研究实验室(BAIR)联合主任。他是机器学习领域的权威专家，培养了多位知名AI企业的创始人，包括OpenAI创始团队成员约翰·舒尔曼、Perplexity的CEO阿拉温德·斯里尼瓦斯等。在GTC 2025上，阿比尔进行了一场关于”机器人训练数据”的主题演讲，探讨如何解决人形机器人的数据困境问题。<机器人如何获得训练数据的视频>
机器人如何获得训练数据：方法、示例与代码实现
数据获取方法概述
根据彼得·阿比尔(Pieter Abbeel)的研究，机器人训练数据主要通过以下几种方式获取：
- 远程操作(Teleoperation) – 通过人类直接控制机器人收集动作数据
- 手部动作跟踪 – 跟踪人类手部动作并转化为机器人指令
- 仿真环境 – 在虚拟环境中生成大量训练数据
- 现实世界学习 – 机器人在真实环境中通过试错学习
- 模仿学习 – 观察并模仿人类行为
下面为每种方法提供具体示例和相关代码实现:
1. 远程操作数据收集
远程操作是获取高质量机器人训练数据的直接方法。例如，Physical Intelligence (PI)公司通过远程操作系统收集了机器人整理衣物的数据。
示例代码 – 远程操作数据收集
import numpy as np
import time
import json
import robotlib # 假设的机器人控制库
class TeleoperationDataCollector:
def __init__(self, robot, save_path="teleop_data.json"):
self.robot = robot
self.save_path = save_path
self.data = []
def record_frame(self, human_input, robot_state):
"""记录一帧远程操作数据"""
frame = {
"timestamp": time.time(),
"joint_angles": robot_state.joint_angles.tolist(),
"gripper_state": robot_state.gripper_state,
"human_command": human_input.tolist(),
"camera_image": robot_state.get_camera_image_path()
}
self.data.append(frame)
def save_data(self):
"""保存收集的数据"""
with open(self.save_path, 'w') as f:
json.dump(self.data, f)
print(f"保存了 {len(self.data)} 帧远程操作数据到 {self.save_path}")
# 使用示例
def collect_folding_data():
robot = robotlib.connect_robot("192.168.1.100") # 连接到机器人
collector = TeleoperationDataCollector(robot)
print("开始数据收集，按 Ctrl+C 停止...")
try:
while True:
human_input = get_human_controller_input() # 获取操作者输入
robot.execute_command(human_input) # 执行命令
robot_state = robot.get_state() # 获取机器人状态
collector.record_frame(human_input, robot_state)
time.sleep(0.1) # 10Hz 采样率
except KeyboardInterrupt:
collector.save_data()
print("数据收集完成")
2. 仿真环境数据生成
使用物理仿真器(如MuJoCo)可以生成大量的训练数据，这些数据可以用于预训练机器人控制模型。
示例代码 – MuJoCo仿真数据生成
import mujoco
import numpy as np
import time
class RobotSimulator:
def __init__(self, model_path, task_type="walking"):
self.model = mujoco.MjModel.from_xml_path(model_path)
self.data = mujoco.MjData(self.model)
self.task_type = task_type
self.collected_data = []
def reset(self):
"""重置仿真环境"""
mujoco.mj_resetData(self.model, self.data)
# 随机初始状态以增加多样性
self.data.qpos[:] = self.data.qpos[:] + np.random.uniform(-0.1, 0.1, size=self.model.nq)
mujoco.mj_forward(self.model, self.data)
return self._get_observation()
def _get_observation(self):
"""获取观察状态"""
qpos = self.data.qpos.copy()
qvel = self.data.qvel.copy()
# 可以根据需要添加更多传感器数据
return {"qpos": qpos, "qvel": qvel}
def step(self, action):
"""执行一步仿真"""
self.data.ctrl[:] = action
for _ in range(10): # 10个物理仿真步骤
mujoco.mj_step(self.model, self.data)
obs = self._get_observation()
reward = self._compute_reward()
done = self._check_termination()
# 记录数据
frame_data = {
"observation": obs,
"action": action.copy(),
"reward": reward,
"done": done
}
self.collected_data.append(frame_data)
return obs, reward, done, {}
def _compute_reward(self):
"""计算奖励函数，取决于任务类型"""
if self.task_type == "walking":
# 对于行走任务，奖励前进距离并惩罚能量消耗
forward_reward = self.data.qpos[0] # x坐标位置
energy_penalty = np.sum(np.square(self.data.ctrl))
return forward_reward - 0.1 * energy_penalty
# 可以添加其他任务类型的奖励函数
return 0.0
def _check_termination(self):
"""检查是否应终止当前回合"""
# 例如，如果机器人摔倒，则终止
height = self.data.qpos[2] # z坐标高度
return height < 0.7 # 假设正常高度应大于0.7
def save_collected_data(self, filename):
"""保存收集的数据"""
np.save(filename, self.collected_data)
print(f"保存了 {len(self.collected_data)} 帧仿真数据到 {filename}")
# 使用示例
def generate_walking_data(episodes=100):
sim = RobotSimulator("humanoid.xml", task_type="walking")
for episode in range(episodes):
obs = sim.reset()
done = False
while not done:
# 使用随机策略或预定义的控制器生成动作
action = np.random.uniform(-1, 1, size=sim.model.nu)
obs, reward, done, _ = sim.step(action)
print(f"完成第 {episode+1}/{episodes} 回合")
sim.save_collected_data("walking_simulation_data.npy")
3. 基于视觉的手部动作跟踪
如加州大学圣地亚哥分校的王小龙教授团队所示，通过视觉设备跟踪人类手部动作可以为机器人提供操作指导。
示例代码 – 手部动作跟踪
import cv2
import mediapipe as mp
import numpy as np
class HandTracker:
def __init__(self):
self.mp_hands = mp.solutions.hands
self.hands = self.mp_hands.Hands(
static_image_mode=False,
max_num_hands=2,
min_detection_confidence=0.5,
min_tracking_confidence=0.5
)
self.mp_drawing = mp.solutions.drawing_utils
def process_frame(self, frame):
"""处理一帧图像并提取手部关键点"""
# 转换为RGB格式
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# 处理图像
results = self.hands.process(frame_rgb)
hand_landmarks = []
if results.multi_hand_landmarks:
for hand_landmarks_data in results.multi_hand_landmarks:
# 绘制手部关键点
self.mp_drawing.draw_landmarks(
frame, hand_landmarks_data, self.mp_hands.HAND_CONNECTIONS)
# 提取关键点坐标
landmarks = []
for landmark in hand_landmarks_data.landmark:
landmarks.append([landmark.x, landmark.y, landmark.z])
hand_landmarks.append(np.array(landmarks))
return frame, hand_landmarks
def convert_to_robot_commands(self, hand_landmarks):
"""将手部关键点转换为机器人指令"""
if not hand_landmarks:
return None
# 示例：使用第一只手的关键点
landmarks = hand_landmarks[0]
# 计算指尖位置 (拇指、食指、中指)
thumb_tip = landmarks[4]
index_tip = landmarks[8]
middle_tip = landmarks[12]
# 计算拇指和食指间距，用于控制夹爪
pinch_distance = np.linalg.norm(thumb_tip - index_tip)
gripper_command = 1.0 if pinch_distance < 0.1 else 0.0
# 手掌中心作为位置控制
palm_center = np.mean(landmarks[[0, 1, 5, 9, 13, 17]], axis=0)
# 转换为机器人坐标系 (示例转换)
robot_pos = palm_center * np.array([2.0, 2.0, 2.0]) - np.array([1.0, 1.0, 0.0])
return {
"position": robot_pos,
"gripper": gripper_command
}
# 使用示例
def hand_tracking_demo():
cap = cv2.VideoCapture(0)
tracker = HandTracker()
collected_data = []
while cap.isOpened():
success, frame = cap.read()
if not success:
break
frame, hand_landmarks = tracker.process_frame(frame)
robot_command = tracker.convert_to_robot_commands(hand_landmarks)
if robot_command:
# 记录数据
data_point = {
"timestamp": time.time(),
"hand_landmarks": hand_landmarks[0].tolist() if hand_landmarks else None,
"robot_command": robot_command
}
collected_data.append(data_point)
# 显示机器人命令
cv2.putText(frame, f"Gripper: {robot_command['gripper']:.1f}", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
cv2.imshow('Hand Tracking', frame)
if cv2.waitKey(5) & 0xFF == 27: # ESC键退出
break
cap.release()
cv2.destroyAllWindows()
# 保存收集的数据
np.save("hand_tracking_data.npy", collected_data)
print(f"保存了 {len(collected_data)} 帧手部跟踪数据")
4. 基于Body Transformer的模型训练
阿比尔介绍的Body Transformer使用局部连接的架构，提高了模仿学习的效率和可扩展性。
示例代码 – Body Transformer模型
import torch
import torch.nn as nn
import torch.nn.functional as F
class MaskedSelfAttention(nn.Module):
"""带有局部连接掩码的自注意力机制"""
def __init__(self, embed_dim, num_heads, robot_structure_matrix):
super().__init__()
self.embed_dim = embed_dim
self.num_heads = num_heads
self.head_dim = embed_dim // num_heads
# 机器人结构矩阵定义哪些关节可以相互关注
# 形状为 [num_joints, num_joints]，1表示允许关注，0表示禁止
self.register_buffer("robot_structure_mask", robot_structure_matrix.unsqueeze(0).repeat(num_heads, 1, 1))
self.q_proj = nn.Linear(embed_dim, embed_dim)
self.k_proj = nn.Linear(embed_dim, embed_dim)
self.v_proj = nn.Linear(embed_dim, embed_dim)
self.out_proj = nn.Linear(embed_dim, embed_dim)
def forward(self, x):
batch_size, seq_len, _ = x.shape
# 投影查询、键、值
q = self.q_proj(x).reshape(batch_size, seq_len, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
k = self.k_proj(x).reshape(batch_size, seq_len, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
v = self.v_proj(x).reshape(batch_size, seq_len, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
# 计算注意力分数
attention = torch.matmul(q, k.transpose(-1, -2)) / (self.head_dim ** 0.5)
# 应用机器人结构掩码
attention = attention.masked_fill(self.robot_structure_mask[:, :seq_len, :seq_len] == 0, float('-inf'))
# 应用softmax并与值相乘
attention = F.softmax(attention, dim=-1)
out = torch.matmul(attention, v)
# 重塑并投影输出
out = out.permute(0, 2, 1, 3).reshape(batch_size, seq_len, self.embed_dim)
out = self.out_proj(out)
return out
class BodyTransformerBlock(nn.Module):
"""Body Transformer块"""
def __init__(self, embed_dim, num_heads, robot_structure_matrix, ffn_dim, dropout=0.1):
super().__init__()
self.attn = MaskedSelfAttention(embed_dim, num_heads, robot_structure_matrix)
self.ffn = nn.Sequential(
nn.Linear(embed_dim, ffn_dim),
nn.GELU(),
nn.Linear(ffn_dim, embed_dim)
)
self.norm1 = nn.LayerNorm(embed_dim)
self.norm2 = nn.LayerNorm(embed_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, x):
# 自注意力 + 残差连接
attn_out = self.attn(x)
x = self.norm1(x + self.dropout(attn_out))
# 前馈网络 + 残差连接
ffn_out = self.ffn(x)
x = self.norm2(x + self.dropout(ffn_out))
return x
class BodyTransformer(nn.Module):
"""针对机器人控制的Body Transformer模型"""
def __init__(self, num_joints, embed_dim, num_heads, num_layers, ffn_dim, robot_structure_matrix, dropout=0.1):
super().__init__()
self.joint_embed = nn.Linear(7, embed_dim) # 每个关节用7个值表示 (位置3 + 方向4)
# 创建Body Transformer块
self.transformer_blocks = nn.ModuleList([
BodyTransformerBlock(embed_dim, num_heads, robot_structure_matrix, ffn_dim, dropout)
for _ in range(num_layers)
])
# 预测每个关节的下一个状态
self.joint_pred = nn.Linear(embed_dim, 7)
def forward(self, joints_state):
# joints_state: [batch_size, num_joints, 7]
batch_size, num_joints, _ = joints_state.shape
# 嵌入每个关节的状态
x = self.joint_embed(joints_state)
# 通过Transformer块
for transformer_block in self.transformer_blocks:
x = transformer_block(x)
# 预测下一个关节状态
next_joints = self.joint_pred(x)
return next_joints
# 使用示例
def train_body_transformer():
# 定义机器人结构矩阵 (简化示例)
num_joints = 20
# 创建一个只允许相邻关节互相关注的矩阵
robot_structure = torch.zeros(num_joints, num_joints)
for i in range(num_joints):
# 自身可以关注
robot_structure[i, i] = 1
# 相邻关节可以关注
if i > 0:
robot_structure[i, i-1] = 1
robot_structure[i-1, i] = 1
# 创建模型
model = BodyTransformer(
num_joints=num_joints,
embed_dim=128,
num_heads=4,
num_layers=3,
ffn_dim=256,
robot_structure_matrix=robot_structure
)
# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
# 训练循环 (伪代码)
def train_epoch(dataloader):
model.train()
total_loss = 0
for batch in dataloader:
current_joints, next_joints = batch
optimizer.zero_grad()
# 前向传播
pred_next_joints = model(current_joints)
# 计算损失
loss = criterion(pred_next_joints, next_joints)
# 反向传播
loss.backward()
optimizer.step()
total_loss += loss.item()
return total_loss / len(dataloader)
print("Body Transformer模型创建成功，可以开始训练")
5. MuJoCo Playground示例
MuJoCo Playground是阿比尔与Google DeepMind合作开发的开源仿真平台，用于定义任务并训练机器人。
示例代码 – MuJoCo Playground使用
import dm_control
import mujoco
import numpy as np
from dm_control import suite, viewer
from dm_control.rl import control
class HumanoidWalkingTask:
"""使用MuJoCo Playground创建的人形机器人行走任务"""
def __init__(self):
# 加载人形机器人模型
self.env = suite.load(domain_name="humanoid", task_name="walk")
# 定义奖励组件
self.reward_components = {
"forward_velocity": 1.0, # 奖励前向速度
"energy_efficiency": -0.1, # 惩罚能量消耗
"stay_upright": 2.0, # 奖励保持直立
"healthy_joints": -1.0, # 惩罚关节到达极限位置
}
def reset(self):
"""重置环境并返回初始观察"""
time_step = self.env.reset()
return time_step.observation
def step(self, action):
"""执行动作并返回结果"""
time_step = self.env.step(action)
# 计算复合奖励
detailed_reward = self._compute_detailed_reward(time_step)
return {
"observation": time_step.observation,
"reward": time_step.reward,
"detailed_reward": detailed_reward,
"done": time_step.last()
}
def _compute_detailed_reward(self, time_step):
"""计算详细的奖励分解"""
obs = time_step.observation
physics = self.env.physics
# 提取相关状态
velocity = physics.horizontal_velocity()
upright = physics.torso_upright()
joint_angles = physics.joint_angles()
joint_limit_distances = physics.joint_margin()
actuator_effort = np.sum(np.square(physics.control()))
# 计算各奖励分量
rewards = {
"forward_velocity": self.reward_components["forward_velocity"] * velocity[0],
"energy_efficiency": self.reward_components["energy_efficiency"] * actuator_effort,
"stay_upright": self.reward_components["stay_upright"] * upright,
"healthy_joints": self.reward_components["healthy_joints"] * np.mean(joint_limit_distances < 0.05),
}
# 总奖励
rewards["total"] = sum(rewards.values())
return rewards
def render(self):
"""渲染当前帧"""
return self.env.physics.render()
# 使用PPO算法训练示例
def train_humanoid_with_ppo():
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Normal
# 简化的PPO策略网络
class PPOPolicy(nn.Module):
def __init__(self, obs_dim, act_dim):
super().__init__()
self.actor_mean = nn.Sequential(
nn.Linear(obs_dim, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, act_dim)
)
self.actor_log_std = nn.Parameter(torch.zeros(act_dim))
self.critic = nn.Sequential(
nn.Linear(obs_dim, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 1)
)
def forward(self, obs):
action_mean = self.actor_mean(obs)
action_std = torch.exp(self.actor_log_std)
value = self.critic(obs)
return action_mean, action_std, value
def get_action(self, obs, deterministic=False):
action_mean, action_std, _ = self(obs)
if deterministic:
return action_mean
dist = Normal(action_mean, action_std)
action = dist.sample()
log_prob = dist.log_prob(action).sum(-1)
return action, log_prob
# 设置任务和模型
task = HumanoidWalkingTask()
obs = task.reset()
# 确定观察和动作维度
obs_keys = list(obs.keys())
obs_dim = sum(np.prod(obs[k].shape) for k in obs_keys)
act_dim = task.env.action_spec().shape[0]
# 创建策略
policy = PPOPolicy(obs_dim, act_dim)
optimizer = optim.Adam(policy.parameters(), lr=3e-4)
# 训练循环简化示例
def flatten_obs(obs_dict):
return np.concatenate([obs_dict[k].flatten() for k in obs_keys])
print("开始训练人形机器人行走任务...")
# 收集数据和训练逻辑省略，实际代码中会包含完整的PPO算法实现
print("训练完成！")
机器人如何获得训练数据的视频:
视频摘要:
机器人的数据困境
阿比尔指出，随着硬件的不断进步，如今机器人缺少的就是”大脑”，而大脑的关键驱动力是AI。与大语言模型可以依靠海量互联网数据训练不同，目前世界上还没有真正的人形机器人，也就没有大量的行为数据。因此，找到有效的数据源是机器人学中的一大挑战和机遇。
数据采集方法
远程操作
远程操作是一种直接获取关节角度、操作力度等数据的方法，类似于大语言模型的数据获取方式。虽然这种方法耗时且昂贵，但斯坦福大学的切尔西·芬恩团队已证明，通过适当设置，可以快速收集数据。Physical Intelligence(PI)公司成功建立了大规模的数据收集系统，展示了机器人自我纠错的能力。
手部动作跟踪
加州大学圣地亚哥分校的王小龙教授团队与麻省理工学院合作，证明可以使用Apple Vision Pro进行远程操作来跟踪手部动作。尽管存在延时问题，但这种方法可以让机器人完成一些需要精细操作的任务。
仿真环境
通过大规模的仿真环境获取数据是另一种方法，但仿真并不总是与现实完全吻合，因为无法将所有现实世界元素都融入到模拟器中。
现实世界学习
直接让机器人在现实世界中学习原则上是可行的，但如何让机器人安全地进行强化学习、试错学习仍是挑战。
互联网视频
利用互联网视频进行下一帧、下一个token的预测可以帮助机器人了解世界，但无法让机器人学习实际行为。
数据金字塔
阿比尔展示了一个数据金字塔，底层是网络数据，中间是合成、仿真数据，顶层是现实世界的数据。与大语言模型相比，机器人领域在高信号数据方面还没有达成共识，如何最佳地组合数据源也没有达成一致。
自主行走与运动控制
阿比尔在伯克利的团队在自主行走方面取得了一些成果。他们通过神经网络控制下的仿真机器人动作，收集了大量关于行走的数据集，包括机器人的关节角度、指令、质心和姿态。通过训练Transformer模型和强化学习，他们的机器人已完成超过4英里的现实徒步。
另一个研究方向是如何让机器人跑得更快。伯克利团队通过强化学习来训练控制器，使机器人能以自然的方式运动，并学会了跳跃等复杂动作。同样的技术也被用于训练四足机器人，使其成为足球守门员。
模块化架构
阿比尔团队目前对模块化的架构更感兴趣，称为Body Transformer。在这种架构中，Transformer的连接不是全连接的，而是局部连接的，可以更有效地利用机器人的骨架作为归纳偏置，让模型更加高效。这种方法不仅提高了模仿学习的效率和可扩展性，而且在数据较少的情况下也能很好地工作。
MuJoCo Playground
阿比尔还介绍了与Google DeepMind合作开发的MuJoCo Playground，这是一个模拟各种任务的开源仿真平台，支持批量GPU渲染，只需一行代码即可安装。它先定义任务和多个奖励，然后开始训练模拟，通常使用PPO算法并根据需要调整奖励。
东南亚如何学习并受益于机器人训练数据技术:
东南亚地区作为一个快速发展的经济体，可以通过多种方式学习并受益于机器人训练数据技术的进步。以下是几个关键领域和具体建议：
制造业转型
东南亚是全球制造业中心之一，可以通过以下方式受益：
- 劳动密集型产业自动化：利用远程操作数据采集方法，为工厂中常见的重复性任务训练机器人，如电子产品组装、纺织品制造等。
- 柔性制造系统：通过模仿学习技术，训练机器人快速适应产品变化，提高小批量生产效率，在全球供应链中占据更高价值位置。
- 质量控制优化：利用视觉基础模型和仿真环境，训练机器人执行精确的质量检测任务，提高出口产品质量。
本地化解决方案
东南亚可以发展适合当地环境和需求的机器人解决方案：
- 农业机器人：针对水稻种植、橡胶采集等当地特色农业，采集特定训练数据并开发专用机器人。
- 灾害响应机器人：考虑到该地区面临的台风、洪水等自然灾害，通过仿真环境训练机器人应对极端情况。
- 热带环境适应：收集热带气候环境下的数据，训练机器人应对高温、高湿度条件，解决因环境因素造成的机器人可靠性问题。
人才与基础设施发展
为支持机器人数据采集和训练，东南亚可以：
- 建立区域数据中心：创建专门的机器人训练数据中心，集中存储和处理来自不同行业的数据。
- 大学-产业合作：如新加坡国立大学、泰国朱拉隆功大学等高校可以与本地制造商合作，建立类似伯克利机器人学习实验室的研究中心。
- 技能转型项目：培训工人从纯手工操作转向远程操作机器人和数据标注工作，创造新的就业机会。
成本效益策略
考虑到资源限制，东南亚可以采取以下成本效益策略：
- 模块化硬件采用：使用如阿比尔团队推广的低成本模块化机器人设计，减少硬件投资门槛。
- 开源仿真优先：优先使用MuJoCo Playground等开源工具进行初步研发，降低前期成本。
- 数据共享联盟：区域内国家间建立数据共享联盟，共同构建更大规模的训练数据集。
特色应用领域
东南亚可以在以下特色领域建立竞争优势：
- 旅游服务机器人：利用大量游客互动数据，训练具有多语言能力的服务机器人，提升旅游体验。
- 海洋资源管理：作为海洋国家集中的地区，可以专注于水下机器人的训练数据收集，用于珊瑚礁监测、可持续渔业等。
- 传统工艺数字化：通过手部动作跟踪技术，记录并保存传统工艺技能，如泰国的丝绸编织、越南的漆器制作等。
实施路径
东南亚地区可以遵循以下路径实施机器人数据技术：
- 先仿真后实体：首先通过仿真环境构建数据基础，降低初始投资风险。
- 远程操作网络：建立区域性远程操作网络，让操作员可以控制不同地点的机器人，最大化数据收集效率。
- 渐进式部署：从简单任务开始，如物流分拣、基础组装，逐步扩展到更复杂的应用场景。
通过这些方法，东南亚可以在保持劳动力优势的同时，逐步引入和适应机器人技术，提高生产力并在全球价值链中占据更有利位置。这种转型不仅可以提高产业竞争力，还能培养新一代技术人才，为数字经济发展奠定基础。
结论
机器人训练数据的获取是实现高级机器人能力的关键挑战。彼得·阿比尔指出，通过数据金字塔结构（互联网数据、仿真数据和现实世界数据）的组合，可以为机器人提供丰富的学习资源。
模块化架构如Body Transformer减少了训练数据需求，使机器人能够从少量示例中学习。随着硬件成本的下降和数据收集方法的进步，机器人领域有望在未来几年取得突破性进展。
上述示例代码展示了机器人数据获取和训练的不同方法，这些方法可以根据具体需求和可用资源进行组合使用。从远程操作数据收集到基于仿真的强化学习，每种方法都有其优势和适用场景。
关键点
彼得·阿比尔的演讲深入探讨了机器人训练数据的获取方法和挑战。主要关键点包括：
- 机器人领域的主要挑战是缺乏大量高质量的训练数据
- 数据采集方法包括远程操作、手部动作跟踪、仿真环境、现实世界学习和互联网视频
- 数据金字塔从底层的网络数据到顶层的现实世界数据构成了完整的数据生态
- 模块化架构(Body Transformer)使机器人学习更高效，即使在数据较少的情况下也能表现良好
- MuJoCo Playground为研究人员提供了一个便捷的开源仿真平台
- 机器人硬件价格正在快速下降，未来可能不再是构建机器人的障碍
