VLA 视觉-语言-动作模型

weixin_57580819

121人浏览 · 2026-07-28 08:47:49

weixin_57580819 · 2026-07-28 08:47:49 发布

1. 什么是 VLA？—— 一个"能看、能听、能动手"的模型

VLA = Vision-Language-Action（视觉-语言-动作模型）。

它是一个端到端的多模态模型，输入端接收摄像头图像 + 自然语言指令，输出端直接产生机器人的关节动作序列。

一句话理解：你对机器人说"帮我把桌上的红色杯子拿过来"，VLA 模型通过摄像头看到杯子在哪、理解"拿过来"是什么意思、然后自主规划出一系列关节运动轨迹来完成任务。整个过程不需要人工编程每一步怎么做。

要真正理解 VLA，需要同时理解它的三个字母：

组件	负责什么	输入	输出	类比
V — Vision（视觉）	看懂场景	摄像头 RGB 图像（单帧或多帧）	场景理解（物体位置、形状、空间关系）	机器人的"眼睛"
L — Language（语言）	理解意图	自然语言文本指令	任务解析（要做什么、条件是什么）	机器人的"耳朵"
A — Action（动作）	执行操作	来自 V+L 的融合表示	关节角度/速度/力矩序列、末端位姿	机器人的"手"

1.1 VLA 与其他概念的关系

AI 模型的能力进化链：

LLM (大语言模型) → 只会处理文本，不懂图像也不懂物理世界
   ↓ 加视觉能力
VLM (视觉语言模型) → 能看图说话，但只会"说"不会"做"
   ↓ 加动作输出能力
VLA (视觉语言动作模型) → 能看、能理解、还能动手执行！

VLA 本质上是把 VLM 的"理解世界的能力" 与 机器人策略的"执行动作的能力" 融合在一起，实现了从"感知"到"决策"再到"行动"的端到端统一。

纯视觉方案（如 ACT）

从图像直接预测动作，没有语言理解能力。换一个任务（"抓杯子"→"推方块"）需要重新训练。无泛化到新任务的能力。

纯语言方案（如 SayCan）

LLM 做高层规划（"先去厨房，再拿杯子"），但底层动作依赖预编程的技能库。无法处理未见过的物体和场景。

VLA 融合方案

视觉+语言在大模型内部深度融合，共同指导动作生成。面对新物体（"拿那个蓝色三角形"）时无需重训。泛化是核心优势。

2. 为什么需要 VLA？传统方法的不足

方法	能做什么	不能做什么	遇到新任务时
经典控制（PID、MPC）	精确跟踪预定轨迹	无法处理非结构化环境、不能用自然语言控制	全部重新编程
模仿学习（ACT、Diffusion Policy）	从演示数据学会特定任务	一个模型只会一个任务，换任务需重新采集数据+重训	重新采集 50+ 条演示
LLM + 技能库	理解自然语言，调用预编程技能	技能库覆盖不到的物体/场景就束手无策	需要程序员新增技能
VLA	理解新语言指令、认出没见过的新物体、泛化到新场景	依赖大规模预训练数据，小数据场景可能不如专用策略	零样本或少量微调

核心价值：泛化（Generalization）。

VLA 最吸引人的地方不是它做某一件特定事情做得有多好，而是它做从未见过的事情的能力。

因为 VLA 的视觉和语言能力来自互联网规模的预训练，当你对它说"把那个绿色的不规则物体翻过来"，它可能从来没见过这个物体，但能通过视觉理解找到它、通过语言理解知道要"翻过来"。

2.1 一个具体的例子

场景：让机器人"把苹果放进红色碗里"

传统模仿学习：
  前提：必须有人演示过"抓苹果→放红碗"的完整过程（50 次）
  换个要求"放到蓝色碗里"？→ 不行，需要重新采集蓝碗数据 + 重新训练

VLA：
  前提：模型在互联网上见过"苹果"长什么样、"红色"是什么颜色、"碗"是容器
  换个要求"放到蓝色碗里"？→ 模型知道"蓝色"是什么，找到蓝碗，直接执行！
  换个物体"把香蕉放进红色碗里"？→ 同样可以！

3. VLA 的核心架构

虽然不同 VLA 模型的具体设计有差异，但它们都遵循一个共同的范式：预训练 VLM 作为基座 + 动作解码器 + 端到端微调。

3.1 架构全景图

INPUT
  ├─ 摄像头图像 (RGB, 多帧或单帧)
  └─ 自然语言指令 ("Pick up the red cup")
│
VISION ENCODER (SigLIP / ViT / DINOv2)
  └─ 将图像编码为特征向量 → image_tokens
│
LANGUAGE ENCODER (LLM backbone)
  ├─ Tokenize 文本指令 → text_tokens
  └─ 与 image_tokens 拼接，一起送入 Transformer
│
MULTIMODAL FUSION (Transformer Decoder layers)
  └─ 图像 token 和文本 token 通过 self-attention 深度融合
  └─ 输出：融合了"看"和"听"的 hidden states
│
ACTION HEAD (MLP / Diffusion / Autoregressive)
  ├─ 从融合表示中解码出动作
  ├─ 输出格式取决于设计：绝对关节角度 / 相对位移 / 末端位姿 / action tokens
  └─ 可能是单步动作 or 动作块 (action chunking)
│
OUTPUT → 机器人执行动作序列

3.2 三种动作输出范式

不同 VLA 模型最大的设计分歧在于"如何输出动作"：

范式	如何工作	优点	缺点	代表模型
离散化 Action Token	把连续动作（关节角度 -30° ~ +30°）分成 N 个离散区间，每个区间映射为一个 token。像语言模型一样逐 token 生成	与 LLM 训练方式完全一致，可复用 LLM 的全部基础设施	离散化引入量化误差，精细操作可能不够精确	RT-2 (Google)
连续回归	Action head 直接输出连续值（关节角度），用 L1/L2/MSE loss 训练	精度最高，无量化误差	与 LLM 的 token 预测范式不一致，需要额外设计 loss	SmolVLA、部分 Pi0 配置
扩散生成	从高斯噪声开始，逐步去噪生成动作轨迹。每个去噪步骤都依赖 VLM 的融合表示作为条件	擅长多模态分布（"既可以这样抓，也可以那样抓"），轨迹平滑	推理慢（需要多次去噪步骤）	Pi0 (diffusion variant)

关键趋势：业界正在向混合方案收敛——用 VLM backbone 做感知与理解（粗粒度），用 diffusion/flow-matching head 做精确动作生成（细粒度）。Pi0 就是这种混合架构的代表。

3.2.1 深入理解：为什么 Action Head 要用 Diffusion？

这是理解现代 VLA 架构设计的关键问题。答案在于动作预测本质上是一个"一对多"的问题——同一个任务往往有多个正确答案，而传统的回归无法处理这种情况。

🎯 核心矛盾：抓一个苹果可以有 N 种方式

你对机器人说"把桌上的苹果拿起来"。这个任务至少有三种完全合理的抓取方式：

方式 A: 正上方垂直抓取 — 机械手从天而降，直直下去
方式 B: 右侧横移抓取 — 从右边滑过去，从侧面夹住
方式 C: 绕后抓取 — 避开前面的杯子，绕到苹果背后再抓

三种方式都是正确的，但它们的关节角度序列完全不同。
如果你用 L1/L2 回归训练，模型会学到什么？

回归的致命缺陷：L1/L2 Loss 的本质是预测"平均值"。看这个例子：

为什么回归在 VLA 中会失败
# ═══════════════════════════════════════════════════════════════
# 训练数据中有 3 条演示，都是"拿起苹果"这个任务：
# ═══════════════════════════════════════════════════════════════
data_A = [30, -10,  5,  45,  20, -15]   # 演示 A: 从上方抓 — 6 个关节角度
data_B = [-15,  45,  0,  60, -10,  30]   # 演示 B: 从侧面抓 — 关节角度完全不同
data_C = [60,  20, -20,  10,  50,  5]   # 演示 C: 绕后抓 — 又是不同的轨迹

# MSE Loss = (预测 - 真实值)² 的最小化会把模型拉向均值
mean_action = [(30-15+60)/3, (-10+45+20)/3, ...]
#              = [25, 18, -5, 38, 20, 7]
# 这个"平均动作"现实中不存在！执行它可能导致：
#   - 机械臂停在半空（不上不下，离苹果还差 5cm）
#   - 撞到桌子（平均值穿过了桌面）
#   - 夹爪在错误时机闭合（三个演示的夹取时机被平均了）

回归的数学本质：

L1/L2 回归假设输出服从单峰分布（只有一个正确答案，数据围绕这个正确答案正态分布）。

但机器人动作天然是多峰分布（多个正确的"峰"），预测"平均值"等于预测一个现实中不可行的中间态——不上不下、不左不右、刚好撞到障碍物。

Diffusion 如何解决？—— 从"预测"变成"采样"

Diffusion 的核心思想转换：不直接预测输出值，而是学习输出的"分布"，然后从分布中采样。

	回归模型	扩散模型 (Diffusion)
训练目标	学习 f(x) → 一个确定的值	学习 p(action \| image, text) → 一个概率分布
推理过程	输入 → [网络] → 输出	随机噪声 → [K 步去噪] → 采样一个可行解
多次推理	每次结果完全相同（确定性）	每次采样结果不同，但都合理（随机性）
面对 3 种抓取方式	学出"平均值" = 不可行的中间态	学出"分布" = 可以从 3 个峰中各采样出一个

一个具体的采样演示：

Diffusion Action Head 的推理过程
# ═══════════════════════════════════════════════════════════════
# VLA 的 Diffusion Action Head 每一步都在做什么
# ═══════════════════════════════════════════════════════════════

# Step 1: 初始化 — 纯随机噪声作为"动作雏形"
action_noise = [0.03, -0.12, 0.08, -0.05, 0.01, -0.09]  # 无意义的随机数

# Step 2: 条件注入 — VLM 的输出作为"导航地图"
condition = VLM_output  # 融合了"苹果在(x,y,z)"和"拿起来"的语义

# Step 3: 迭代去噪 (K 步)，每一步都参考 condition
for t in [K, K-1, ..., 2, 1]:
    # 网络预测：给定当前噪声动作 + 场景条件，"应该减去多少噪声"
    predicted_noise = denoise_net(action_noise, condition, t)

    # 从当前动作中减去预测的噪声 → 向"干净动作"靠近一步
    action_noise = action_noise - predicted_noise

    # 直观感受每一步的变化：
    # t=50:  噪声很大，动作还很模糊  → 只知道"大概往苹果方向走"
    # t=30:  方向明确了              → "从上方还是侧面？初步确定"
    # t=10:  轨迹成形了              → "最后一小段是向上提"
    # t=5:   精细微调                → "夹爪打开 0.5mm 以确保夹住"
    # t=1:   输出干净的动作序列 ✓    → [28.3, -9.1, 4.2, 44.8, 19.5, -14.7]

# ═══════════════════════════════════════════════════════════════
# 关键：如果换一个随机种子（不同的初始噪声），结果不同！
# ═══════════════════════════════════════════════════════════════
# 初始噪声 [种子=42] → 去噪 → 从上方抓取 [30, -10, 5, ...]
# 初始噪声 [种子=99] → 去噪 → 从侧面抓取 [-15, 45, 0, ...]
# 初始噪声 [种子=7]  → 去噪 → 绕后抓取 [60, 20, -20, ...]
#
# 三种都是合理的动作！模型学会了"分布"而非"平均值"

为什么 VLM Condition 是 Diffusion 的完美搭档？

Diffusion 本身只会"去噪"——它知道怎么让随机噪声变得有意义。但什么样的动作算"有意义"，完全由 VLM 提供的 condition 决定：

Condition 包含的信息	对去噪过程的引导作用
图像特征 → "苹果在桌面坐标 (0.3, -0.1, 0.05)"	告诉去噪网络："末端轨迹的终点要落到这个位置"
语言语义 → "拿起来"（pick up，含向上运动）	告诉去噪网络："轨迹末尾要有一个向上提升的 phase"
空间关系 → "苹果在桌上，旁边有水杯"	告诉去噪网络："轨迹要绕开水杯，不能直线穿过"
物体属性 → "苹果大小约 5cm，表面光滑"	告诉去噪网络："夹爪开合角度约 5~6cm，力度适中"

直觉理解

把 Diffusion 想象成一个拿着画笔的画家，把 VLM Condition 想象成一张照片。
画家一开始面对一张白纸（随机噪声），但手里有参照照片（condition）。
他看一眼照片，画一笔轮廓……再看一眼，细化细节……再看一眼，润色收尾。
每次画出来的画可能略有不同（不同的笔触风格），但画的内容始终是照片里的场景。

如果没有 condition（照片），画家就不知道要画什么——Diffusion 没有 VLM 的条件信号，就不知道"什么动作是合理的"。

⚡ Pi0 为什么用 Flow Matching 而不是纯 Diffusion？

Pi0（Physical Intelligence）用了 Flow Matching——Diffusion 的高效变体，核心区别在于"去噪路径"的设计：

标准 Diffusion 的去噪路径：
  噪声 ──> 弯曲路径 ──> 弯曲路径 ──> ... ──> 干净动作
  每一步往随机方向走一点，需要 50~100 步才能到达目标

Flow Matching 的去噪路径：
  噪声 ─────────────────> 直线路径 ────────────────> 干净动作
  路径被显式建模为一条直线，只需 5~10 步即可到达目标

为什么直线路径更快？

Diffusion 的原始设计中，去噪路径是随机的——每一步往哪个方向走多少，网络自己学习。

Flow Matching 直接把路径约束为直线插值（x_t = t·x_noise + (1-t)·x_clean），网络只需要学习这条直线上的"方向梯度"。路径更短、更可预测，所以步数从 50+ 降到个位数，Pi0Fast 因此得名。

三种范式对决 — 完整对比

维度	回归 (MSE)	离散化 Token	Diffusion / Flow Matching
如何生成	MLP → 一个确定值	逐 token 预测离散 bin	噪声 → K 步迭代去噪
多模态分布	❌ 学的是平均值	⚠️ 可能但量化粗糙	✅ 天然支持（采样）
输出精度	✅ 连续值最高精度	❌ 量化误差	✅ 连续值高精度
轨迹平滑度	⚠️ 可能不连续	❌ 离散阶梯状	✅ 去噪天然平滑
推理速度	✅ 极快（单次前向）	✅ 快（并行解码）	⚠️ 需迭代 K 步
训练兼容性	独立 loss 设计	✅ 与 LLM 统一	⚠️ 需额外去噪网络
代表模型	SmolVLA	RT-2, OpenVLA	Pi0 (Flow Matching), Octo

一句话总结：

Action Head 用 Diffusion 不是因为"Diffusion 很酷"，而是因为机器人动作天然是多模态的（同一个任务有多个正确答案）

回归学不了"分布"，离散化丢精度且轨迹不连续，只有 Diffusion/Flow Matching 能同时做到采样不同合理动作 + 连续高精度输出 + 轨迹平滑。

VLM 的融合表示作为 condition，就像给扩散过程装上了 GPS——确保采样出的动作始终符合当前场景和指令。

3.3 动作空间：VLA 输出什么？

动作类型	含义	维度	适用场景
关节角度	每个关节的目标角度（绝对位置控制）	6D（6 自由度臂）	SO-101 等低成本机械臂
末端位姿	机械手末端在空间中的位置(xyz) + 姿态(rpy)	6D~7D	需要 IK 解算的工业臂
关节速度/力矩	每个关节的目标速度或力矩	6D+	力控任务（柔顺装配）
夹爪开合	夹爪的开关状态（连续或离散）	1D	几乎所有抓取任务
Action Chunk	未来 N 步的动作序列，一次性预测	N × 动作维度	减少累积误差（ACT 风格）

为什么 Action Chunking 很重要？

如果模型每步只看一张图像、输出一个动作（开环控制），随着执行步骤增多，微小误差不断累积，最终机械臂会偏离目标。

ACT（Action Chunking Transformer）的解法是一次性预测未来 N 步的动作序列，然后用时间集成（temporal ensemble）融合多步预测，大幅减少累积误差。现代 VLA（如 Pi0）通常继承了这一设计。

4. 主流 VLA 模型盘点

模型	开发方	基座	动作范式	亮点	硬件需求
RT-2	Google DeepMind	PaLI-X / PaLM-E	离散化 Action Token	第一个证明"互联网 VLM + 机器人数据"可行的大规模实验。在未见过的物体/场景/指令上展现出显著泛化能力	云端推理
Octo	UC Berkeley / Stanford	T5 + ViT	Diffusion Head	开源、模块化设计。支持多机器人平台，社区生态活跃	24GB GPU
OpenVLA	Stanford / Berkeley	Llama + SigLIP/DINOv2	离散化 Action Token	完全开源（模型+数据+代码）。7B 参数，可在消费级 GPU 微调和推理	24GB GPU
Pi0 / Pi0.5 / Pi0Fast	Physical Intelligence (π)	自研 VLM	Flow Matching + 连续回归	专用机器人基础模型，在多种机械臂和人形机器人上训练。泛化能力目前最强之一。LeRobot 原生支持	24GB+ GPU
GR00T N1.5	NVIDIA	自研 + Cosmos	多模态融合	NVIDIA 生态深度整合（Isaac Sim + Cosmos），仿真→真机链路最完整	云端 / DGX
SmolVLA	Hugging Face 社区	SmolVLM	连续回归	最轻量 VLA！可在笔记本 GPU 上实时推理。LeRobot 原生支持，语音控制 SO-101 的首选	8GB GPU
MolmoAct2	AI2 (Allen Institute)	Molmo	离散 + 连续混合	开放词汇物体指代能力强，支持复杂空间关系描述（"放在第二个方块的左边"）	24GB GPU
RDT-1B	清华	自研 Diffusion Transformer	Diffusion + DiT	1B 参数的双臂操作模型，在人形机器人上演示了复杂操作（叠衣服、倒水）	24GB+ GPU

选型建议：

如果你有一台 SO-101 且只有消费级 GPU（8~24GB），SmolVLA 是最佳入门选择——轻量、LeRobot 原生支持、有社区语音控制项目。

如果你有 24GB+ GPU 且追求更強泛化，Pi0 和 OpenVLA 是自然升级路径。

如果你在 NVIDIA 生态（Isaac Sim），GR00T 的仿真→真机链路最完善。

5. VLA 的训练范式

5.1 两阶段训练：预训练 + 微调

VLA 的训练几乎都遵循两阶段范式，与 LLM 的"预训练→SFT→RLHF"路线高度相似：

阶段	数据来源	训练目标	学到什么
阶段 1：视觉语言预训练	互联网图片+文本（几十亿对）	图文匹配、图像描述、视觉问答	"苹果长什么样""红色是什么颜色""碗是容器"——常识性视觉理解和语言理解
阶段 2：机器人数据微调	机器人演示数据（几千到几十万条轨迹）	动作预测、行为克隆	"抓取苹果的动作轨迹长什么样""放到碗里的末端位姿序列是怎样的"——具体操作技能

关键洞察：为什么两阶段有效？

阶段 1 提供了语义理解——模型已经知道"苹果"和"碗"是什么。

阶段 2 的机器人数据只需要教模型"怎么做"，不需要再教"是什么"。这样机器人数据（通常很少，几千条）的效率极高。

这也是为什么 VLA 能做到"零样本泛化"——语义理解来自阶段 1 的海量数据，不需要在阶段 2 中重新学。

5.2 数据：VLA 的"燃料"

数据来源	规模	包含什么	开源代表
互联网图文数据	几十亿对	任意图片 + 文字描述	LAION、COCO、WebLI
大规模机器人数据集	百万级轨迹	多机器人、多任务的演示数据	Open X-Embodiment (OXE)
LeRobot 社区数据	几千到几万条	SO-101/SO-100/Aloha 等特定平台	Hugging Face Hub
自采遥操作数据	几十到几百条	用自己的机械臂录制	用户自己录制+上传
仿真数据	无限（自动生成）	Isaac Sim / ManiSkill3 模拟轨迹	Sim-to-Real 项目的训练数据

数据的"多具身"（Multi-Embodiment）是 VLA 泛化能力的关键。

Open X-Embodiment 数据集包含来自 20+ 种不同机器人（工业臂、人形、移动操作平台）的轨迹。

在这些混合数据上训练的 VLA，能学到跨平台的通用操作技能——"抓取"这个概念不依赖特定机械臂的自由度数量或尺寸。

这就是 VLA 与专用策略的根本区别。

5.3 与 LoRA 的结合

Python — LoRA 微调 VLA
# ═══════════════════════════════════════════════════════════════
# VLA 模型通常很大（7B+），全参数微调需要 A100。
# 在实际项目中，用 LoRA 微调 VLA 是标准做法——
# 冻结 VLM backbone，只训练 action head + 少量 LoRA adapter。
# 这样单张 RTX 3090/4090 就能微调 OpenVLA 或 Pi0。
# ═══════════════════════════════════════════════════════════════
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForVision2Seq

# 1. 加载预训练 VLA（如 OpenVLA-7B）
# OpenVLA 基于 Llama，加载时可以用 4-bit 量化省显存
model = AutoModelForVision2Seq.from_pretrained(
    "openvla/openvla-7b",
    load_in_4bit=True,              # 4-bit 量化，7B 模型只占 ~4GB
    device_map="auto",
)

# 2. 配置 LoRA — 只微调 attention 层的适配器
# VLM backbone 被冻结，不更新；只更新 LoRA adapter + action head
lora_config = LoraConfig(
    r=16,                              # LoRA rank — 可在 8~64 之间调整
    lora_alpha=32,
    target_modules=["q_proj", "v_proj", "o_proj"],  # 哪些层加 adapter
    lora_dropout=0.05,
)
model = get_peft_model(model, lora_config)

# 3. 用 SO-101 遥操作数据微调 action head
#   数据格式：(image, "put the red block on the left", joint_angles)
#   训练目标：给定 image + text，预测 action 序列
#   冻结 → VLM 的语义理解能力不变
#   更新 → action head 学会"把 VLM 的理解翻译成具体关节动作"

# 训练完成后，LoRA adapter 只有几十 MB
# 可以轻松分享、切换、组合不同的微调 adapter

6. 实战：VLA 工作流全链路

以 SO-101 机械臂 + SmolVLA + 语音控制 为例（参考 lerobot.html 中的语音控制项目）：

伪代码 — VLA 推理主循环
# ═══════════════════════════════════════════════════════════════
# VLA 控制机械臂的典型推理循环
# 展示了"感知 → 推理 → 执行 → 反馈"的闭环
# ═══════════════════════════════════════════════════════════════

# 初始化：加载 VLA 模型 + 连接机械臂 + 打开摄像头
model = load_vla("smolvla")          # 加载 SmolVLA 到 GPU
robot = connect_robot("so101")       # USB 连接 SO-101
camera = open_camera(0)             # 打开 USB 摄像头
instruction = "把红色方块放到左边"    # 语音识别后的文本指令

while not task_done:
    # Step 1: 拍一张当前的场景照片
    image = camera.capture()           # RGB 图像，如 224×224 或 384×384

    # Step 2: VLA 推理 — 输入 image + text → 输出 action
    # 模型内部流程:
    #   Vision Encoder 编码图像 → 图像特征向量
    #   LLM backbone 处理 图像特征 + 文本 token → 融合表示
    #   Action Head 从融合表示中解码 → 关节动作
    action = model.predict(image=image, text=instruction)

    # action 可以是:
    #   单步: {"joint1": 30.5, "joint2": -15.2, ..., "gripper": 0.8}
    #   或 action chunk: [action_t, action_t+1, ..., action_t+15]

    # Step 3: 执行动作（带插值平滑）
    robot.execute(action, smooth=True)   # 平滑轨迹避免抖动

    # Step 4: 判断任务是否完成
    # 可通过视觉判断（夹爪里有没有物体）、力反馈等
    task_done = check_completion(image, robot)

# 任务完成后回初始位置
robot.move_to_home()

闭环 vs 开环：

上面的循环是闭环控制——每一步都重新看摄像头、重新推理。

如果物体被碰歪了，VLA 会自适应调整动作。与之对应的是开环控制：看一次，生成完整动作序列，然后一口气执行完。

VLA 通常支持两种模式：复杂任务用闭环（更鲁棒），简单任务用开环（更快）。

7. VLA 的关键挑战与前沿方向

挑战	为什么难	当前解决方案
推理延迟	7B+ 参数的 Transformer 在嵌入式设备上推理一次需要 200~500ms。对于需要 30Hz+ 实时控制的机器人来说太慢	模型蒸馏（大 VLA → 小 VLA）、量化（INT8/INT4）、投机解码、Action Chunking（一次预测多步，降低推理频率）
数据稀缺	互联网数据没有动作标签。机器人演示数据采集成本高（需要人遥操作，每小时只能录几十条）	OXE 等大规模开源数据集、Sim-to-Real（仿真中无限生成数据）、Video-to-Action（从人类视频中学习）
跨具身泛化	不同机器人有不同的自由度、尺寸、动力学。一个策略在 SO-101 上好用，换到 UR5 工业臂就用不了	多具身联合训练（OXE 的做法）、标准化动作空间（相对末端位姿比绝对关节角度更容易迁移）、具身特征作为输入条件
精细操作	离散化 action token 方案在需要毫米级精度的任务（插线、焊接）上精度不够	连续回归 + Diffusion Head、视觉伺服（VLA 做粗规划 + 经典视觉伺服做精细对准）
家庭场景泛化	真实家庭环境有无穷多种物体、布局、光照条件。训练数据不可能覆盖所有情况	开放词汇检测（不限于训练集见过的物体）、基础模型泛化能力、持续学习（边用边学）
安全	VLA 是黑盒，输出动作可能危险（速度快、碰撞、夹到人）	动作空间约束（限制关节速度和力矩）、碰撞检测、人在环（紧急停止）、分层架构（VLA 出高层指令，底层控制器做安全检查）

7.1 前沿方向

世界模型 + VLA

让 VLA 不仅感知当前场景，还能"想象"动作执行后的结果。VLA-JEPA（LeCun 的 JEPA 范式在机器人上的实现）就是这一方向的代表。模型学会预测"如果我做这个动作，世界会变成什么样"。

人形机器人 VLA

RDT-1B（清华）、GR00T N1.5 等开始面向人形机器人的复杂全身操作（叠衣服、倒水、开门）。从单臂到双臂再到全身，动作空间维度从 7D 扩展到 50D+，对 VLA 的动作表示提出新挑战。

自主数据闭环

让机器人在实践中自主收集数据：执行 → 成功/失败 → 自动标注 → 加入训练集 → 重训 → 下次更好。这是 VLA "越用越聪明"的关键——降低了持续依赖人类遥操作的数据采集成本。

模块化 VLA 架构

将 VLA 拆解为可替换的模块——视觉编码器、语言模型、动作解码器各自独立，允许快速迭代和组合。Octo 和 OpenVLA 的开源设计已经朝这个方向努力。

8. 关键问答

8.1 VLA 核心概念速查

概念	一句话解释
VLA	输入图像+文本 → 输出机器人动作的端到端多模态模型
VLM vs VLA	VLM 只会"说"（输出文本），VLA 还会"做"（输出动作）
Action Head	VLA 中负责将多模态融合表示解码为关节动作的模块
Action Token	连续动作离散化后的 token（如 RT-2 的做法），使动作预测可用 LLM 训练
Action Chunking	一次预测未来 N 步动作（而非单步），减少累积误差
OXE	Open X-Embodiment — 目前最大的开源多机器人数据集，VLA 训练的核心数据源
Multi-Embodiment	在多种机器人（不同自由度、尺寸）数据上联合训练，学到跨平台通用技能
Sim-to-Real	仿真中训练策略 → 迁移到真机。零成本无限试错，但需弥合仿真-现实差距
Pi0	Physical Intelligence 的通用机器人 VLA，LeRobot 原生支持
SmolVLA	最轻量 VLA，消费级 GPU 可运行，SO-101 入门首选

8.2 关键问题

Q1: VLA 和传统模仿学习的区别？

答：

模仿学习（ACT、Diffusion Policy）是从特定任务的演示数据中学一个视觉→动作的映射，一个模型只做一个任务。

VLA 多了语言理解——它的视觉和语义理解来自互联网预训练（VLM backbone），因此能理解开放词汇指令、泛化到训练时未见过的新物体和新任务。

核心差异在于语言的加入带来了zero-shot 泛化能力。

Q2: VLA 的动作空间如何设计？

答：

三种主流方案。

①离散化 token（RT-2）——把连续角度分成 N 个 bin，每个 bin 映射为一个 token，和 LLM 的 next-token prediction 训练一致；

②连续回归（SmolVLA）——直接输出浮点值，精度高但与 LLM 范式不兼容；

③扩散生成（Pi0）——从噪声逐步去噪生成动作，擅长多模态分布。选择取决于精度需求和硬件约束。

Q3: 为什么 VLA 能泛化到新任务？

答：

因为 VLA 的语义理解（"苹果是什么""红色是什么颜色"）来自互联网规模的预训练（几十亿图文对），而非只有几百条的机器人数据。

机器人微调阶段只需要教会模型"怎么操作"，而"操作什么"已经在预训练中学会。

当用户说"拿蓝色三角形"，模型能从预训练知识中理解"蓝色"和"三角形"，而不需要之前见过这个特定组合。

Q4: Pi0 和 OpenVLA 的核心差异？

答：

Pi0（Physical Intelligence）是专用机器人基础模型，使用 Flow Matching（扩散模型的高效替代）生成连续动作，训练数据来自多种真实机器人；

OpenVLA 基于 Llama 构建，使用离散化 action token，完全开源（模型+数据+代码）。

Pi0 在泛化能力上目前更强，但 OpenVLA 的开源生态更友好、更容易微调和部署。

Q5: VLA 推理太慢怎么办？

答：

四招。

①Action Chunking：一次预测 16 步动作，推理频率从 30Hz 降到 ~2Hz；

②模型蒸馏：大 VLA（7B）蒸馏为小 VLA（1B 或更小），速度提升 5~10 倍；

③量化：INT8/INT4 量化，显存和带宽都降低；

④异步架构：VLA 跑在 GPU 上做"慢思考"（高层规划），底层高速 PID 控制器做"快反应"（实时伺服）。

Q6: VLA 训练需要多少数据？

答：

分两种情况。

①从零训练 VLA（如 Pi0、GR00T）：需要百万级机器人轨迹（OXE 数据集）+ 互联网图文数据，训练成本百万美元级。

②微调已有 VLA（LoRA + SO-101 数据）：只需50~200 条本机遥操作数据，配合 LoRA 在单张 24GB GPU 上几小时可完成。

对个人开发者而言，方案②是唯一可行的路径。

Q7: VLA 和 Embodied AI 的关系？

答：

Embodied AI（具身智能）是一个更大的概念，指能感知物理世界并在其中行动的 AI 系统。

VLA 是 Embodied AI 中的核心模型范式——它解决了"语言理解→视觉感知→物理动作"这个端到端映射问题。

但完整的 Embodied AI 还需要导航、长期规划、记忆、多智能体协作等能力，VLA 是其中最关键的一块拼图。

Q8: VLA 目前最大的局限是什么？

答：

四个核心挑战：

①精细操作（毫米级精度难达到）；

②长时序任务（"做一顿饭"这种需要几百步的任务）；

③安全性（VLA 输出不可预测，在与人交互时需要保障）；

④数据瓶颈（机器人数据仍然太少，且难以大规模自动化采集）。

这些都是当前最活跃的研究方向。

8.3 VLA 与相关领域的全景图

技术演进全景
# ═══════════════════════════════════════════════════════════════
#                    VLA 相关技术全景
# ═══════════════════════════════════════════════════════════════
#
#   底层技术                    中层能力                    上层应用
#   ────────                    ────────                    ────────
#
#   Transformer          →     LLM (GPT, Llama)      →    ChatGPT
#        │                        │
#        │   + Vision Encoder     │
#        ▼                        ▼
#   Attention 机制        →     VLM (GPT-4V, Molmo)   →    看图问答
#        │                        │
#        │   + Action Head        │  + 机器人数据
#        │   + 机器人数据           │
#        ▼                        ▼
#   Diffusion / Flow      →     VLA (Pi0, OpenVLA)    →    "拿那个杯子"
#        │                        │
#        │   + 多模态输入           │  + 导航+规划+记忆
#        ▼                        ▼
#   世界模型 (JEPA)       →     Embodied AI            →    全能机器人
#
# ═══════════════════════════════════════════════════════════════