2026年，具身智能（Embodied AI）正经历从概念验证迈向工业级规模部署的关键拐点。机器人基础模型从根本上改变了机器人开发的范式——从为每个任务编写自定义控制逻辑，转向用一个通用模型解决多个任务。在这一变革中，视觉-语言-动作（Vision-Language-Action, VLA）模型作为连接数字认知与物理执行的"大脑皮层"，展现出前所未有的跨平台泛化潜力。

VLA模型于2023年7月由Google DeepMind在发布RT-2模型时首次被正式提出。其革命性在于将机器人动作直接融入语言模型的输出序列：图像像素、文本指令与机器人动作被映射到统一语义空间，大模型首次具备了"理解动作"的可能性。此后，斯坦福大学等机构于2024年发布OpenVLA开源框架，进一步推动了社区对VLA模型的研究热情。

本报告将系统阐述VLA模型的技术原理、核心架构、代码实现与行业前沿进展。

二、VLA模型的核心原理

2.1 从模块化到端到端

传统机器人控制系统通常采用模块化设计：

[视觉感知模块] → [场景理解模块] → [规划模块] → [控制模块]

各模块独立训练，接口复杂，误差逐级累积，难以实现跨任务泛化。

VLA模型的端到端架构则彻底颠覆了这一范式：

[视觉输入 + 语言指令 + 本体状态] → [统一Transformer骨干] → [动作序列输出]

端到端学习使信息无损传递，避免了传统分层架构中各模块接口间的语义损耗。

2.2 三大核心创新

（1）统一表征空间：视觉标记（Vision Tokens）、语言标记（Language Tokens）和动作标记（Action Tokens）在同一个Transformer空间中交互，实现隐式跨模态推理。

（2）动作标记化（Action Tokenization）：将连续机器人动作离散化为token序列，复用语言模型的自回归生成范式。例如RT-2将动作空间量化为256个离散token。

（3）流匹配解码（Flow Matching）：Physical Intelligence提出的替代方案，直接在连续动作空间中生成平滑轨迹，避免离散化带来的精度损失，特别适合需要精细力控的接触任务。

三、技术架构详解

3.1 模型层组件

VLA模型的技术栈可分为模型层、数据层和部署层三个维度。

组件技术选型说明
视觉编码器ViT / CLIP / SigLIP / DINOv2提取图像空间特征与语义特征
语言编码器LLM / Llama / Qwen理解自然语言指令
多模态融合交叉注意力 / 门控融合视觉-语言特征对齐
动作解码器离散token预测 / 连续扩散 / 流匹配生成机器人控制信号

3.2 主流架构路线

当前VLA模型在技术路线上呈现明显分化：

  • 大模型增强路线：以Google Gemini Robotics为代表，将超大多模态模型的推理能力直接注入机器人控制，优势是强大的语言理解和常识推理能力。
  • 专用高效路线：以Physical Intelligence π0为代表，使用相对紧凑的专用架构（3B参数），结合Flow Matching实现实时控制，优势是延迟低、可边缘部署。
  • 平台生态路线：以NVIDIA GR00T为代表，提供基础模型+仿真平台+开发工具链的完整生态系统。

3.3 2026年前沿进展

  • 类脑架构：智平方NeuroVLA引入"大脑-小脑-脊髓"三层类脑体系，碰撞反射时间仅20毫秒，脊髓层功耗仅0.4瓦。
  • 具身先验注入：地平线HoloBrain-0将机器人本体信息结构化地注入模型计算过程，在RoboTwin 2.0的50项任务中平均成功率超过90%。
  • 大小脑协同：小米Xiaomi-Robotics-0采用MoT混合架构，"视觉语言大脑"负责决策，"动作执行小脑"生成高频平滑动作块。

四、代码实现与解析

以下是一个简化版VLA模型的PyTorch实现，展示核心架构：

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import AutoModel, AutoTokenizer


class VisionEncoder(nn.Module):
    """视觉编码器：使用预训练ViT提取图像特征"""
    def __init__(self, embed_dim=768, image_size=224):
        super().__init__()
        self.vit = AutoModel.from_pretrained("google/vit-base-patch16-224")
        self.proj = nn.Linear(768, embed_dim)
    
    def forward(self, images):
        # images: (B, 3, H, W)
        outputs = self.vit(pixel_values=images)
        # 取[CLS] token作为全局图像表示
        image_features = outputs.last_hidden_state[:, 0, :]  # (B, 768)
        return self.proj(image_features)  # (B, embed_dim)


class LanguageEncoder(nn.Module):
    """语言编码器：使用预训练LLM提取文本特征"""
    def __init__(self, embed_dim=768):
        super().__init__()
        self.tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
        self.llm = AutoModel.from_pretrained("meta-llama/Llama-2-7b-hf")
        self.proj = nn.Linear(4096, embed_dim)
    
    def forward(self, input_ids, attention_mask):
        outputs = self.llm(input_ids=input_ids, attention_mask=attention_mask)
        # 取最后一个token的隐藏状态作为句子表示
        text_features = outputs.last_hidden_state[:, -1, :]  # (B, 4096)
        return self.proj(text_features)  # (B, embed_dim)


class ActionHead(nn.Module):
    """动作头：将多模态特征映射为机器人动作"""
    def __init__(self, embed_dim=768, action_dim=7, num_bins=256):
        super().__init__()
        self.action_dim = action_dim  # 如: 6DoF位姿 + 夹爪开合
        self.num_bins = num_bins      # 动作离散化bin数量
        
        # 多层感知机预测每个动作维度的离散分布
        self.mlp = nn.Sequential(
            nn.Linear(embed_dim, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, action_dim * num_bins)
        )
    
    def forward(self, fused_features):
        # fused_features: (B, embed_dim)
        logits = self.mlp(fused_features)  # (B, action_dim * num_bins)
        logits = logits.view(-1, self.action_dim, self.num_bins)
        return logits  # (B, action_dim, num_bins)
    
    def decode_actions(self, logits):
        """将logits解码为连续动作值"""
        probs = F.softmax(logits, dim=-1)
        # 使用期望值作为动作输出
        bins = torch.linspace(-1, 1, self.num_bins, device=logits.device)
        actions = torch.sum(probs * bins.view(1, 1, -1), dim=-1)
        return actions  # (B, action_dim)


class VLAModel(nn.Module):
    """
    视觉-语言-动作一体化模型
    
    架构流程:
    1. 视觉编码器提取图像特征
    2. 语言编码器提取指令特征
    3. 交叉注意力融合多模态特征
    4. 动作头输出机器人控制信号
    """
    def __init__(self, embed_dim=768, action_dim=7, num_bins=256):
        super().__init__()
        self.vision_encoder = VisionEncoder(embed_dim=embed_dim)
        self.language_encoder = LanguageEncoder(embed_dim=embed_dim)
        
        # 交叉注意力融合模块
        self.cross_attn = nn.MultiheadAttention(
            embed_dim=embed_dim,
            num_heads=8,
            batch_first=True
        )
        self.fusion_mlp = nn.Sequential(
            nn.Linear(embed_dim * 2, embed_dim),
            nn.GELU(),
            nn.Linear(embed_dim, embed_dim)
        )
        
        # 动作预测头
        self.action_head = ActionHead(
            embed_dim=embed_dim,
            action_dim=action_dim,
            num_bins=num_bins
        )
        
        # 本体状态编码器（关节角度、末端位姿等）
        self.proprio_encoder = nn.Sequential(
            nn.Linear(14, 128),  # 假设14维本体状态
            nn.ReLU(),
            nn.Linear(128, embed_dim)
        )
    
    def forward(self, images, input_ids, attention_mask, proprio_state=None):
        """
        Args:
            images: (B, 3, H, W) 视觉输入
            input_ids: (B, seq_len) 语言指令token IDs
            attention_mask: (B, seq_len) 注意力掩码
            proprio_state: (B, 14) 本体状态（可选）
        
        Returns:
            action_logits: (B, action_dim, num_bins) 动作预测logits
        """
        # Step 1: 提取视觉特征
        vision_features = self.vision_encoder(images)  # (B, embed_dim)
        
        # Step 2: 提取语言特征
        text_features = self.language_encoder(input_ids, attention_mask)  # (B, embed_dim)
        
        # Step 3: 多模态融合（交叉注意力）
        # 以语言特征为Query，视觉特征为Key/Value
        vision_kv = vision_features.unsqueeze(1)  # (B, 1, embed_dim)
        text_q = text_features.unsqueeze(1)        # (B, 1, embed_dim)
        
        attn_output, _ = self.cross_attn(
            query=text_q,
            key=vision_kv,
            value=vision_kv
        )  # (B, 1, embed_dim)
        
        # 拼接并融合
        fused = torch.cat([text_features, attn_output.squeeze(1)], dim=-1)
        fused_features = self.fusion_mlp(fused)  # (B, embed_dim)
        
        # Step 4: 融合本体状态（如果提供）
        if proprio_state is not None:
            proprio_features = self.proprio_encoder(proprio_state)
            fused_features = fused_features + proprio_features
        
        # Step 5: 预测动作
        action_logits = self.action_head(fused_features)
        return action_logits
    
    def predict_action(self, images, instruction_text, proprio_state=None):
        """推理接口：从原始输入预测动作"""
        self.eval()
        with torch.no_grad():
            # 编码语言指令
            inputs = self.language_encoder.tokenizer(
                instruction_text,
                return_tensors="pt",
                padding=True,
                truncation=True
            )
            input_ids = inputs["input_ids"].to(images.device)
            attention_mask = inputs["attention_mask"].to(images.device)
            
            # 前向传播
            logits = self.forward(images, input_ids, attention_mask, proprio_state)
            
            # 解码为连续动作
            actions = self.action_head.decode_actions(logits)
        return actions


# ==================== 训练流程示例 ====================

class VLA Trainer:
    """VLA模型训练器"""
    
    def __init__(self, model, lr=1e-4, num_bins=256):
        self.model = model
        self.num_bins = num_bins
        self.optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
        self.scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
            self.optimizer, T_max=10000
        )
    
    def compute_loss(self, action_logits, target_actions):
        """
        计算动作预测损失
        
        使用交叉熵损失：将连续目标动作映射到最近的bin，
        然后对每个动作维度计算分类损失。
        """
        # 将连续动作值映射到离散bin索引
        # 假设动作范围[-1, 1]
        bin_indices = ((target_actions + 1) / 2 * (self.num_bins - 1)).long()
        bin_indices = bin_indices.clamp(0, self.num_bins - 1)  # (B, action_dim)
        
        # 交叉熵损失
        loss = F.cross_entropy(
            action_logits.view(-1, self.num_bins),  # (B*action_dim, num_bins)
            bin_indices.view(-1)                      # (B*action_dim,)
        )
        return loss
    
    def train_step(self, batch):
        """单步训练"""
        self.model.train()
        
        images = batch["images"]           # (B, 3, H, W)
        input_ids = batch["input_ids"]     # (B, seq_len)
        attention_mask = batch["attention_mask"]
        proprio_state = batch.get("proprio_state")
        target_actions = batch["actions"]  # (B, action_dim)
        
        # 前向传播
        action_logits = self.model(
            images, input_ids, attention_mask, proprio_state
        )
        
        # 计算损失
        loss = self.compute_loss(action_logits, target_actions)
        
        # 反向传播
        self.optimizer.zero_grad()
        loss.backward()
        
        # 梯度裁剪防止爆炸
        torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
        
        self.optimizer.step()
        self.scheduler.step()
        
        return loss.item()


# ==================== 使用示例 ====================

if __name__ == "__main__":
    # 初始化模型
    model = VLAModel(embed_dim=768, action_dim=7, num_bins=256)
    
    # 模拟输入
    batch_size = 4
    images = torch.randn(batch_size, 3, 224, 224)
    proprio_state = torch.randn(batch_size, 14)
    instruction = "pick up the red cube"
    
    # 推理
    action = model.predict_action(images, instruction, proprio_state)
    print(f"预测动作形状: {action.shape}")  # (4, 7)
    print(f"预测动作值:\n{action}")
    
    # 训练
    trainer = VLATrainer(model)
    batch = {
        "images": images,
        "input_ids": torch.randint(0, 32000, (batch_size, 16)),
        "attention_mask": torch.ones(batch_size, 16),
        "proprio_state": proprio_state,
        "actions": torch.rand(batch_size, 7) * 2 - 1,  # [-1, 1]
    }
    loss = trainer.train_step(batch)
    print(f"训练损失: {loss:.4f}")

代码解析

（1）VisionEncoder：使用预训练的ViT（Vision Transformer）提取图像的全局特征。取[CLS] token作为整张图像的表示，再通过线性层投影到统一嵌入维度。

（2）LanguageEncoder：使用预训练的大语言模型（如Llama-2）编码文本指令，取最后一个token的隐藏状态作为句子级语义表示。

（3）ActionHead：核心创新在于动作离散化。将连续动作空间（如关节角度、末端位姿）划分为256个bin，将回归问题转化为分类问题，从而复用LLM强大的token预测能力。推理时通过期望值还原为连续动作。

（4）交叉注意力融合：以语言特征为Query、视觉特征为Key/Value，使模型能够根据指令内容"关注"图像中的相关区域，实现视觉-语言的细粒度对齐。

（5）训练损失：采用交叉熵损失，将连续目标动作映射到最近的bin索引，对每个动作维度独立计算分类损失。这种方式比直接回归更稳定，且与LLM的训练目标一致。

五、技术亮点与突破

5.1 端到端信息无损

VLA模型最大的优势在于端到端的信息传递。传统流水线中，视觉模块输出的边界框、分割掩码等中间表示会丢失大量原始信息；而VLA直接在原始像素级别进行联合表征学习，保留了最丰富的环境信息。

5.2 开放世界语义理解

借助互联网规模预训练获得的常识知识，VLA模型能够理解自然语言指令中的隐含意图。例如"把桌上乱的东西收拾一下"这样的模糊指令，传统机器人无法处理，而VLA模型可以结合视觉场景进行合理推断。

5.3 跨本体泛化能力

通过共享高层视觉-语言表示，VLA模型可以实现不同机器人形态间的知识迁移。使用LoRA等参数高效微调方法，仅需少于1000条数据即可适配新机器人本体。

5.4 实时控制突破

2026年的技术进展显著提升了VLA的推理效率：

  • OpenVLA-OFT优化版实现25-50倍推理加速，在LIBERO基准上达97.1%成功率。
  • 地平线HoloBrain-0的0.2B版本在端侧芯片上实现>5Hz流畅推理，部分场景达25fps。
  • 智平方NeuroVLA的"脊髓"层实现20毫秒碰撞反射，功耗仅0.4瓦。

5.5 与世界模型融合

VLA处理快速反应控制（系统1），世界模型处理需要推理和规划的慢速深思决策（系统2），两者结合正成为主流趋势。腾讯2026年4月发布的具身模型引入"预测性世界模型"，在执行动作前先在内部模拟结果，选择最优路径。

六、挑战与展望

尽管VLA模型取得了显著进展，仍面临以下挑战：

挑战说明应对方向
数据依赖需要大量高质量视觉-语言-动作对齐数据仿真数据生成、人类视频挖掘、自监督学习
实时性与精度矛盾高频控制需求（50-100Hz）与Transformer推理延迟存在张力模型压缩、异步推理、分层架构
长程任务规划弱单次推理难以处理多步骤协调的复杂任务与世界模型结合、思维链推理
安全性验证难端到端架构缺乏可解释中间表征类脑反射层、形式化验证、安全护栏

展望2027年及以后，VLA模型将向以下方向演进：

  1. 类脑架构深化：大脑-小脑-脊髓分层协同将成为主流，兼顾高层推理与底层实时控制。
  2. 数据飞轮启动：随着部署规模扩大，真实世界数据将反哺模型迭代，形成自我增强的数据闭环。
  3. 工业规模化落地：物流仓储、柔性制造等场景将率先实现商业规模化，家庭服务机器人也将进入试点阶段。
  4. 开源生态繁荣：OpenVLA、HoloBrain、GR00T等开源框架将持续降低技术门槛，推动社区创新。

七、总结

VLA具身基座模型代表了人工智能从"数字智能"向"物理智能"演进的关键一步。通过将视觉感知、语言理解和动作生成统一在端到端神经网络中，VLA模型使机器人首次具备了"看-想-做"的闭环能力。

从2023年RT-2的首次提出，到2024年OpenVLA的开源普及，再到2026年类脑架构、世界模型融合等前沿突破，VLA技术正以惊人的速度迭代。尽管在数据、实时性、安全性等方面仍面临挑战，但随着技术成熟和生态完善，VLA模型有望成为未来通用机器人的核心"大脑"，推动具身智能从实验室走向千家万户和工业生产一线。

对于开发者和研究者而言，当下正是入局的最佳时机——借助开源框架和预训练基座模型，可以在垂直场景中快速验证VLA技术的价值，参与到这场重塑机器人行业的范式变革之中。

在这里插入图片描述

# 人工智能 # microsoft
Logo
DAMO开发者矩阵

DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐

cover

超级具身智能集群协作研究（21）：群体智能涌现与宏观秩序调控机制详解

avatar DAMO开发者矩阵
cover

超级具身智能集群协作研究（18）：基于FRA的断点续传与状态一致性恢复机制

avatar DAMO开发者矩阵
cover

超级具身智能集群协作研究（24）：基于FRA的人机回环协同与可信干预机制

avatar DAMO开发者矩阵