芯耀
与非AI
241
转载自公众号：敢敢AUTOHUB
0. 引言
当我们谈论具身智能时，脑海中浮现的往往是波士顿动力的机器狗、特斯拉的人形机器人，或是各类工业机械臂。然而，一个国民级导航应用高德地图，却在这个赛道上取得了令人瞩目的成绩。高德推出的 ABot 全栈具身技术体系，不仅在 CVPR 2026 Video World Model Workshop 国际挑战赛中超越谷歌和英伟达，更在 WorldArena 全球排行榜上夺得第一名，横扫具身智能领域 15 项 SOTA 指标。
这并非偶然的跨界尝试，而是一次深思熟虑的技术升维。高德从"为人类导航"升级到"为机器人构建物理世界操作系统"，其背后的技术逻辑值得深入剖析。本文将从数据基础、模型架构、训练方法到实际应用，全面解读高德如何利用地图时代积累的核心能力，在具身智能领域实现技术突破。
1. 技术体系概览：三层架构构建完整闭环
高德 ABot 采用了从底层到应用层的全栈技术架构，这种设计理念确保了从数据生产到实际部署的完整闭环。整个体系分为三个核心层次，形成了一个自洽的技术生态系统。
1.1 数据层：ABot-World 可交互世界模型
这是整个体系的基石，包含两大核心引擎。ABot-3DGS 作为"数字孪生工厂"，负责将真实世界的物理空间转化为可编程的训练环境；ABot-PhysWorld 作为"物理思维引擎"，确保生成的数据符合真实物理规律。这一层解决的是具身智能最根本的问题：如何让机器人理解真实物理世界的运作规律。
数据层的核心价值在于构建了一个可交互、可验证、可扩展的虚拟物理世界。与传统的静态数据集不同，ABot-World 能够根据机器人的动作实时生成反馈，形成闭环的交互式学习环境。这种动态数据生成能力，使得模型能够在无限多样的场景中进行训练，而不受真实世界数据采集成本的限制。
1.2 模型层：导航与执行双基座模型
在数据层之上，高德构建了两个专门化的基座模型。ABot-N 导航基座模型专注于路径规划和空间理解，能够处理从室外到室内的跨场景导航任务；ABot-M 执行基座模型则负责具体的动作生成和控制，将高层指令转化为精确的关节控制信号。这种分工明确的设计，使得系统能够同时处理宏观的导航决策和微观的动作执行，避免了端到端模型在复杂任务中的性能瓶颈。
双基座模型的设计理念源于人类认知系统的分层处理机制。导航模型类似于人类的空间认知系统，负责"去哪里"的决策；执行模型类似于运动控制系统，负责"怎么去"的实现。这种分层设计不仅提高了模型的可解释性，也使得系统能够更灵活地适应不同的机器人平台和任务需求。
1.3 应用层：ABot-Claw 机器人操作系统
最上层是面向实际应用的操作系统，它将底层的模型能力封装成易于调用的接口，支持不同形态的机器人快速接入。ABot-Claw 提供了统一的 API 规范，使得开发者无需深入了解底层模型的实现细节，就能够快速构建具身智能应用。这种设计理念类似于 Android 系统对移动设备的支持，降低了具身智能应用的开发门槛，加速了技术的产业化进程。
2. 核心突破：从视觉渲染到物理推演的范式转变
2.1 传统方法的困境
当前主流的世界模型大多基于视觉渲染范式，其核心目标是生成"看起来像"的视频内容。这些模型通过学习大量视频数据中的像素分布，能够生成视觉上逼真的画面。然而，这种方法存在致命缺陷：它们只关注表面的视觉相似性，而忽略了物理世界的内在规律。
具体表现为三类典型错误：物体穿透现象（机械臂直接穿过桌面）、无接触抓取（夹爪未接触物体就完成了抓取）、反重力运动（物体悬浮在空中）。这些违反物理常识的行为，使得模型生成的数据无法用于训练真实的机器人系统。即使视觉效果再逼真，一旦部署到实际环境中，机器人也会因为学习了错误的物理关系而频繁失败。
传统视觉渲染模型的根本问题在于，它们将视频生成视为一个纯粹的像素预测问题，而非物理状态演化问题。模型学习的是"什么样的像素序列在统计上更可能出现"，而不是"物体在物理规律约束下应该如何运动"。这种方法论上的偏差，导致生成的视频虽然在视觉上连贯，但在物理上却是荒谬的。
2.2 高德的解决方案：可微分物理引擎
高德 ABot-PhysWorld 采用了完全不同的技术路线，实现了从"视觉渲染范式"向"可微分物理引擎范式"的根本性迁移。这个 140 亿参数的 Diffusion Transformer 模型，其核心创新在于将物理规律嵌入到生成过程中。
模型的输出不再是简单的像素矩阵，而是包含质量、接触力场、惯性张量的可微分物理状态快照。每一帧画面都对应着一个完整的物理状态描述，包括物体的位置、速度、加速度，以及相互之间的作用力。这种设计使得模型能够进行真正的物理推演，而不是表面的视觉模拟。
以下是 ABot-PhysWorld 的实际推理代码，展示了如何加载模型并生成物理一致的视频：
#!/usr/bin/env python3
"""
ABot-PhysWorld 推理脚本
基于 Wan2.1-I2V-14B-480P 模型的图像到视频生成
"""
import torch
from PIL import Image
from diffsynth import save_video
from diffsynth.pipelines.wan_video_new import WanVideoPipeline, ModelConfig
from diffsynth.models.utils import load_state_dict
# ModelScope 模型标识
MODELSCOPE_MODEL_ID = "amap_cvlab/Abot-PhysWorld"
CHECKPOINT_FILENAME = "step-2400.safetensors"
def load_pipeline(device="cuda"):
"""加载 Wan2.1-I2V-14B-480P 基础流水线"""
print("正在加载 Wan2.1-I2V-14B-480P 基础模型...")
pipe = WanVideoPipeline.from_pretrained(
torch_dtype=torch.bfloat16,
device=device,
model_configs=[
# DiT 扩散模型（140亿参数）
ModelConfig(
model_id="Wan-AI/Wan2.1-I2V-14B-480P",
origin_file_pattern="diffusion_pytorch_model*.safetensors",
offload_device="cpu",
),
# T5 文本编码器
ModelConfig(
model_id="Wan-AI/Wan2.1-I2V-14B-480P",
origin_file_pattern="models_t5_umt5-xxl-enc-bf16.pth",
offload_device="cpu",
),
# VAE 视频编码器
ModelConfig(
model_id="Wan-AI/Wan2.1-I2V-14B-480P",
origin_file_pattern="Wan2.1_VAE.pth",
offload_device="cpu",
),
# CLIP 图像编码器
ModelConfig(
model_id="Wan-AI/Wan2.1-I2V-14B-480P",
origin_file_pattern="models_clip_open-clip-xlm-roberta-large-vit-huge-14.pth",
offload_device="cpu",
),
],
)
return pipe
def load_checkpoint(pipe, checkpoint_path):
"""加载 ABot-PhysWorld 微调检查点"""
print(f"正在加载 ABot-PhysWorld 检查点: {checkpoint_path}")
checkpoint_state_dict = load_state_dict(checkpoint_path)
print(f" 检查点包含 {len(checkpoint_state_dict)} 个参数键")
# 加载到 DiT 模型中
missing_keys, unexpected_keys = pipe.dit.load_state_dict(
checkpoint_state_dict, strict=False
)
print(f" 已加载 - 缺失键: {len(missing_keys)}, 意外键: {len(unexpected_keys)}")
def generate_video(
pipe,
input_image,
prompt,
negative_prompt="静态，细节模糊不清，最差质量，低质量，畸形的",
height=480,
width=832,
num_frames=81,
num_inference_steps=50,
cfg_scale=5.0,
seed=0,
tiled=True,
):
"""从输入图像和文本提示生成视频"""
if input_image.size != (width, height):
input_image = input_image.resize((width, height), Image.Resampling.LANCZOS)
# 调用流水线生成视频
video = pipe(
prompt=prompt,
negative_prompt=negative_prompt,
input_image=input_image,
height=height,
width=width,
num_frames=num_frames,
num_inference_steps=num_inference_steps,
cfg_scale=cfg_scale,
seed=seed,
tiled=tiled,
)
return video这段代码展示了 ABot-PhysWorld 的核心架构：140 亿参数的 DiT（Diffusion Transformer）模型作为物理推理引擎，配合 T5 文本编码器理解任务指令，VAE 编码器处理视频特征，CLIP 图像编码器提取视觉语义。整个流水线使用 bfloat16 混合精度训练，支持 CPU offload 机制以优化显存使用。
这种物理优先的设计带来了三个关键优势。首先是动作可控性，给定一个动作指令（如"下降 5 厘米、夹爪闭合"），模型能够精准计算出接下来会发生什么，而不是依靠"猜测"。其次是零样本泛化能力，即使遇到从未见过的物体或机器人，模型也能根据质量、摩擦、惯性等通用物理规律做出合理判断。最后是物理合规性，生成的每一帧都严格遵守牛顿力学定律，杜绝了低级物理错误。
3. 数据生产：从真实世界到训练材料的完整流程
3.1 ABot-3DGS：可编程的数字孪生工厂
传统的机器人训练数据采集方式面临三大困境：成本高昂（需要大量人力和设备）、效率低下（采集速度远跟不上需求）、覆盖不全（难以覆盖长尾场景）。高德通过 ABot-3DGS 系统性地解决了这些问题。
该系统以高德积累的厘米级城市、道路、室内空间数据为基础，结合前沿的 3D Gaussian Splatting 技术，构建可编程的数字孪生空间。关键在于"可编程"三个字，这意味着数据生产不再受制于物理世界的采集条件。任意视角、光照条件、遮挡状态都可以通过编程直接生成，机器人形态也能灵活切换，不同执行体之间的差异被系统性抹平。
更重要的是，这套体系能够系统性补齐长尾交互场景。通过大规模组合与仿真，那些机器人容易"翻车"的极端情况、突发干扰都能提前构造出来，最终将场景覆盖率推到 99%。这意味着模型在训练阶段就已经"见过"并"练过"了绝大多数可能出现的情况，大幅降低了实际部署时的失败率。
数据生产的三步流程：
第一步是"翻译"，将原始数据转换成机器可读的多模态 Clip。以骑车经过路口为例，高德记录的不只是一张静态图片，而是一整套结构化信息：路口的视觉外观（图像）、红绿灯的空间位置（坐标）、当前的交通状态（红灯或绿灯）、行为意图（直行或转弯），以及周围的动态元素（行人、车辆）。所有信息打包形成一个完整的 Clip，而高德手中拥有千万级规模的此类数据。
第二步是"重建"，利用这些多模态 Clip 重建三维场景。ABot-3DGS 能够将路口、街道、商场等地方重建成万级规模的 3D 真实场景。由于前一步获取的信息自带物理规则和空间逻辑，重建出的数字场景也都是"活"的，每个物体都被赋予了质量、摩擦系数等物理属性，从一开始就构成一个可计算、可干预的物理环境。
第三步是"Run"，将机器人放入重建的场景中实际运行。通过编程改变参数（如调整物体质量、地面摩擦系数），可以模拟各种不同的物理条件。机器人在这些场景中走一遍、做一遍，千万级训练轨迹数据就这样批量生成。这种方法的效率远超传统的人工采集，且数据质量更高、覆盖面更广。
3.2 ABot-PhysWorld：物理思维引擎的训练策略
有了大规模的场景数据，下一个挑战是如何让模型真正"懂物理"。ABot-PhysWorld 基于 140 亿参数的 Diffusion Transformer 架构，通过三个维度的创新实现了物理对齐。
以下是 ABot-PhysWorld 的实际训练代码，展示了如何进行全参数微调：
#!/usr/bin/env python3
"""
ABot-PhysWorld 训练脚本
全参数 SFT 训练 Wan2.1-I2V-14B-480P 模型
"""
import torch
from diffsynth import load_state_dict
from diffsynth.pipelines.wan_video_new import WanVideoPipeline, ModelConfig
from diffsynth.trainers.utils import DiffusionTrainingModule
class WanTrainingModule(DiffusionTrainingModule):
"""Wan2.1-I2V-14B 视频生成模型的训练模块"""
def __init__(
self,
model_paths=None,
trainable_models=None,
use_gradient_checkpointing=True,
save_encoded_cache=False,
encoded_cache_dir=None,
skip_vae=False,
skip_text_encoder=False,
realtime_text_encode=False,
max_timestep_boundary=1.0,
min_timestep_boundary=0.0,
):
super().__init__()
# 实时文本编码模式：保持文本编码器加载
if realtime_text_encode and skip_text_encoder:
print("=" * 60)
print("警告: realtime_text_encode=True 但 skip_text_encoder=True")
print(" 实时文本编码需要文本编码器，禁用 skip_text_encoder")
print("=" * 60)
skip_text_encoder = False
# 解析模型配置
model_configs = self.parse_model_configs(
model_paths, enable_fp8_training=False
)
# 过滤掉需要跳过的模型（用于缓存训练）
if skip_vae or skip_text_encoder:
filtered_configs = []
skipped_models = []
for config in model_configs:
pattern = config.origin_file_pattern if hasattr(config, 'origin_file_pattern') else ""
if skip_vae and "VAE" in pattern:
skipped_models.append(f"VAE ({pattern})")
continue
if skip_text_encoder and ("t5" in pattern.lower() or "text" in pattern.lower()):
skipped_models.append(f"TextEncoder ({pattern})")
continue
filtered_configs.append(config)
if skipped_models:
print("=" * 60)
print("[缓存训练模式] 跳过以下模型以节省显存:")
for model in skipped_models:
print(f" - {model}")
print("=" * 60)
model_configs = filtered_configs
# 加载模型
self.pipe = WanVideoPipeline.from_pretrained(
torch_dtype=torch.bfloat16,
device="cpu",
model_configs=model_configs,
)
# 设置训练模式
self.switch_pipe_to_training_mode(
self.pipe,
trainable_models,
enable_fp8_training=False,
)
# 存储配置
self.use_gradient_checkpointing = use_gradient_checkpointing
self.max_timestep_boundary = max_timestep_boundary
self.min_timestep_boundary = min_timestep_boundary
# 编码缓存配置
self.save_encoded_cache = save_encoded_cache
self.encoded_cache_dir = encoded_cache_dir
self.cache_index = {}
if self.save_encoded_cache and self.encoded_cache_dir:
from pathlib import Path
Path(self.encoded_cache_dir).mkdir(parents=True, exist_ok=True)
print(f"编码缓存模式已启用，保存目录: {self.encoded_cache_dir}")
self.skip_vae = skip_vae
self.skip_text_encoder = skip_text_encoder
self.realtime_text_encode = realtime_text_encode
if self.realtime_text_encode:
print("=" * 60)
print("[实时文本编码模式] 已启用:")
print(" - 使用缓存的视频特征 (input_latents, y, clip_feature)")
print(" - 从 JSONL 读取新提示词并实时编码文本")
print(" - 使用场景: 视频不变，但标注重新标注")
print("=" * 60)这段代码展示了 ABot-PhysWorld 训练的核心特性：
1. 全参数微调（Full-parameter SFT）：不同于 LoRA 等参数高效方法，ABot-PhysWorld 对 140 亿参数进行全量训练，确保模型能够深度学习物理规律。
2. DeepSpeed ZeRO-2 分布式训练：通过 Accelerate 框架集成 DeepSpeed，支持多 GPU 并行训练，优化显存使用。
3. 编码特征缓存：支持保存和加载 VAE、T5、CLIP 的编码结果，大幅加速训练过程。对于视频不变但标注更新的场景，可以跳过视频编码，只重新编码文本。
4. 实时文本编码模式：当视频特征已缓存时，可以动态读取新的文本提示词并实时编码，适用于数据标注迭代优化的场景。
5. 梯度检查点（Gradient Checkpointing）：通过重计算中间激活值来节省显存，使得在有限的硬件资源下也能训练大模型。
数据层面：四层级物理语义结构
高德精选了 300 万条真实操作视频，采用 VLM（视觉语言模型）和 LLM（大语言模型）双阶段标注，构建了四层级物理语义结构。这种标注方式不仅告诉模型"发生了什么"，更重要的是解释"为什么发生"。
- • *宏观层（意图）**使用自然语言描述整体任务目标，如"抓取并放置苹果"。这一层提供了任务的高层语义理解，帮助模型建立目标导向的认知。通过理解任务意图，模型能够在执行过程中保持目标一致性，避免出现动作正确但目标偏离的情况。
- • *中观层（动作序列）**采用动词-名词短语序列表示，如"接近→抓握→提起→移动→释放"。这种结构化表示将复杂任务分解为可执行的原子动作，便于模型学习动作之间的因果关系。每个动作都有明确的前置条件和后置效果，形成了一个完整的动作链。
- • *微观层（轨迹细节）**记录笛卡尔轨迹、相对运动、夹爪状态等精确信息，如"末端沿 Z 轴下降 5cm，夹爪闭合至 20mm"。这一层提供了动作执行的具体参数，确保模型能够生成精确的控制指令。这些精确的数值信息是实现高精度操作的关键。
- • *场景层（物理关系）**描述接触、支撑、包含关系及任务结果，如"苹果与桌面接触，被夹爪稳固抓握，成功放置于袋中"。这一层明确了物体之间的物理交互关系，是物理推理的关键。通过学习这些物理关系，模型能够理解动作如何改变物体的状态。
# 四层级物理语义标注示例
annotation = {
'macro': {
'intent': '抓取并放置苹果',
'goal': '将苹果从桌面移动到袋子中'
},
'meso': {
'action_sequence': [
{'action': 'approach', 'target': 'apple'},
{'action': 'grasp', 'target': 'apple'},
{'action': 'lift', 'height': 0.1},
{'action': 'move', 'destination': 'bag'},
{'action': 'release', 'target': 'apple'}
]
},
'micro': {
'trajectory': [
{'time': 0.0, 'position': [0.3, 0.2, 0.5], 'gripper': 'open'},
{'time': 1.0, 'position': [0.3, 0.2, 0.45], 'gripper': 'closing'},
{'time': 2.0, 'position': [0.3, 0.2, 0.45], 'gripper': 'closed'},
{'time': 3.0, 'position': [0.3, 0.2, 0.55], 'gripper': 'closed'},
# ... 更多轨迹点
]
},
'scene': {
'physical_relations': [
{'type': 'contact', 'objects': ['apple', 'table'], 'time': 0.0},
{'type': 'grasp', 'objects': ['gripper', 'apple'], 'time': 2.0},
{'type': 'support', 'objects': ['gripper', 'apple'], 'time': 3.0},
{'type': 'contain', 'objects': ['bag', 'apple'], 'time': 5.0}
],
'task_result': 'success'
}
}训练层面：物理判别机制取代像素优化
传统的**最大似然估计（MLE）**方法只关心"画面对不对"，通过最小化预测帧与真实帧之间的像素差异来优化模型。这种方法的问题在于，像素相似并不等于物理正确。一个物体可能在视觉上看起来很真实，但其运动轨迹却违反了物理定律。
高德引入了物理判别机制，将优化目标从"像素相似度"转向"物理一致性"。该机制包含两个核心组件：
Proposer 模块负责根据当前任务生成物理规则清单。对于抓取任务，它会列出"夹爪必须接触物体才能抓取"、"物体受重力作用会下落"、"刚体不能相互穿透"等规则。这些规则来自物理学的基本定律，是不可违反的硬约束。Proposer 的设计基于物理引擎的约束求解器，能够自动推导出任务相关的物理约束。
Scorer 模块对模型生成的多个候选结果逐帧打分。它会检查每一帧是否违反了 Proposer 列出的物理规则，物理正确的帧获得高分，违反物理的帧被扣分。这种评分机制确保了模型学习的是真实的物理规律，而不是表面的视觉模式。Scorer 使用可微分的物理仿真器来计算物理一致性得分。
在此基础上，高德采用 Diffusion-DPO（Direct Preference Optimization）强化学习方法，将物理判别的结果作为奖励信号。物理正确的生成结果获得正向奖励，物理错误的结果受到惩罚。经过反复训练，模型自然学会了"什么动作不违反物理"，从根源上消除了低级物理错误。这种方法避免了传统强化学习中的值函数估计问题，直接优化策略的偏好排序。
# 物理判别机制实现示例
class PhysicsDiscriminator:
def __init__(self):
self.proposer = PhysicsProposer() # 生成物理规则
self.scorer = PhysicsScorer() # 评分模块
def generate_physics_checklist(self, task_description):
"""Proposer：生成物理规则清单"""
checklist = []
if 'grasp' in task_description:
checklist.append({
'rule': 'contact_before_grasp',
'description': '夹爪必须接触物体才能抓取',
'check': lambda frame: self.check_contact(frame, 'gripper', 'object')
})
checklist.append({
'rule': 'no_penetration',
'description': '夹爪不能穿透物体',
'check': lambda frame: not self.check_penetration(frame)
})
if 'lift' in task_description:
checklist.append({
'rule': 'gravity_effect',
'description': '物体受重力作用',
'check': lambda frame: self.check_gravity(frame)
})
return checklist
def score_generated_video(self, video_frames, checklist):
"""Scorer：对生成的视频评分"""
scores = []
for frame in video_frames:
frame_score = 0
for rule in checklist:
if rule['check'](frame):
frame_score += 1.0 # 符合物理规则
else:
frame_score -= 1.0 # 违反物理规则
scores.append(frame_score)
return np.mean(scores)
# Diffusion-DPO 训练流程
def train_with_physics_dpo(model, dataset):
for batch in dataset:
# 生成多个候选结果
candidates = model.generate_multiple(batch, num_candidates=4)
# 物理判别评分
checklist = discriminator.generate_physics_checklist(batch['task'])
scores = [discriminator.score_generated_video(c, checklist)
for c in candidates]
# 选择最佳和最差候选
best_idx = np.argmax(scores)
worst_idx = np.argmin(scores)
# DPO 损失：增大最佳候选概率，降低最差候选概率
loss = -log_prob(candidates[best_idx]) + log_prob(candidates[worst_idx])
loss.backward()
optimizer.step()输出层面：可微分物理状态与动作条件化推演
ABot-PhysWorld 的每一帧输出不仅包含像素信息，更重要的是包含完整的物理状态描述。这种设计支持"动作条件化推演"，即给定一个动作指令，模型能够精准计算出未来的物理状态变化。
这种能力带来了零样本泛化的可能。当遇到从未见过的物体或机器人时，模型不需要重新训练，而是根据物体的质量、摩擦系数、惯性等通用物理属性，直接推演出合理的交互结果。这是因为物理定律是普适的，不依赖于具体的物体形态。
3.3 闭环进化：从预测到执行的自我修正
ABot-World 不是一个静态模型，而是具备自我修正能力的认知基座。它支持完整的 VLA（Vision-Language-Action）闭环：预测→执行→反馈→自我修正。
具体工作流程如下：机器人根据 ABot-World 的推演结果生成动作计划，在真实环境中执行该计划，传感器记录实际执行结果，将预测与实际的误差回传给模型。模型根据这个误差信号自动调整内部参数，使得下次预测更加精准。
举例来说，机器人根据模型推演去抓取一个杯子，预测显示夹爪闭合到 15mm 就能稳固抓取。但实际执行中，由于杯子表面比预期更光滑，夹爪在 15mm 时发生了滑脱。这个失败信号立即回传给 ABot-PhysWorld，模型识别出是摩擦系数估计偏高，自动调整该类表面的摩擦参数。下次遇到类似光滑表面时，模型会预测需要更大的夹持力或更小的夹爪开度。
这种自生长、自修正、自适应的能力，意味着机器人不再完全依赖人类演示，而是能够在真实环境中持续进化。随着交互次数的增加，模型对物理世界的理解会越来越准确，这正是 AGI 时代机器人应有的"操作系统级"能力。
# VLA 闭环自我修正机制
class VLAClosedLoop:
def __init__(self, world_model, robot):
self.world_model = world_model
self.robot = robot
self.experience_buffer = []
def execute_with_feedback(self, task):
# 1. 预测阶段
predicted_trajectory = self.world_model.predict(
current_observation=self.robot.get_observation(),
task_description=task
)
# 2. 执行阶段
actual_trajectory = self.robot.execute(predicted_trajectory)
# 3. 反馈阶段
execution_result = self.robot.get_execution_result()
prediction_error = self.compute_error(
predicted_trajectory,
actual_trajectory
)
# 4. 自我修正阶段
if execution_result['success'] == False:
# 分析失败原因
failure_analysis = self.analyze_failure(
predicted_trajectory,
actual_trajectory,
execution_result
)
# 更新物理参数
if failure_analysis['type'] == 'friction_mismatch':
self.world_model.update_friction_model(
object_type=execution_result['object'],
new_friction=failure_analysis['estimated_friction']
)
elif failure_analysis['type'] == 'mass_mismatch':
self.world_model.update_mass_model(
object_type=execution_result['object'],
new_mass=failure_analysis['estimated_mass']
)
# 存储经验用于后续学习
self.experience_buffer.append({
'prediction': predicted_trajectory,
'actual': actual_trajectory,
'error': prediction_error,
'correction': failure_analysis
})
return execution_result
def continuous_improvement(self):
"""基于累积经验持续改进模型"""
if len(self.experience_buffer) >= batch_size:
batch = sample(self.experience_buffer, batch_size)
self.world_model.fine_tune(batch)
self.experience_buffer.clear()4. 实际应用：从实验室到真实世界
4.1 导盲机器狗：精准导航的实战验证
在北京亦庄机器人半马活动中，高德展示了搭载 ABot 系统的四足机器狗，它能够帮助盲人朋友走出家门，实现精准导航。这个应用场景完美体现了高德技术的实用价值，也是具身智能从实验室走向真实世界的重要里程碑。
导盲任务对导航精度要求极高。机器狗不仅要规划出一条可行路径，还要实时感知环境变化（行人、车辆、障碍物），做出安全决策。更重要的是，它要理解城市环境的语义信息：人行横道在哪里、红绿灯状态如何、哪里有台阶需要提醒。这些看似简单的任务，对机器人来说却是巨大的挑战。
高德的 POI 数据和语义地图在这里发挥了关键作用。机器狗知道"前方 20 米是人行横道，当前红灯，需要等待"，而不是简单地"前方有障碍物，停止"。这种语义理解能力，使得机器狗的行为更符合人类的预期，用户体验也更好。导盲机器狗的成功部署，证明了 ABot 系统在复杂真实环境中的可靠性和实用性。
4.2 室内外无缝衔接：BridgeNav 解决最后一公里
高德还推出了 BridgeNav 框架，专门解决从室外到室内的"最后一公里"导航问题。这是一个长期被忽视但极其重要的场景：外卖配送、快递投递、机器人接待等应用，都需要机器人从室外街道精确进入建筑物内部。
传统方法依赖精确的 GPS 坐标或预先构建的语义地图，但这些信息在实际场景中往往不可用或不准确。GPS 精度通常只能到 5-10 米，无法指导机器人找到具体的入口。而预先构建语义地图成本高昂，且难以应对环境变化。每次建筑物装修、店铺更换，地图就需要重新采集，维护成本极高。
BridgeNav 采用纯视觉驱动的方法，机器人只需要自车视角的观测图像和简单的文字指令（如"去星巴克"），就能完成从室外到室内的导航。系统包含三个核心模块：
潜在意图推断模块（Latent Intention Inference）：根据机器人与目标的距离，动态调整注意力焦点。远距离时关注全局图像与指令的匹配，判断目标是否在视野内；中距离时锁定显眼的标志物（如招牌），确定行进方向；近距离时精确定位入口或门，避免"临门找不到门"的尴尬。这种分层注意力机制模拟了人类导航的认知过程。
光流引导的动态感知模块（Optical Flow Guided Perception）：让机器人理解"自己动一下，眼前的画面会怎么变"。通过轻量级光流估计网络 RAFT 计算连续帧之间的密集光流场，筛选出受运动影响最大的区域进行重点学习。这种"想象未来"的能力，帮助机器人提前预判，减少导航偏差。动态感知使得机器人能够在移动中持续优化路径。
轨迹条件视频生成（Trajectory-Conditioned Video Generation）：为了解决训练数据噪声大的问题，BridgeNav 采用生成式扩散模型合成物理对齐的数据。先用单目几何估计构建局部占用网格，用 *A 算法**规划无障碍路径，再用扩散模型生成符合物理约束的视频序列。这种方法生成的数据质量高、覆盖面广，有效补充了真实数据的不足。
# BridgeNav 核心模块实现
class BridgeNav:
def __init__(self):
self.intention_module = LatentIntentionInference()
self.perception_module = OpticalFlowGuidedPerception()
self.multimodal_llm = Qwen2_5_VL_3B()
def navigate(self, observation, instruction):
"""执行导航决策"""
# 1. 潜在意图推断：确定当前应该关注什么
salient_regions = self.intention_module.infer(
observation,
instruction,
distance_to_target=self.estimate_distance(observation, instruction)
)
# 2. 动态感知：预测运动对视觉的影响
future_changes = self.perception_module.predict_changes(
current_observation=observation,
candidate_actions=self.generate_candidate_actions()
)
# 3. 多模态融合：整合视觉、语言、动作信息
decision = self.multimodal_llm.decide(
visual_tokens=self.encode_visual(observation, salient_regions),
language_tokens=self.encode_language(instruction),
dynamic_tokens=future_changes
)
return decision['waypoints']
def estimate_distance(self, observation, instruction):
"""估计与目标的距离，用于调整注意力策略"""
target_in_view = self.detect_target(observation, instruction)
if not target_in_view:
return 'far' # 目标不在视野内
target_size = target_in_view['bbox_area'] / observation.size
if target_size > 0.3:
return 'near' # 目标占据大部分视野
elif target_size > 0.1:
return 'medium' # 目标清晰可见
else:
return 'far' # 目标较小
class LatentIntentionInference:
def infer(self, observation, instruction, distance_to_target):
"""根据距离动态调整注意力"""
if distance_to_target == 'far':
# 远距离：关注全局匹配
return self.global_matching(observation, instruction)
elif distance_to_target == 'medium':
# 中距离：关注标志物（招牌）
return self.detect_signage(observation, instruction)
else:
# 近距离：关注入口
return self.detect_entrance(observation, instruction)在 BridgeNav 数据集上的实验表明，该方法在成功率和路径效率上都显著优于现有基线方法。更重要的是，它不依赖任何外部先验信息，具有很强的实用性。
4.3 跨机器人平台泛化：真正的零样本能力
ABot-PhysWorld 最令人印象深刻的能力是跨机器人平台的零样本泛化。在 EZS-Bench 基准测试中，模型面对的是完全未见过的机器人形态、任务类型和场景组合。
例如，模型在训练时只见过单臂 Franka 机器人抓取刚性物体，但在测试时需要控制双臂机器人折叠毛巾。这涉及到完全不同的运动学结构（单臂 vs 双臂）、物体属性（刚性 vs 柔性）和任务逻辑（抓取 vs 折叠）。传统方法在这种情况下几乎完全失效，因为它们学习的是特定机器人-任务组合的模式，而不是通用的物理规律。
ABot-PhysWorld 却能够生成物理合理的折叠动作序列：两个机械臂协调运动，避免碰撞；毛巾在抓取点产生真实的形变；折叠过程中保持接触，没有穿透或悬浮。这是因为模型理解了布料的柔性力学、双臂协调的约束条件、以及折叠任务的物理本质。
类似的零样本能力在多个场景中得到验证：
可变形物体操作：双臂折叠毛巾，布料形变真实，双臂运动协调流畅。模型理解了柔性材料的应力-应变关系，能够预测布料在不同抓取点的形变模式。
精细操作：堆叠杯子、搭建积木、放置刀具，不同形状、重量、摩擦系数的物体都能正确处理。模型能够根据物体的物理属性调整抓取力度和放置策略。
铰接物体交互：打开柜门，正确施加旋转力矩，运动遵循铰链约束。模型理解了旋转关节的运动学约束，能够生成符合约束的轨迹。
流体交互：双臂倒水，倾斜角度和时机控制准确，液体转移过程视觉连贯。虽然流体模拟极其复杂，但模型学会了液体流动的基本规律。
清洁任务：擦拭污渍，保持工具与表面接触，系统性覆盖目标区域。模型理解了接触力的维持和路径规划的策略。
多场景泛化：在不同背景、光照、物体变化下，稳定完成水果分拣任务。模型的物理推理能力不受视觉外观变化的干扰。
这些能力的实现，依赖于模型对物理规律的深刻理解。它不是记忆训练数据中的具体案例，而是学会了质量、惯性、摩擦、弹性等物理属性如何影响物体的运动。这种通用的物理知识，可以迁移到任何新的机器人-任务-场景组合中，这才是真正的智能。
5. ABot-Claw：统一的机器人操作系统
当前具身智能系统面临一个结构性断层：VLA（视觉-语言-动作）架构赋予机器人强大的感知与直觉响应能力，但其开环特性与长期记忆建模的缺失，使其难以应对复杂长程任务。引入 System 2 认知机制的代理框架虽能改进规划与推理，却多运行于封闭沙箱，依赖预定义工具集，缺乏对真实系统的直接控制。
阿里巴巴 AMAP CV Lab 推出的 ABot-Claw，以 OpenClaw 本地化运行时为基础执行核心，通过三项关键技术整合，构建从高层意图到低层动作的端到端闭环，形成可在开放动态环境中持续学习、适应与进化的具身智能框架。
视觉-语言-动作-评判（VLAC）闭环机制：在传统 VLA 基础上增加评判模块，实现在线状态评估与动态策略调整。系统不再是"执行完就结束"，而是持续监控执行效果，根据反馈实时调整策略。这种闭环机制使得机器人能够应对执行过程中的不确定性，当初始计划失败时自动触发重规划。
跨本体多模态记忆系统：统一视觉、语言与状态信息，支持长时域上下文保持。不同机器人平台共享同一记忆空间，可以跨时间、空间与本体类型检索环境上下文。这种共享记忆机制使得多机器人系统能够协同工作，一个机器人的经验可以被其他机器人直接利用。
弹性多智能体调度架构：基于路由表的任务隔离、并行执行与即插即用设备协同。系统作为集中式运行时，维护动态设备池，追踪各机器人的可用性、任务进度与状态。用户请求可分解为兼容并行执行的子任务，跨多机器人分发，支持执行过程中的动态切换与跨本体协作。
5.1 技术架构详解
异构本体整合（Heterogeneous Embodiment Integration）
不同机器人平台的控制接口差异显著——机械臂依赖笛卡尔规划，移动平台暴露导航原语，人形机器人需要全身运动控制。ABot-Claw 引入统一本体接口，通过 ROS 适配器将各平台原生功能映射为共享技能集（导航、观测、巡检、操作原语），实现高层规划与硬件细节的解耦。
系统作为集中式运行时，维护动态设备池，追踪各机器人的可用性、任务进度与状态。用户请求可分解为兼容并行执行的子任务，跨多机器人分发。任务路由综合考量能力匹配、空间位置、当前负载与任务优先级四维度，支持执行过程中的动态切换与跨本体协作。
视觉中心的多模态记忆（Vision-Centric Multimodal Memory）
针对几何地图与自然语言对齐困难、文本日志丢失视觉细节的问题，系统构建以视觉为核心的多模态记忆，组织为四类实体：
图像-语义记忆（Image-Semantic Memory）：保留视觉嵌入，支持开放词汇的跨模态检索。当用户询问"红色的杯子在哪里"时，系统可以直接在视觉记忆中搜索，而不需要预先定义"红色杯子"这个类别。
关键帧记忆（Keyframe Memory）：压缩探索轨迹为带相机参数与时间戳的稀疏快照。这种压缩方式既节省存储空间，又保留了足够的信息用于后续检索和重定位。
物体中心记忆（Object-Centric Memory）：记录类别、观测时间、来源本体及 3D 位姿，支撑交互任务。每个物体都有完整的观测历史，包括何时、何地、被哪个机器人观测到。
地点锚点记忆（Place Anchor Memory）：将语义位置（如厨房、入口）注册为可导航坐标。这种语义-几何的绑定，使得机器人能够理解"去厨房"这样的自然语言指令。
所有连接机器人共享同一记忆空间，支持跨时间、空间与本体类型的环境上下文检索。检索结果统一归一化为包含语义类别、置信度、视觉证据与全局坐标系 3D 位姿的标准格式，可直接输入导航栈或运动规划器。
基于通用评判模型的闭环反馈（Closed-Loop Feedback with Universal Critic）
为应对执行不确定性，系统配备评判模块（Critic Module），以通用奖励模型实例化，接收任务指令与当前观测，输出标量进度信号。该信号驱动三类决策：
• 达标则标记完成并推进：当进度信号达到阈值，系统认为当前子任务已完成，自动推进到下一个子任务。
• 有进展则局部微调：调整目标位姿、更新视角、重试短序列。这种微调避免了完全重规划的开销。
• 停滞或倒退则触发重规划：可能调用共享记忆重新查询，生成新的执行计划。
执行轨迹与评判分数记录为结构化经验，反馈至运行时，形成从执行到评估再到未来决策的闭环。这种经验积累使得系统能够持续改进，避免重复犯错。
5.2 工程实现
系统采用三层解耦设计：
OpenClaw 层：负责人机交互与高层决策，将自然语言指令解析为结构化任务表示，输出可复现、可追溯的可执行 Python 脚本。这种脚本化的设计使得任务执行过程完全透明，便于调试和优化。
共享服务层：托管计算密集且可复用的感知（YOLO-World）、抓取感知（AnyGrasp）、空间记忆、任务评估等模块，支持 VLA、VLN、WAM 等高级模型通过标准化接口接入。这种服务化的架构避免了重复计算，提高了系统效率。
机器人层：通过 ROS/ROS2 与具体硬件平台对接，隔离驱动、传感器与底层控制，保持上层接口稳定。这种分层设计使得系统能够快速适配新的机器人平台。
该架构允许各模块独立演进，新本体通过能力描述注册即可接入，新模型通过服务扩展即可集成，无需修改控制逻辑或调度框架。这种即插即用的设计大大降低了系统维护成本。
# ABot-Claw 核心架构实现
class ABotClaw:
def __init__(self):
# OpenClaw 层：高层决策
self.task_parser = OpenClawTaskParser()
# 共享服务层
self.perception_service = YOLOWorldService()
self.grasp_service = AnyGraspService()
self.memory_service = MultimodalMemoryService()
self.critic_service = UniversalCriticModel()
# 机器人层：设备池
self.robot_pool = DynamicRobotPool()
def execute_task(self, natural_language_instruction):
"""执行自然语言任务指令"""
# 1. 解析任务为结构化表示
task_plan = self.task_parser.parse(natural_language_instruction)
# 2. 任务分解与路由
subtasks = self.decompose_task(task_plan)
robot_assignments = self.route_tasks(subtasks)
# 3. 并行执行与监控
execution_results = []
for subtask, robot_id in robot_assignments:
result = self.execute_with_feedback(subtask, robot_id)
execution_results.append(result)
return execution_results
def execute_with_feedback(self, subtask, robot_id):
"""带反馈的任务执行"""
robot = self.robot_pool.get_robot(robot_id)
max_retries = 3
for attempt in range(max_retries):
# 执行子任务
trajectory = robot.execute(subtask)
# 评判模块评估进度
progress_score = self.critic_service.evaluate(
task=subtask,
observation=robot.get_observation(),
trajectory=trajectory
)
if progress_score >= threshold_complete:
# 任务完成
self.memory_service.store_success(subtask, trajectory)
return {'status': 'success', 'trajectory': trajectory}
elif progress_score >= threshold_progress:
# 有进展，局部微调
adjusted_subtask = self.local_adjustment(
subtask, trajectory, progress_score
)
subtask = adjusted_subtask
else:
# 停滞或倒退，重规划
context = self.memory_service.retrieve_context(subtask)
subtask = self.replan(subtask, context, trajectory)
# 多次尝试失败
return {'status': 'failed', 'reason': 'max_retries_exceeded'}
def route_tasks(self, subtasks):
"""任务路由：考虑能力、位置、负载、优先级"""
assignments = []
for subtask in subtasks:
# 获取所有可用机器人
available_robots = self.robot_pool.get_available_robots()
# 计算每个机器人的适配分数
scores = []
for robot in available_robots:
score = (
0.4 * self.capability_match(robot, subtask) +
0.3 * self.spatial_proximity(robot, subtask) +
0.2 * (1 - robot.current_load) +
0.1 * subtask.priority
)
scores.append((robot.id, score))
# 选择最佳机器人
best_robot_id = max(scores, key=lambda x: x[1])[0]
assignments.append((subtask, best_robot_id))
return assignments
class MultimodalMemoryService:
"""多模态记忆服务"""
def __init__(self):
self.image_semantic_memory = ImageSemanticMemory()
self.keyframe_memory = KeyframeMemory()
self.object_memory = ObjectCentricMemory()
self.place_memory = PlaceAnchorMemory()
def retrieve_context(self, task):
"""检索任务相关的上下文"""
# 跨模态检索
relevant_images = self.image_semantic_memory.search(task.description)
relevant_objects = self.object_memory.search(task.target_objects)
relevant_places = self.place_memory.search(task.target_location)
# 统一格式
context = {
'visual_evidence': relevant_images,
'object_poses': relevant_objects,
'navigable_coordinates': relevant_places,
'timestamp': time.now()
}
return context以下是 ABot-Claw 的实际代码实现，展示了 VLAC 评判服务和空间记忆服务的真实工程实现：
# service_layer/VLAC/main.py - VLAC 评判服务核心实现
"""VLAC Critic Service - 视觉-语言-动作-评判闭环服务"""
from __future__ import annotations
import base64, io, time, threading
from contextlib import asynccontextmanager
from pathlib import Path
from typing import Any, Dict, List, Optional
import requests, torch
from fastapi import FastAPI, HTTPException
from PIL import Image
from pydantic import BaseModel, Field
from evo_vlac import GAC_model
SERVICE_VERSION = "0.1.0"
MODEL_PATH = os.getenv("VLAC_MODEL_PATH", "./models")
CRITIC: Optional[GAC_model] = None
INFER_LOCK = threading.Lock()
class CriticRequest(BaseModel):
image: str = Field(..., description="当前图像 (base64/url/path)")
reference_image: str = Field(..., description="参考图像 (base64/url/path)")
task_description: str = Field(..., description="任务描述")
batch_num: int = Field(1, ge=1, le=32)
class CriticResponse(BaseModel):
critic_list: List[float] # 评判分数列表
value_list: List[float] # 价值估计列表
latency_ms: float # 推理延迟
def _normalize_image_input(image_input: str) -> Image.Image:
"""支持 URL、base64、本地路径三种图像输入方式"""
payload = image_input.strip()
if payload.startswith(("http://", "https://")):
response = requests.get(payload, timeout=15)
return Image.open(io.BytesIO(response.content)).convert("RGB")
if payload.startswith("data:image"):
payload = payload.split(",", 1)[1]
try:
image_bytes = base64.b64decode(payload, validate=True)
return Image.open(io.BytesIO(image_bytes)).convert("RGB")
except Exception:
if Path(payload).exists():
return Image.open(payload).convert("RGB")
raise ValueError("Invalid image input")
@asynccontextmanager
async def lifespan(app: FastAPI):
"""服务启动时加载 VLAC 模型"""
global CRITIC
critic = GAC_model(tag="critic")
critic.init_model(model_path=MODEL_PATH, model_type="internvl2",
device_map="cuda:0" if torch.cuda.is_available() else "cpu")
critic.temperature = 0.5
critic.top_k = 1
critic.set_config()
critic.set_system_prompt()
CRITIC = critic
yield
CRITIC = None
app = FastAPI(title="ABot-Claw VLAC Critic Service", version=SERVICE_VERSION,
lifespan=lifespan)
@app.post("/critic", response_model=CriticResponse)
def critic(req: CriticRequest) -> CriticResponse:
"""VLAC 评判接口：比较当前图像与参考图像，评估任务完成度"""
if CRITIC is None:
raise HTTPException(status_code=503, detail="Model not initialized")
start_t = time.time()
current_image = _normalize_image_input(req.image)
reference_image = _normalize_image_input(req.reference_image)
with INFER_LOCK:
critic_list, value_list = CRITIC.get_trajectory_critic(
task=req.task_description,
image_list=[reference_image, current_image],
batch_num=req.batch_num,
reverse_eval=False,
)
latency_ms = (time.time() - start_t) * 1000.0
return CriticResponse(
critic_list=[float(item) for item in critic_list],
value_list=[float(item) for item in value_list],
latency_ms=latency_ms
)# robot_layer/arm_piper/agent_server/robot_sdk/memory_sdk.py
# 空间记忆 SDK - 机器人层封装
"""通过 Spatial Memory Hub HTTP 服务完成物体记忆的写入与查询"""
from __future__ import annotations
from dataclasses import dataclass
from typing import Any, Dict, List, Optional
import requests
@dataclass
class Pose:
"""6-DoF 位姿表示"""
x: float = 0.0
y: float = 0.0
z: float = 0.0
roll: float = 0.0
pitch: float = 0.0
yaw: float = 0.0
frame_id: str = "map"
def to_dict(self) -> Dict[str, Any]:
return {
"x": self.x, "y": self.y, "z": self.z,
"roll": self.roll, "pitch": self.pitch, "yaw": self.yaw,
"frame_id": self.frame_id
}
class MemorySDK:
"""Spatial Memory Hub 物体记忆封装 - 提供写入与查询能力"""
def __init__(self, base_url: Optional[str] = None, request_timeout: float = 10.0):
self._base_url = (base_url or
os.environ.get("SPATIAL_MEMORY_HUB_URL") or
"<http://localhost:8012>").rstrip("/")
self._timeout = request_timeout
def _post(self, path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
resp = requests.post(f"{self._base_url}{path}", json=payload,
timeout=self._timeout)
resp.raise_for_status()
return resp.json()
def upsert_object(self, object_name: str, robot_id: str, robot_type: str,
robot_pose: Pose | Dict[str, Any],
object_pose: Pose | Dict[str, Any],
detect_confidence: float = 0.0,
image_b64: Optional[str] = None) -> Dict[str, Any]:
"""写入或更新一个物体记忆
Args:
object_name: 物体名称，如 "red_cup"
robot_id: 机器人 ID，如 "piper_001"
robot_type: 机器人类型，如 "arm" / "humanoid" / "quadruped"
robot_pose: 观测时机器人位姿
object_pose: 物体位姿
detect_confidence: 检测置信度 (0~1)
image_b64: 可选，base64 编码的物体图像
Returns:
dict: {"ok": True, "id": "obj_abc123"}
"""
payload: Dict[str, Any] = {
"object_name": object_name,
"robot_id": robot_id,
"robot_type": robot_type,
"robot_pose": robot_pose.to_dict() if isinstance(robot_pose, Pose) else robot_pose,
"object_pose": object_pose.to_dict() if isinstance(object_pose, Pose) else object_pose,
"detect_confidence": detect_confidence,
}
if image_b64 is not None:
payload["image"] = image_b64
data = self._post("/memory/object/upsert", payload)
if not data.get("ok"):
raise RuntimeError(f"upsert_object 失败: {data}")
return data
def query_object(self, name: str, n_results: int = 5) -> List[Dict[str, Any]]:
"""按名称查询物体记忆
Args:
name: 要查询的物体名称（支持模糊匹配）
n_results: 最多返回条数
Returns:
list[dict]: 匹配的物体记录列表，包含 name/pose/confidence 等字段
"""
data = self._post("/query/object", {"name": name, "n_results": n_results})
return data.get("results", [])# service_layer/SpatialMemory/app/services/memory_service.py
# 空间记忆服务核心实现
"""统一的机器人记忆服务 - 支持物体/地点/关键帧/语义帧四类记忆"""
from __future__ import annotations
import base64, io, time, uuid
from pathlib import Path
from typing import Any, Optional
import numpy as np
from PIL import Image
from app.config import settings
from app.embeddings import cosine_similarity, decode_image_input, image_embedding, text_embedding
from app.storage import SqliteStore
class MemoryService:
def __init__(self, store: SqliteStore):
self.store = store
settings.data_dir.mkdir(parents=True, exist_ok=True)
settings.image_dir.mkdir(parents=True, exist_ok=True)
def _save_image(self, image: Image.Image, memory_id: str) -> str:
"""保存图像证据到本地"""
path = settings.image_dir / f"{memory_id}.jpg"
image.save(path, format="JPEG", quality=90)
return str(path)
def upsert_object(self, req: ObjectMemoryUpsertRequest) -> dict[str, Any]:
"""写入或更新物体记忆"""
ts = req.timestamp or time.time()
memory_id = req.object_id or f"obj_{uuid.uuid4().hex[:12]}"
# 处理图像并提取特征
image_path: Optional[str] = None
emb = np.array([], dtype=np.float32)
if req.image:
image = decode_image_input(req.image)
image_path = self._save_image(image, memory_id)
emb = image_embedding(image, settings.embedding_dim)
# 构建记忆条目
payload = {
"id": memory_id,
"memory_type": "object",
"name": req.object_name,
"robot_id": req.robot_id,
"robot_type": req.robot_type,
"timestamp": ts,
"x": req.object_pose.x, "y": req.object_pose.y, "z": req.object_pose.z,
"yaw": req.object_pose.yaw,
"robot_pose": req.robot_pose.model_dump(),
"image_path": image_path,
"confidence": req.detect_confidence,
"embedding": emb.tolist(),
}
self.store.insert_memory(payload)
return {"ok": True, "id": memory_id}# openclaw_layer/MISSION.md - 多机器人任务调度规则
"""
ABot-Claw 任务分类与机器人选择策略：
可用机器人：
- Piper: 固定式机械臂，用于可靠的局部操作
- Unitree G1: 人形机器人，用于直立交互和全身任务
- Unitree Go2: 四足机器人，用于移动、巡逻、检查和远程感知
任务分类规则：
1. 操作优先任务 (pick/grasp/place) → Piper
2. 全身或人机交互任务 (interact/handover) → G1
3. 移动、巡逻、检查任务 (navigate/patrol/scout) → Go2
4. 跨机器人工作流 → 分阶段路由到合适平台
核心操作规则：
- 不要直接跳到代码，先决定哪个机器人应该拥有任务
- 在提出控制代码之前使用 SDK 发现机制
- 当先前观察、物体、地点或语义场景可能有帮助时使用记忆
- 对硬件保持谨慎 - 没有模拟器安全缓冲
"""# openclaw_layer/skills/abotclaw-progress-critic/SKILL.md
# ABot-Claw 进度评判技能
"""
使用已部署的 VLAC 风格评判服务来评估任务进度、比较当前观测与参考图像、
从机器人相机帧判断任务完成情况。
服务契约：
- 端点: POST /critic
- 必需输入:
* image: 当前帧 (base64/url/path)
* reference_image: 参考帧 (base64/url/path)
* task_description: 任务描述
使用场景：
- 任务进度估计
- 任务完成验证
- 检测失败或未改变的任务状态
- 决定机器人是否应该继续、重试或停止
标准工作流：
1. 使用 SDK 发现学习目标机器人如何暴露相机帧
2. 从 Piper/G1/Go2 捕获当前帧
3. 获取代表期望状态的参考图像
4. 编写匹配预期目标的任务描述
5. 在一个请求中调用评判服务
6. 将响应解释为任务控制的监督信号
示例请求：
curl -X POST http://SERVICE_HOST:8014/critic \
-H 'Content-Type: application/json' \
-d '{
"image": "<current_frame>",
"reference_image": "<reference_frame>",
"task_description": "把碗放回白色收纳盒中"
}'
如何使用结果：
- 如果评判指示强完成 → 停止或返回成功
- 如果评判指示部分进展 → 继续
- 如果评判指示失败或无变化 → 重试、重新规划或寻求帮助
"""上述代码展示了 ABot-Claw 的完整技术栈：从底层的机器人 SDK 封装（MemorySDK 提供统一的记忆读写接口），到中层的共享服务（VLAC 评判服务、空间记忆服务），再到顶层的任务调度规则（MISSION.md 定义的多机器人选择策略）。这种分层设计使得系统具有极强的可扩展性和可维护性。
特别值得注意的是，VLAC 评判服务采用了线程锁机制（INFER_LOCK）来保证模型推理的线程安全，支持多种图像输入格式（URL、base64、本地路径），并返回详细的评判分数和价值估计。空间记忆服务则通过图像特征提取和向量检索，实现了高效的物体记忆查询，支持模糊匹配和多模态检索。
5.3 技术价值与未来展望
ABot-Claw 的核心贡献在于工程架构层面的系统性整合：将 OpenClaw 从软件任务编排扩展至真实世界具身操作，通过异构本体抽象、持久视觉记忆与在线评判反馈的紧耦合，实现高层认知决策与低层物理执行的统一。
该框架为构建真正自主的通用机器人系统提供了可扩展的工程范式，指向一条务实路径：通过架构创新有效组织现有的感知、推理与控制能力，在开放环境中实现持续进化。与追求单一模型的端到端学习不同，ABot-Claw 采用模块化设计，使得各个组件可以独立优化和替换，降低了系统维护成本。
项目已在 GitHub 开源：https://github.com/amap-cvlab/ABot-Claw
6. 开源战略：构建具身智能生态
6.1 开源 ABot-World：降低行业门槛
高德宣布将 ABot-World 开源，这是一个具有战略意义的决策。开源不仅是技术分享，更是生态构建的关键一步。
对于研究者和开发者来说，ABot-World 提供了一个统一的、物理合规的、可进化的机器人世界模型操作系统。他们不需要从零开始构建数据生产流程、训练物理对齐模型，而是可以直接在这个平台上开发自己的应用。这大大降低了具身智能研究和应用的门槛，使得更多的创新者能够参与到这个领域中来。
对于整个行业来说，统一的底层平台意味着资源不再分散在各自的"造轮子"上，而是集中在更高层次的创新。数据不够、仿真不真的问题被系统性缓解，行业发展速度将显著加快。这种协同效应将推动整个具身智能领域进入快速发展期。
对于高德自身来说，开源策略带来的是生态位的确立。当越来越多的开发者在 ABot-World 上构建应用，这个平台就成为了事实上的行业标准。高德自然也就站在了具身智能赛道最核心的位置，类似于 Linux 在操作系统领域、TensorFlow 在深度学习领域的地位。
6.2 发布 EZS-Bench：建立评估标准
除了开源模型，高德还发布了 EZS-Bench（Embodied Zero-Shot Benchmark），这是首个真正的零样本评估基准。
现有的评估基准大多存在训练-测试数据泄露问题，模型可能只是记住了测试集中的模式，而不是真正学会了泛化能力。EZS-Bench 通过构造完全未见过的机器人-场景-任务组合，确保评估的是模型的真实泛化能力。这种严格的评估方式，迫使研究者关注模型的本质能力，而不是过拟合测试集。
评估方法也更加科学。传统方法通常让模型自己评估自己生成的结果，存在明显的偏差。EZS-Bench 采用解耦的双模型评分协议：Qwen3-VL 生成任务特定的物理检查清单，Gemini 3 Pro 通过思维链推理对视频评分。两个模型分工明确，避免了自我评估的偏差。
物理检查清单的设计也很巧妙。对于抓取任务，清单包含"夹爪是否穿透物体？"、"是否遵守重力？"、"接触是否真实？"等问题。其中 30-50% 是负面问题（预期答案为"否"），防止模型通过简单的"全选是"策略获得高分。这种对抗性设计确保了评估的可靠性。
# EZS-Bench 评估流程
class EZSBench:
def __init__(self):
self.checklist_generator = Qwen3_VL() # 生成物理检查清单
self.video_scorer = Gemini3_Pro() # 评分模型
def evaluate(self, generated_video, task_description):
"""评估生成的视频"""
# 1. 生成物理检查清单
checklist = self.checklist_generator.generate_checklist(task_description)
# 示例清单：
# - 夹爪是否在接触物体后才闭合？（正面问题）
# - 物体是否穿透了桌面？（负面问题）
# - 运动是否违反重力？（负面问题）
# - 接触点是否产生了合理的形变？（正面问题）
# 2. 逐帧评分
frame_scores = []
for frame in generated_video:
score = self.video_scorer.score_frame(
frame=frame,
checklist=checklist,
use_chain_of_thought=True # 使用思维链推理
)
frame_scores.append(score)
# 3. 计算综合指标
physical_fidelity = np.mean([s['physical'] for s in frame_scores])
temporal_coherence = self.compute_temporal_coherence(frame_scores)
action_alignment = self.compute_action_alignment(
generated_video,
task_description
)
return {
'physical_fidelity': physical_fidelity,
'temporal_coherence': temporal_coherence,
'action_alignment': action_alignment,
'domain_score': (physical_fidelity + temporal_coherence + action_alignment) / 3
}
def compute_temporal_coherence(self, frame_scores):
"""计算时序连贯性"""
# 检查相邻帧之间的物理状态是否平滑过渡
coherence_scores = []
for i in range(len(frame_scores) - 1):
state_diff = abs(frame_scores[i+1]['state'] - frame_scores[i]['state'])
# 物理状态应该连续变化，不应该突变
coherence = 1.0 / (1.0 + state_diff)
coherence_scores.append(coherence)
return np.mean(coherence_scores)EZS-Bench 的发布，为具身智能领域提供了一个公正、严格、可复现的评估标准。研究者可以在统一的基准上比较不同方法，推动整个领域向更高的目标迈进。
7. 总结
回顾高德的技术演进路径，从地图导航到具身智能并非偶然的跨界，而是能力的自然延伸。地图时代积累的空间理解、数据处理、实时更新能力，在具身智能时代找到了新的应用场景。这种演进不是技术的断裂，而是能力的升级和重组。
高德的角色本质上没有变化：以前是连接人和现实世界的基础设施，现在是连接机器人和物理世界的基础设施。只是服务对象从人类扩展到了机器，能力边界从二维地图扩展到了三维物理世界。这种角色的延续性，使得高德能够将多年积累的数据资产和技术能力无缝迁移到新的领域。
ABot 全栈技术体系的推出，标志着具身智能领域从"百花齐放"走向"生态收敛"的转折点。当底层基础设施开始成型，行业发展就会迅速加速。就像 TCP/IP 统一了网络连接方式，Linux 成为操作系统底座，云计算把算力变成公共资源，ABot-World 正在成为具身智能的统一底座。这种基础设施的标准化，将释放巨大的创新潜力。
参考文献
https://mp.weixin.qq.com/s/CCzmShDg1KsHECGHszm26g
https://mp.weixin.qq.com/s/qF4tbuV16GkTqGDPitq_Ug
https://github.com/amap-cvlab/ABot-Navigation
https://github.com/amap-cvlab/ABot-PhysWorld
https://github.com/amap-cvlab/ABot-Claw/
