具身智能从零到精通：完整学习路线与实战指南

目录

• 一、什么是具身智能
• 二、具身智能技术全景
• 三、必备基础知识
• 四、核心技术栈详解
• 五、开源项目与平台
• 六、硬件平台选择
• 七、仿真环境
• 八、学习路线图
• 九、实战项目
• 十、前沿论文与趋势

一、什么是具身智能

1.1 最直观的理解

具身智能 = 有"身体"的AI。

传统AI（如ChatGPT）只能在虚拟世界中处理文字和图片，而具身智能是让AI拥有物理身体（机器人），能够在真实世界中感知、决策、行动。

传统AI: 文字/图片 → [大脑] → 文字/图片
具身智能: 真实世界 → [感知] → [大脑] → [动作] → 真实世界
↑ │
└──────────── 反馈循环 ←────────────────────────┘

通俗类比：

• ChatGPT = 被关在房间里的天才（只能通过纸条交流）
• 具身智能 = 能走出房间干活的机器人（有眼睛、手、脚）

1.2 为什么具身智能是下一个风口

1.3 具身智能 vs 机器人 vs 自动驾驶

┌─────────────────────────────────────────────────────┐
│ 具身智能（最广） │
│ ┌─────────────────────────────────────────────┐ │
│ │ 机器人（子集） │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ 工业机器人│ │ 服务机器人│ │ 人形机器人│ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────┘ │
│ ┌──────────────┐ │
│ │ 自动驾驶 │ │
│ └──────────────┘ │
│ ┌──────────────┐ │
│ │ 无人机 │ │
│ └──────────────┘ │
└─────────────────────────────────────────────────────┘

1.4 具身智能的典型应用

二、具身智能技术全景

2.1 核心技术栈

┌─────────────────────────────────────────────────────────────┐
│ 具身智能技术栈 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 感知层 (Perception) │
│ ├── 视觉: RGB相机、深度相机、立体视觉 │
│ ├── 点云: LiDAR、RGB-D │
│ ├── 触觉: 力/力矩传感器、触觉皮肤 │
│ ├── 本体感知: 关节编码器、IMU │
│ └── 技术: 目标检测、语义分割、6D位姿估计、3D重建 │
│ │
│ 决策层 (Decision) │
│ ├── 任务规划: LLM任务分解、行为树、状态机 │
│ ├── 运动规划: 路径规划(RRT)、轨迹优化 │
│ ├── 操作规划: 抓取规划、装配规划 │
│ └── 技术: VLA模型、世界模型、强化学习策略 │
│ │
│ 控制层 (Control) │
│ ├── 底层控制: PID、阻抗控制、力控制 │
│ ├── 运动控制: 全身运动控制(WBC)、步态规划 │
│ └── 技术: MPC、RL策略执行、关节伺服 │
│ │
│ 仿真层 (Simulation) │
│ ├── 物理引擎: MuJoCo、Isaac Sim、Gazebo │
│ ├── 场景生成: 程序化生成、数字孪生 │
│ └── 域随机化: 材质、光照、物理参数随机化 │
│ │
│ 数据层 (Data) │
│ ├── 遥操作: VR手套、主从控制 │
│ ├── 数据集: Open X-Embodiment、DROID │
│ └── 数据增强: 仿真数据、合成数据 │
│ │
└─────────────────────────────────────────────────────────────┘

2.2 具身智能的关键研究方向

三、必备基础知识

3.1 数学基础

3.2 编程基础

3.3 AI/ML 基础

3.4 机器人学基础

四、核心技术栈详解

4.1 VLA（Vision-Language-Action）模型

VLA 是具身智能最核心的技术方向，它将视觉、语言和动作统一到一个模型中。

输入: "把红色的杯子放到桌上"
+ 相机图像
↓
┌──────────────────┐
│ VLA 模型 │
│ (类似 GPT 的 │
│ 多模态模型) │
└──────┬───────────┘
↓
输出: 机器人动作序列 [关节角度, 夹爪状态, …]

代表模型

使用 OpenVLA

# 安装
pip install openvla

from transformers import AutoModelForVision2Seq, AutoProcessor
from PIL import Image
import torch

# 加载模型
model = AutoModelForVision2Seq.from_pretrained("openvla/openvla-7b", torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained("openvla/openvla-7b", trust_remote_code=True)

# 输入：图像 + 语言指令
image = Image.open("robot_view.jpg")
prompt = "In: What action should the robot take to pick up the cup?\\nOut:"

# 推理
inputs = processor(prompt, image).to(model.device, dtype=torch.bfloat16)
action = model.predict_action(**inputs, unnorm_key="bridge_orig")
# action: 7维向量 [x, y, z, roll, pitch, yaw, gripper]

4.2 模仿学习（Imitation Learning）

从人类演示中学习机器人行为，是目前最实用的具身智能方法。

4.2.1 行为克隆（Behavior Cloning, BC）

最简单的模仿学习：直接学习 state → action 的映射。

import torch
import torch.nn as nn

class BehaviorCloningPolicy(nn.Module):
"""简单的BC策略网络"""
def __init__(self, obs_dim, act_dim, hidden=256):
super().__init__()
self.net = nn.Sequential(
nn.Linear(obs_dim, hidden), nn.ReLU(),
nn.Linear(hidden, hidden), nn.ReLU(),
nn.Linear(hidden, act_dim)
)

def forward(self, obs):
return self.net(obs)

# 训练循环
policy = BehaviorCloningPolicy(obs_dim=7, act_dim=7)
optimizer = torch.optim.Adam(policy.parameters(), lr=1e-3)

for epoch in range(100):
for obs, action in dataloader: # 人类演示数据
pred_action = policy(obs)
loss = nn.MSELoss()(pred_action, action)
loss.backward()
optimizer.step()
optimizer.zero_grad()

4.2.2 ACT（Action Chunking with Transformers）

ACT 是目前最流行的模仿学习方法之一，核心思想：一次预测一段动作序列。

# ACT 核心思想
# 输入: 当前图像观测
# 输出: 未来 T 步的动作序列 [a_t, a_{t+1}, …, a_{t+T}]

# 关键技术:
# 1. 动作分块（Action Chunking）: 一次预测多步
# 2. CVAE（条件变分自编码器）: 处理多模态动作分布
# 3. Transformer 编码器-解码器架构

4.2.3 Diffusion Policy

使用扩散模型生成动作，处理多模态分布效果极好。

# Diffusion Policy 核心思想
# 1. 将动作视为"噪声"
# 2. 通过去噪过程生成动作
# 3. 条件于当前观测

# 公式化:
# a_t = a_t – ε_θ(a_t, t, o_t) （去噪步骤）
# 其中 ε_θ 是去噪网络，o_t 是当前观测

4.2.4 模仿学习方法对比

4.3 强化学习（Reinforcement Learning）

4.3.1 RL 在具身智能中的应用

环境 (仿真)
│
├── 观测 (obs): 关节角度、相机图像
├── 奖励 (reward): 任务完成度
└── 动作 (action): 关节力矩
│
▼
策略网络 π(a|s)
│
├── PPO (Proximal Policy Optimization) ← 最常用
├── SAC (Soft Actor-Critic)
└── TD3 (Twin Delayed DDPG)

4.3.2 Isaac Lab 训练示例

# NVIDIA Isaac Lab (原 Isaac Gym 的升级版)
# 可以同时在数千个GPU环境中并行训练RL策略

from omni.isaac.lab.envs import ManagerBasedRLEnvCfg
from omni.isaac.lab_tasks.manager_based.locomotion.velocity import VelocityEnvCfg

# 配置环境
env_cfg = VelocityEnvCfg()
env_cfg.scene.num_envs = 4096 # 4096个并行环境
env_cfg.sim.device = "cuda:0"

# 创建环境
env = ManagerBasedRLEnv(cfg=env_cfg)

# 使用 RSL-RL 训练
from rsl_rl.runners import OnPolicyRunner

runner = OnPolicyRunner(env, policy_cfg, device="cuda:0")
runner.learn(num_learning_iterations=5000)

4.3.3 Sim-to-Real（仿真到现实迁移）

最大的挑战：在仿真中训练的策略如何在真实机器人上工作。

仿真环境 真实环境
┌────────────┐ ┌────────────┐
│ Isaac Sim │ Sim-to-Real 迁移 │ 真实机器人 │
│ │ ┌─────────────┐ │ │
│ 理想物理 │ │ 域随机化 │ │ 真实物理 │
│ 完美传感 │ │ 领域适应 │ │ 噪声传感 │
│ 无限数据 │ │ 系统辨识 │ │ 有限数据 │
│ │ └─────────────┘ │ │
└────────────┘ ←── 域差距 ──→ └────────────┘

关键方法：

• 域随机化（Domain Randomization）：随机化仿真参数（摩擦力、质量、光照等）
• 领域适应（Domain Adaptation）：在少量真实数据上微调
• 系统辨识（System Identification）：精确标定仿真参数

4.4 3D视觉感知

4.4.1 6D位姿估计

估计物体在3D空间中的位置和姿态（3个平移 + 3个旋转）。

4.4.2 3D场景理解

# 使用 Grounded-SAM 进行3D场景理解
# 1. 使用 SAM 分割物体
# 2. 使用 DINOv2 提取3D特征
# 3. 使用点云处理获取3D信息

# 代码示例：RGB-D 点云处理
import open3d as o3d
import numpy as np

# 从RGB-D图像创建点云
depth_image = o3d.io.read_image("depth.png")
color_image = o3d.io.read_image("color.png")
rgbd = o3d.geometry.RGBDImage.create_from_color_and_depth(color_image, depth_image)
point_cloud = o3d.geometry.PointCloud.create_from_rgbd_image(rgbd, intrinsic)

# 点云处理
point_cloud.estimate_normals()
point_cloud.oxel_down_sample(voxel_size=0.01)

# 3D目标分割
labels = np.array(point_cloud.cluster_dbscan(eps=0.02, min_points=100))

4.5 机器人运动规划

4.5.1 运动规划算法

4.5.2 抓取规划

# 使用 grasp_detection 进行抓取规划
# 输入: 点云或RGB-D图像
# 输出: 抓取位姿 (位置 + 姿态 + 夹爪宽度)

# 代表性方法:
# – GraspNet: 通用抓取检测
# – Contact-GraspNet: 接触感知抓取
# – AnyGrasp: 任意物体抓取

五、开源项目与平台

5.1 核心开源项目

5.1.1 模型与算法

5.1.2 仿真与训练

5.1.3 数据与工具

5.1.4 硬件相关

5.2 LeRobot — HuggingFace 机器人学习库

LeRobot 是入门具身智能最好的开源项目，由 HuggingFace 维护。

# 安装
git clone https://github.com/huggingface/lerobot.git
cd lerobot
pip install -e .

# 使用预训练策略推理
from lerobot.common.policies.diffusion.modeling_diffusion import DiffusionPolicy

policy = DiffusionPolicy.from_pretrained("lerobot/diffusion_pusht")
obs = env.reset()
action = policy.select_action(obs)

LeRobot 支持的策略：

• ACT (Action Chunking Transformer)
• Diffusion Policy
• TDMPC (Temporal Difference Model Predictive Control)
• VQ-BeT (Vector-Quantized Behavior Transformer)

LeRobot 支持的环境：

• PushT（2D推动任务）
• ALOHA（双臂操作）
• SimXArm（机械臂）
• 物理硬件（SO-100机械臂）

六、硬件平台选择

6.1 学习阶段推荐硬件

6.2 SO-100 机械臂（最推荐入门）

SO-100 是 LeRobot 官方推荐的入门级机械臂：

# 使用 LeRobot 控制 SO-100
from lerobot.common.robot_devices.robots.factory import make_robot

robot = make_robot(
"so100",
port="/dev/ttyUSB0",
calibration_dir="path/to/calibration"
)
robot.connect()

# 读取关节角度
positions = robot.read_position()
print(f"当前关节角度: {positions}")

# 发送关节角度
robot.send_position(target_angles)

6.3 传感器选择

七、仿真环境

7.1 仿真器对比

7.2 MuJoCo 快速入门

pip install mujoco

# 基本使用
import mujoco
import mujoco.viewer

# 加载模型
model = mujoco.MjModel.from_xml_path("robot_arm.xml")
data = mujoco.MjData(model)

# 仿真循环
for i in range(1000):
mujoco.mj_step(model, data)
print(f"时间: {data.time:.3f}, 关节角度: {data.qpos[:6]}")

<!– robot_arm.xml – 简单机械臂模型 –>
<mujoco model="robot_arm">
<compiler angle="radian"/>
<option timestep="0.001"/>

<worldbody>
<body name="base" pos="0 0 0">
<geom type="cylinder" size="0.05 0.02" rgba="0.5 0.5 0.5 1"/>
<body name="link1" pos="0 0 0.02">
<joint name="joint1" type="hinge" axis="0 0 1" range="-3.14 3.14"/>
<geom type="capsule" fromto="0 0 0 0.3 0 0" size="0.03"/>
<body name="link2" pos="0.3 0 0">
<joint name="joint2" type="hinge" axis="0 1 0" range="-1.57 1.57"/>
<geom type="capsule" fromto="0 0 0 0 0 0.3" size="0.025"/>
<body name="end_effector" pos="0 0 0.3">
<geom type="sphere" size="0.02" rgba="1 0 0 1"/>
</body>
</body>
</body>
</body>
</worldbody>

<actuator>
<motor name="motor1" joint="joint1" ctrlrange="-10 10"/>
<motor name="motor2" joint="joint2" ctrlrange="-10 10"/>
</actuator>
</mujoco>

7.3 Isaac Lab 快速入门

# 安装（需要NVIDIA GPU）
pip install isaacsim
pip install isaaclab

# 运行示例
from omni.isaac.lab.app import AppLauncher
app_launcher = AppLauncher({"headless": False})
simulation_app = app_launcher.app

from omni.isaac.lab.envs import ManagerBasedRLEnv
from omni.isaac.lab_tasks.manager_based.manipulation.reach import ReachEnvCfg

env_cfg = ReachEnvCfg()
env_cfg.scene.num_envs = 64

env = ManagerBasedRLEnv(cfg=env_cfg)
obs, info = env.reset()

for i in range(1000):
action = torch.randn(env.action_space.shape)
obs, reward, terminated, truncated, info = env.step(action)

八、学习路线图

8.1 完整学习路线

阶段0: 基础准备（1-2个月）
├── Python 基础（NumPy、PyTorch）
├── 线性代数复习（矩阵、旋转、变换）
├── Linux 基础命令
├── Git 基本使用
└── 深度学习入门（CNN、Transformer）

阶段1: 机器人学基础（1-2个月）
├── ROS2 入门（节点、话题、TF）
├── 机器人运动学（正/逆运动学）
├── MuJoCo 仿真入门
├── 机械臂控制基础
└── 项目：用 MuJoCo 控制机械臂抓取物体

阶段2: 计算机视觉基础（1-2个月）
├── 目标检测（YOLO）
├── 图像分割（SAM）
├── 深度估计
├── 6D位姿估计
└── 项目：视觉引导的机械臂抓取

阶段3: 机器人学习基础（2-3个月）
├── 强化学习入门（PPO、SAC）
├── 模仿学习入门（BC、ACT）
├── 使用 LeRobot 训练策略
├── Diffusion Policy 理解与实践
└── 项目：用 ACT/Diffusion Policy 完成操作任务

阶段4: VLA 与大模型（2-3个月）
├── 理解 VLA 架构（RT-2、OpenVLA）
├── 使用 OpenVLA 推理
├── 多模态模型基础
├── LLM 任务规划
└── 项目：用 VLA 模型完成语言引导的操作

阶段5: Sim-to-Real（2-3个月）
├── Isaac Lab 大规模训练
├── 域随机化技术
├── 真实机器人部署
├── 数据采集与训练闭环
└── 项目：从仿真到真实机器人的完整流程

阶段6: 前沿研究（持续）
├── 阅读最新论文
├── 复现经典工作
├── 参与开源项目
└── 竞赛与挑战赛

8.2 推荐学习资源

课程

书籍

开源课程与教程

九、实战项目

9.1 项目1：MuJoCo 机械臂抓取（入门）

"""
项目1: MuJoCo 机械臂抓取
目标: 控制机械臂抓取桌面上的方块
技能: MuJoCo使用、正运动学、简单控制
时间: 1-2周
"""

import mujoco
import mujoco.viewer
import numpy as np

# 加载模型
model = mujoco.MjModel.from_xml_path("robot_arm_grasp.xml")
data = mujoco.MjData(model)

# PID 控制器
class PIDController:
def __init__(self, kp, ki, kd):
self.kp, self.ki, self.kd = kp, ki, kd
self.prev_error = 0
self.integral = 0

def compute(self, target, current, dt):
error = target – current
self.integral += error * dt
derivative = (error – self.prev_error) / dt
self.prev_error = error
return self.kp * error + self.ki * self.integral + self.kd * derivative

# 控制策略
def move_to_target(model, data, target_pos):
"""将末端执行器移动到目标位置"""
# 逆运动学求解（简化版）
joint_targets = inverse_kinematics(target_pos)

# PID 控制
for i, (target, current) in enumerate(zip(joint_targets, data.qpos[:6])):
data.ctrl[i] = pid_controllers[i].compute(target, current, model.opt.timestep)

# 主循环
with mujoco.viewer.launch_passive(model, data) as viewer:
while viewer.is_running():
# 阶段1: 移动到物体上方
move_to_target(model, data, [0.3, 0.0, 0.2])

# 阶段2: 下降到抓取位置
move_to_target(model, data, [0.3, 0.0, 0.05])

# 阶段3: 闭合夹爪
data.ctrl[6] = 1.0 # 夹爪关闭

# 阶段4: 提升
move_to_target(model, data, [0.3, 0.0, 0.3])

mujoco.mj_step(model, data)
viewer.sync()

9.2 项目2：LeRobot ACT 策略训练（进阶）

"""
项目2: 使用 LeRobot 训练 ACT 策略
目标: 从演示数据中学习机械臂操作
技能: 模仿学习、ACT、数据采集
时间: 2-3周
"""

# 步骤1: 采集演示数据
from lerobot.common.robot_devices.robots.factory import make_robot
from lerobot.common.robot_devices.cameras.opencv import OpenCVCamera

robot = make_robot("so100", port="/dev/ttyUSB0")
camera = OpenCVCamera(camera_index=0, fps=30, width=640, height=480)

# 遥操作采集
from lerobot.scripts.control_robot import record_episode

dataset = record_episode(
robot=robot,
cameras=[camera],
fps=30,
episode_time_s=30,
num_episodes=50,
task="pick up the red block"
)

# 步骤2: 训练 ACT 策略
from lerobot.scripts.train import train

train(
policy="act",
dataset_repo_id="my_dataset",
env="real",
batch_size=8,
steps=50000,
output_dir="outputs/train_act"
)

# 步骤3: 评估和部署
from lerobot.scripts.control_robot import replay_episode

replay_episode(
robot=robot,
policy="act",
policy_path="outputs/train_act/checkpoints/last/pretrained_model",
cameras=[camera],
fps=30,
)

9.3 项目3：VLA 模型部署（高级）

"""
项目3: 部署 VLA 模型到真实机器人
目标: 使用自然语言指令控制机器人
技能: VLA模型、多模态感知、机器人控制
时间: 3-4周
"""

from transformers import AutoModelForVision2Seq, AutoProcessor
from lerobot.common.robot_devices.robots.factory import make_robot
from lerobot.common.robot_devices.cameras.opencv import OpenCVCamera
import torch

# 加载 VLA 模型
model = AutoModelForVision2Seq.from_pretrained("openvla/openvla-7b", torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained("openvla/openvla-7b")
model = model.cuda()

# 连接机器人和相机
robot = make_robot("so100", port="/dev/ttyUSB0")
camera = OpenCVCamera(camera_index=0, fps=30, width=640, height=480)

# 用户指令
instruction = "pick up the red cup and place it on the plate"

# 控制循环
for step in range(500):
# 获取图像
image = camera.read()

# VLA 推理
prompt = f"In: What action should the robot take to {instruction}?\\nOut:"
inputs = processor(prompt, image).to("cuda", dtype=torch.bfloat16)
action = model.predict_action(**inputs, unnorm_key="bridge_orig")

# 执行动作
robot.send_position(action[:6])
robot.send_gripper(action[6])

# 检查任务完成
if task_completed(image, instruction):
print("任务完成！")
break

9.4 项目4：RL 训练人形机器人行走（高级）

"""
项目4: 使用 Isaac Lab 训练人形机器人行走
技能: RL、Isaac Lab、人形机器人控制
时间: 3-4周
"""

# 使用 Isaac Lab 的人形行走任务
from omni.isaac.lab_tasks.manager_based.locomotion.velocity.velocity_env_cfg import LocomotionVelocityEnvCfg
from omni.isaac.lab.envs import ManagerBasedRLEnv

# 配置环境
env_cfg = LocomotionVelocityEnvCfg()
env_cfg.scene.robot = "unitree_g1" # Unitree G1 人形机器人
env_cfg.scene.num_envs = 4096
env_cfg.rewards.undesired_contacts = None

# 创建环境
env = ManagerBasedRLEnv(cfg=env_cfg)

# 使用 RSL-RL 训练
from rsl_rl.runners import OnPolicyRunner
from rsl_rl.algorithms import PPO

policy_cfg = {
"policy_class_name": "ActorCritic",
"init_noise_std": 1.0,
"actor_hidden_dims": [512, 256, 128],
"critic_hidden_dims": [512, 256, 128],
"activation": "elu",
}

runner = OnPolicyRunner(env, policy_cfg, device="cuda:0")
runner.learn(num_learning_iterations=5000)

十、前沿论文与趋势

10.1 必读论文

基础模型

模仿学习

强化学习

世界模型

10.2 2026年具身智能趋势

10.3 推荐关注的研究组

附录：常见问题

Q: 我没有机器人，可以学具身智能吗？ A: 完全可以！80%的学习可以在仿真中完成。MuJoCo、Isaac Sim 都是免费的。

Q: 需要多少GPU算力？ A: 入门阶段单卡 RTX 3090/4090 即可。大规模训练需要 A100/H100。

Q: 从哪个方向开始最好？ A: 建议从 LeRobot + 仿真环境开始，先跑通模仿学习的完整流程。

Q: 具身智能和传统机器人学有什么区别？ A: 传统机器人学依赖精确建模和手写规则；具身智能用数据驱动的方法（学习）替代。

Q: 需要很强的数学吗？ A: 入门不需要。能理解矩阵乘法和梯度下降即可开始。深入研究时再补数学。