NVIDIA Cosmos 3 深度实战：当世界模型重塑 Physical AI——从 MoT 架构到机器人策略的生产级完全指南（2026）

前言

2026 年 6 月 4 日，台北 GTC 大会上，黄仁勋发布了 Cosmos 3——全球首个完全开源的全模态物理 AI 世界模型。消息一出，技术社区的反应不是"又一个 SOTA 模型"，而是"世界模型的 Android 时刻真的来了"。

为什么这么说？因为过去几年，Physical AI（物理人工智能）领域面临一个根本性困境：训练数据极度稀缺。长尾场景（corner case）——比如自动驾驶中突然闯入的行人、机器人操作中从未见过的物体姿态——靠真实采集几乎不可能穷尽。仿真工具（SIMUM、Isaac Sim）能生成数据，但物理逼真度和场景多样性始终差一口气。

Cosmos 3 的出现，给出了一个新的方向：不再靠手工建模物理规则，而是用大规模多模态数据训练一个"懂物理世界如何运作"的模型，让它自己生成高保真、可控的合成训练样本。

本文从程序员视角出发，深入剖析 Cosmos 3 的架构设计、MoT 双塔机制、统一动作表征、多模态位置编码，以及如何在 Hugging Face 生态下实际调用 Cosmos 3 进行推理和视频生成。文末附生产级部署建议和性能基准数据。

一、为什么世界模型是 Physical AI 的下一个基础设施

1.1 Physical AI 的数据困境

在讨论 Cosmos 3 之前，有必要搞清楚为什么这个方向值得关注。

传统 AI 的核心战场是数字世界——文本、图像、语音。这些领域的数据量大、获取成本相对低、标注相对标准化。但 Physical AI（机器人、自动驾驶、智能工厂）处理的是物理世界，数据特征完全不同：

获取成本极高：真实机器人操作数据需要硬件平台、场地、人员，每小时采集成本从几百到几千美元不等。

长尾分布严重：日常操作（抓取已知物体）数据多，危险场景（碰撞、跌落）数据少到几乎没有。

跨具身泛化困难：四足机器人数据不能直接用于机械臂，自动驾驶数据对服务机器人参考价值有限。

物理一致性要求高：合成数据如果违反物理规律（重力不对、碰撞不对），训练出来的策略模型完全不可用。

这些问题叠加在一起，导致 Physical AI 的发展速度远落后于语言和视觉领域。

1.2 从仿真工具到世界模型

过去十年，行业的主流思路是"仿真优先"：用物理引擎（Mujoco、PyBullet、PhysX）构建虚拟环境，在里面生成训练数据。这条路走到今天，瓶颈已经很明显了：

• 物理引擎的逼真度上限就是人类建模的上限
• 新场景需要新建模，成本和周期都很高
• 仿真到现实（Sim2Real）的 gap 始终存在

世界模型（World Model）的思路完全不同：不是让人类去建模物理规则，而是训练一个大模型，让它自己从海量多模态数据中学习"世界如何运转"。这个模型学到的不只是视觉外观，还有物体之间的关系、运动规律、因果链条。

Cosmos 3 的核心定位就是这个方向：一个统一的、多模态的、能同时理解世界并生成世界状态的世界模型，专门服务于 Physical AI 的训练和推理。

二、Cosmos 3 核心架构：Omnimodal World Model

2.1 什么是全模态（Omnimodal）

Cosmos 3 的第一个关键词是 Omnimodal（全模态）。它不是简单地把多个单模态模型拼接在一起，而是用同一个模型同时处理和生成：文本（Language）、图像（Image）、视频（Video）、音频（Audio）、动作（Action）五种模态。

这五种模态在物理世界中本来就是共同出现的：

• 一杯水被打翻 → 画面变化（视频）+ 声音（音频）+ 空间位移（动作）+ 语言描述（文本）

传统方法通常只关注其中一两种，而 Cosmos 3 把它们全部纳入统一建模。更重要的是，Cosmos 3 不仅是"输入多种模态"，而是"理解、生成、推理、预测"全部在一个框架内完成。

2.2 架构总览：双路径统一框架

Cosmos 3 的整体架构可以用一张图来概括（基于论文描述的架构总结）：

输入端
├── 文本 Token ──→ 语言编码器（使用预训练 VLM 的 Embedding 层）
├── 图像 Token ──→ ViT 编码器（Vision Transformer）
├── 视频 Token ──→ ViT 编码器（时空维度）
├── 音频 Token ──→ 音频编码器
└── 动作 Token ──→ 动作编码器（域感知投影层）

         ↓ 统一 Token 序列

┌──────────────────────────────────────────────────────────┐
│           Mixture-of-Transformers (MoT) 核心             │
│                                                          │
│  ┌─────────────────────────────────────────────────────┐ │
│  │              推理塔（Reasoner Tower）               │ │
│  │   自回归 Transformer，处理 AR 子序列                │ │
│  │   输入：文本+图像+视频 的语义 Token                 │ │
│  │   输出：推理结果、世界理解                          │ │
│  └─────────────────────────────────────────────────────┘ │
│                       ↕ 双流联合注意                      │
│  ┌─────────────────────────────────────────────────────┐ │
│  │              生成塔（Generator Tower）              │ │
│  │   扩散 Transformer，处理 Diffusion 子序列           │ │
│  │   输入：视频+音频+动作 的生成 Token                 │ │
│  │   输出：高保真视频、音频、动作序列                  │ │
│  └─────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────┘

         ↓ 解码

输出端（根据任务模式灵活切换）
├── 视觉-语言模型模式（VLM）
├── 文本→图像生成模式（T2I）
├── 图像→视频生成模式（I2V）
├── 视频→视频（未来预测）模式
└── 世界-动作模型模式（WAM / Policy）

这个架构的核心创新是 MoT（Mixture-of-Transformers）双塔设计，将理解能力（推理塔）和生成能力（生成塔）统一在同一个 Transformer 框架中，但使用两组不同的参数。

三、MoT 架构：为什么理解和生成要放在一起

3.1 自回归 vs 扩散：两种范式的根本差异

在深入 MoT 之前，先理解为什么需要两个不同的塔。

自回归模型（Autoregressive / AR）：按顺序生成 token，每一步基于前文预测下一个。最适合处理离散 token——文字、代码、动作序列。优势在于推理能力强，能做复杂的多步推理和逻辑推导。GPT 系列、LLaMA 都是 AR 模型。

扩散模型（Diffusion）：从随机噪声开始，逐步去噪生成连续信号。最适合处理高维连续信号——图像像素、视频帧、音频波形。优势在于生成质量高，保真度好。Stable Diffusion、Sora 都是扩散模型。

对于物理世界建模，两种能力缺一不可：

• 推理：需要理解"为什么杯子会倒"（因果推理）
• 生成：需要生成"杯子倒下的高清慢动作视频"（高质量视觉生成）

3.2 MoT 双塔的工程实现

Cosmos 3 的 MoT 架构将两种范式融合在同一套 Transformer 层中：

# 简化版 MoT 层结构（基于论文描述的架构示意）
class MoTTransformerLayer:
    """
    每个 MoT Transformer 层包含两组独立参数：
    - 推理塔参数（Reasoner）：处理 AR 子序列的 token
    - 生成塔参数（Generator）：处理 Diffusion 子序列的 token
    两组参数独立，但通过双流联合注意机制交互。
    """

    def __init__(self, hidden_dim, num_heads):
        # 推理塔（AR 分支）
        self.reasoner_attn = MultiHeadAttention(hidden_dim, num_heads)
        self.reasoner_ffn = FeedForwardNetwork(hidden_dim)

        # 生成塔（Diffusion 分支）
        self.generator_attn = MultiHeadAttention(hidden_dim, num_heads)
        self.generator_ffn = FeedForwardNetwork(hidden_dim)

        # 共享归一化（保持两塔输出在同一尺度）
        self.norm1 = LayerNorm(hidden_dim)
        self.norm2 = LayerNorm(hidden_dim)

    def forward(self, ar_tokens, diffusion_tokens):
        """
        ar_tokens: 自回归子序列（文本+图像理解 token）
        diffusion_tokens: 扩散子序列（视频生成 token）
        """
        # 推理塔前向传播
        ar_hidden = self.norm1(ar_tokens)
        ar_hidden = self.reasoner_attn(ar_hidden, ar_hidden, ar_hidden)

        # 生成塔前向传播
        diff_hidden = self.norm2(diffusion_tokens)
        diff_hidden = self.generator_attn(diff_hidden, diff_hidden, diff_hidden)

        # 双流联合注意：Diffusion token 与 AR token 交叉注意
        cross_attn_output = self.generator_attn(
            query=diff_hidden,
            key=ar_hidden,      # AR 提供语义上下文
            value=ar_hidden
        )
        diff_hidden = diff_hidden + cross_attn_output

        # 各自经过 FFN
        ar_output = self.reasoner_ffn(ar_hidden)
        diff_output = self.generator_ffn(diff_hidden)

        return ar_output, diff_output

关键设计点：

参数隔离：推理塔和生成塔使用独立的注意力参数和 FFN 参数，各自优化。这避免了两种不同类型信号在同一参数空间中的干扰。

双流联合注意：虽然参数独立，但扩散分支的 token 可以通过交叉注意力读取推理分支的 hidden state。这使得"生成的视频帧"能够受到"文本语义"和"场景理解"的引导。

统一位置编码：两种 token 共享同一套 3D MRoPE 位置编码（详见后文），保证了跨模态的时间对齐。

3.3 三种动作生成模式

Cosmos 3 支持三种动作生成模式，这是它区别于普通视频生成模型的关键：

正向动力学（Forward Dynamics）：
输入当前状态 + 动作 → 预测下一个状态（视频帧）

[当前画面 + 机械臂移动指令] → [预测的下一帧画面]

逆向动力学（Inverse Dynamics）：
输入状态序列（视频）→ 反推导致这个状态变化的隐含动作

[物体从位置A移动到位置B的视频] → [推断：这是一个抓取-移动-释放动作序列]

策略模式（Policy Mode / WAM）：
联合生成动作序列和对应的视频结果

[当前画面 + 任务目标] → [生成动作序列 + 预测的执行结果视频]

策略模式是最有实际价值的——它让模型同时输出"应该做什么"和"预期会看到什么"，这对机器人控制来说是天然的闭环信号。

四、统一动作表征：跨具身泛化的核心

4.1 动作表示的核心挑战

物理 AI 的一个根本问题是：不同机器人有不同的动作空间。

• Franka Panda 7-DoF 机械臂：7 个关节角度 + 夹爪开合度
• 宇树 H1 人形机器人：全身 30+ 自由度
• 自动驾驶车辆：方向盘角度、油门、刹车

如果每个具身形态单独建模一个模型，训练成本和数据成本都不可接受。Cosmos 3 的解决方案是统一动作表征（Unified Action Representation），将异构的动作空间映射到一个共享的潜动作空间。

4.2 动作编码设计

Cosmos 3 将动作分为两类分量，统一编码：

运动分量：使用 6D 旋转表示法（由 Zhou et al. 2019 提出）编码末端执行器的姿态。

为什么不用四元数或欧拉角？因为 6D 旋转表示是连续的，避免了四元数的双-cover 问题（同一个旋转对应两个四元数），也比欧拉角更利于网络学习。

import numpy as np

def rotation_6d_to_matrix(d6: np.ndarray) -> np.ndarray:
    """
    将6D旋转表示转换为3x3旋转矩阵
    d6: 前3列为第一个正交基向量，后3列为第二个
    返回: 3x3 SO(3) 旋转矩阵
    """
    b1 = d6[:3]
    b2 = d6[3:]

    # Gram-Schmidt 正交化
    b1_normalized = b1 / (np.linalg.norm(b1) + 1e-8)
    b2_orthogonalized = b2 - np.dot(b1_normalized, b2) * b1_normalized
    b2_normalized = b2_orthogonalized / (np.linalg.norm(b2_orthogonalized) + 1e-8)
    b3 = np.cross(b1_normalized, b2_normalized)

    # 构建正交旋转矩阵
    rotation_matrix = np.column_stack([b1_normalized, b2_normalized, b3])
    return rotation_matrix

def pose_to_6d(rotation_matrix: np.ndarray) -> np.ndarray:
    """
    将3x3旋转矩阵转换为6D表示
    用于将真实旋转转换为网络可处理的连续向量
    """
    b1 = rotation_matrix[:3, 0]  # 第一列
    b2 = rotation_matrix[:3, 1]  # 第二列
    return np.concatenate([b1, b2])

状态分量：抓取状态直接编码为当前操控状态（如指尖位置、夹爪开合数值）。

4.3 域感知投影机制

不同具身形态使用独立的域感知输入/输出投影层（各域独立权重矩阵），共享 MoT 主干网络：

class DomainAwareActionProjection(nn.Module):
    """
    域感知的动作投影层：
    - 输入：异构动作向量（不同具身形态格式不同）
    - 输出：统一 Token 序列（共享语义空间）
    """
    def __init__(self, hidden_dim, num_domains):
        super().__init__()
        # 每个具身形态域独立的投影参数
        self.input_projections = nn.ModuleList([
            nn.Linear(self._get_action_dim(domain), hidden_dim)
            for domain in range(num_domains)
        ])
        self.output_projections = nn.ModuleList([
            nn.Linear(hidden_dim, self._get_action_dim(domain))
            for domain in range(num_domains)
        ])

    def encode(self, action_vector, domain_id):
        """将具身域的动作向量编码为 token"""
        projected = self.input_projections[domain_id](action_vector)
        return projected

    def decode(self, latent_action, domain_id):
        """将潜动作 token 解码回具身域的原始格式"""
        decoded = self.output_projections[domain_id](latent_action)
        # SVD 后处理：将预测的6D旋转转换为标准旋转矩阵
        rotation_6d = decoded[..., :6]
        rotation_matrix = rotation_6d_to_matrix(rotation_6d)
        # ... 组合为最终动作向量
        return decoded

这种设计的巧妙之处在于：共享 MoT 主干让不同具身形态的知识相互迁移（泛化能力），独立投影层处理各具身的特殊格式（表达能力）。

五、3D MRoPE：跨模态时间对齐

5.1 为什么需要 3D 位置编码

在统一处理文本、图像、视频、音频、动作时，有一个关键问题：这些模态的时间尺度完全不同。

• 视频帧：可能 24fps、30fps、60fps，同一帧内所有 token 共享同一个时间索引
• 音频：采样率可能是 16kHz、44.1kHz，每个采样点对应一个 token
• 动作序列：可能 50Hz、100Hz，每个动作 step 对应一个 token

Cosmos 3 面临的是：如何让模型正确理解"这段音频和这段视频是同步的"这个事实。

5.2 绝对时间调制的设计

Cosmos 3 基于 3D MRoPE（Bai et al., 2025）设计了自己的绝对时间调制机制：

时间索引分配策略：

绝对时间调制：不同模态的时间增量对应不同的物理时间。通过 FPS 调制（temporal modulation），将所有模态的时间索引映射到统一的物理时间轴上：

class AbsoluteTimeModulation:
    """
    绝对时间调制：
    将不同采样率的模态（视频/音频/动作）对齐到统一物理时间轴
    """
    def __init__(self, base_fps=24):
        self.base_fps = base_fps

    def modulate_time_index(self, modality, raw_index, native_fps_or_hop):
        """
        将模态的原始时间索引映射为物理时间
        modality: 'video', 'audio', 'action', 'text'
        raw_index: 原始 token 索引
        native_fps_or_hop: 该模态的原生采样率或 hop 大小
        """
        if modality == 'text':
            # 文本退化为1D，每个 token 一个时间单位
            return raw_index

        elif modality == 'video':
            # 视频：时间步 = 帧索引
            physical_time = raw_index * (self.base_fps / native_fps_or_hop)
            return physical_time

        elif modality == 'audio':
            # 音频：时间步 = hop 数量
            time_per_hop = 1.0 / native_fps_or_hop
            physical_time = raw_index * time_per_hop
            return physical_time

        elif modality == 'action':
            # 动作：时间步 = 控制 step 数
            control_rate = native_fps_or_hop  # e.g., 50Hz
            physical_time = raw_index * (1.0 / control_rate)
            return physical_time

5.3 AR-Diffusion 时间间隔

在实现中，如果扩散 token 紧接在最后一个自回归 token 之后，会导致视频初始帧出现过饱和和棋盘格伪影（checkerboard artifact）。原因是最后一个语言 token 和第一帧视频 token 占据了相邻的时间位置。

Cosmos 3 在 AR 子序列和 Diffusion 子序列之间插入了固定的时间间隔（所有模型统一设为 15000），相当于在时间轴上创造了一个"缓冲地带"，提供更清晰的"文本→视觉"转换信号，且无需修改模型架构。

六、模型变体：从 Edge 到 Super 的全谱系

6.1 三档规格对比

Cosmos3-Nano（约 15.75B 参数）是目前最常用的开源版本，也是 Hugging Face 上可直接下载的版本。Cosmos3-Super（约 64B 参数）面向高精度需求场景，在 RoboArena 评测中被评为最佳策略模型。

6.2 训练数据规模

七、Hugging Face 实战：零基础上手 Cosmos 3

7.1 环境准备

# 推荐使用 conda 或 venv
conda create -n cosmos3 python=3.10
conda activate cosmos3

# 安装核心依赖（Cosmos 3 基于 NVIDIA 生态）
pip install torch torchvision torchaudio
pip install transformers accelerate
pip install huggingface_hub

# 如需视频处理
pip install decord av opencv-python

# 登录 Hugging Face（需申请 NVIDIA 官方模型访问权限）
huggingface-cli login

7.2 下载和加载模型

Cosmos 3 的模型在 Hugging Face 和 NVIDIA 官方平台均有托管：

from huggingface_hub import hf_hub_download, snapshot_download
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 下载 Cosmos3-Nano 模型（需要申请访问权限）
# 模型 ID: nvidia/Cosmos3-Nano

model_id = "nvidia/Cosmos3-Nano"

# 方法一：snapshot_download（推荐，自动管理缓存）
model_dir = snapshot_download(
    repo_id=model_id,
    allow_patterns=["*.safetensors", "*.bin", "*.json"],
    ignore_patterns=["*.md", "*.txt", "__pycache__"],
)

print(f"模型已下载至: {model_dir}")

# 方法二：逐文件下载（节省带宽）
# config_file = hf_hub_download(repo_id=model_id, filename="config.json")
# model_safetensors = hf_hub_download(repo_id=model_id, filename="model.safetensors")

7.3 图像→视频生成（I2V）

Cosmos 3 最重要的能力之一是基于图像生成视频，即图生视频（Image-to-Video）。这在机器人场景中可以用于：

• 基于当前观测生成未来帧（世界预测）
• 动画化静态场景（场景探索）
• 预测动作执行结果（策略验证）

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

class Cosmos3I2V:
    """
    Cosmos 3 图生视频推理封装
    基于 Cosmos3-Nano 模型
    """
    def __init__(self, model_path, device="cuda"):
        self.device = device

        # 加载模型和处理器
        self.processor = AutoProcessor.from_pretrained(
            model_path,
            trust_remote_code=True
        )
        self.model = AutoModelForCausalLM.from_pretrained(
            model_path,
            torch_dtype=torch.bfloat16,
            device_map="auto",
            trust_remote_code=True,
        )
        self.model.eval()

    @torch.no_grad()
    def generate_video(
        self,
        init_image: Image.Image,
        prompt: str,
        num_frames: int = 121,
        guidance_scale: float = 7.5,
        num_inference_steps: int = 50,
    ) -> torch.Tensor:
        """
        从初始图像和文本提示生成视频

        参数:
            init_image: 起始帧图像（PIL.Image）
            prompt: 描述想要生成的视频内容
            num_frames: 生成帧数（最大121帧 @ Nano）
            guidance_scale: CFG 引导强度
            num_inference_steps: 扩散去噪步数

        返回:
            generated_video: [T, C, H, W] 格式的视频张量
        """
        # 图像预处理
        pixel_values = self.processor.preprocess_image(init_image)
        pixel_values = pixel_values.to(device=self.device, dtype=torch.bfloat16)

        # 文本编码
        text_inputs = self.processor(
            text=prompt,
            return_tensors="pt",
            padding=True,
        )
        text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}

        # 统一 Token 化（关键！）
        # Cosmos 3 将图像和文本编码为统一 token 序列
        inputs = self.processor(
            images=pixel_values,
            text=prompt,
            return_tensors="pt",
            video_num_frames=num_frames,
        )
        inputs = {k: v.to(self.device) if isinstance(v, torch.Tensor) else v
                  for k, v in inputs.items()}

        # 生成配置
        generation_config = {
            "num_frames": num_frames,
            "guidance_scale": guidance_scale,
            "num_inference_steps": num_inference_steps,
            "video_gen_type": "image_to_video",  # I2V 模式
        }

        # 执行推理（使用 MoT 双塔）
        # - AR 塔处理文本+图像的语义 token
        # - Diffusion 塔逐步生成视频 token
        outputs = self.model.generate(
            **inputs,
            **generation_config,
            do_sample=True,
        )

        # 解码视频 token → 像素
        video_frames = self.processor.postprocess_video(outputs)
        return video_frames  # [T, H, W, C]

# 使用示例
cosmos = Cosmos3I2V(model_path="./models/Cosmos3-Nano")

init_img = Image.open("robot_table_scene.png")
prompt = "A robotic arm gently picks up the blue cube and places it in the red container. Smooth motion with realistic shadows."

video = cosmos.generate_video(
    init_image=init_img,
    prompt=prompt,
    num_frames=121,  # ~5秒 @ 24fps
    guidance_scale=7.5,
)

print(f"生成了 {video.shape[0]} 帧视频")

7.4 机器人策略模式（WAM）

Cosmos 3 的策略模式允许同时输入当前画面 + 任务文本，输出动作序列和预测视频。这是机器人操作规划的核心能力：

class Cosmos3Policy:
    """
    Cosmos 3 世界-动作模型（World-Action Model）模式
    用于机器人操作策略预测
    """
    def __init__(self, model_path, embodiment_config, device="cuda"):
        self.device = device
        self.cosmos = Cosmos3I2V(model_path, device)

        # 加载具身配置（动作空间定义）
        self.embodiment_config = embodiment_config

    def predict_action(
        self,
        current_image: Image.Image,
        task_description: str,
        history_observations: list[Image.Image],
        top_k_actions: int = 5,
    ) -> dict:
        """
        基于当前观测和任务描述，预测最优动作序列

        参数:
            current_image: 当前画面
            task_description: 自然语言任务描述
            history_observations: 历史观测序列（用于时序推理）
            top_k_actions: 返回 Top-K 候选动作

        返回:
            {
                "action_sequence": [动作序列],
                "predicted_video": [预测的未来帧],
                "confidence": 置信度,
            }
        """
        # 合并历史观测构建上下文
        context_frames = history_observations[-8:] + [current_image]
        # 编码为统一 token 序列
        multi_modal_inputs = self.cosmos.processor(
            images=context_frames,
            text=task_description,
            return_tensors="pt",
            video_num_frames=0,  # 不生成视频，仅推理
        )

        # Policy 模式推理
        # 输入：观测序列 + 任务文本
        # 输出：动作 token 序列（解码为具体关节角度）
        action_tokens = self.cosmos.model.generate(
            **multi_modal_inputs,
            output_mode="world_action_model",  # 策略模式
            num_action_tokens=16,  # 输出16步动作预测
        )

        # 解码动作 token
        predicted_actions = []
        for action_token in action_tokens:
            action_vector = self.cosmos.model.decode_action_token(
                action_token,
                domain_id=self.embodiment_config["domain_id"]
            )
            predicted_actions.append(action_vector)

        # 同时生成预测视频（可选）
        predicted_video = self.cosmos.generate_video(
            init_image=current_image,
            prompt=f"{task_description} - Predicted execution outcome",
            num_frames=61,
        )

        return {
            "action_sequence": predicted_actions,  # 格式由具身配置决定
            "predicted_video": predicted_video,
            "confidence": self._compute_confidence(action_tokens),
        }

# 使用示例：Franka Panda 机械臂场景
franka_config = {
    "domain_id": 0,
    "joint_names": [
        "panda_joint1", "panda_joint2", "panda_joint3",
        "panda_joint4", "panda_joint5", "panda_joint6", "panda_joint7",
        "panda_finger_joint1", "panda_finger_joint2",
    ],
    "action_dim": 9,  # 7关节 + 2夹爪
    "control_rate_hz": 50,
}

policy = Cosmos3Policy(
    model_path="./models/Cosmos3-Nano",
    embodiment_config=franka_config,
)

# 读取当前画面（来自摄像头或仿真器）
current_obs = Image.open("panda_current_view.png")
history = [Image.open(f"obs_{i}.png") for i in range(8, 0, -1)]

result = policy.predict_action(
    current_image=current_obs,
    task_description="Pick up the red cube on the left and place it into the blue box on the right",
    history_observations=history,
)

print(f"预测动作序列长度: {len(result['action_sequence'])}")
print(f"预测视频帧数: {result['predicted_video'].shape[0]}")

7.5 多模态理解（VLM 模式）

除了生成，Cosmos 3 也能作为视觉-语言模型进行物理场景理解：

class Cosmos3VLM:
    """
    Cosmos 3 视觉-语言理解模式
    用于场景理解、物理关系推理、动作描述
    """
    def __init__(self, model_path, device="cuda"):
        self.device = device
        self.processor = AutoProcessor.from_pretrained(model_path)
        self.model = AutoModelForCausalLM.from_pretrained(
            model_path,
            torch_dtype=torch.bfloat16,
            device_map="auto",
        )

    @torch.no_grad()
    def understand_scene(self, image: Image.Image, question: str) -> str:
        """
        理解图像中的物理场景，并回答问题
        """
        inputs = self.processor(
            text=f"Question: {question}\nAnswer:",
            images=image,
            return_tensors="pt",
            video=None,
        )
        inputs = {k: v.to(self.device) if isinstance(v, torch.Tensor) else v
                  for k, v in inputs.items()}

        # 使用 AR 塔（Reasoner）进行理解推理
        outputs = self.model.generate(
            **inputs,
            max_new_tokens=512,
            do_sample=False,
        )

        # 解码文本响应
        response = self.processor.batch_decode(
            outputs[:, inputs["input_ids"].shape[1]:],
            skip_special_tokens=True,
        )[0]

        return response

# 使用示例
vlm = Cosmos3VLM("./models/Cosmos3-Nano")

scene_question = (
    "分析图中机器人手臂的状态。"
    "判断：(1) 夹爪是张开还是闭合，(2) 末端执行器朝向哪里，"
    "(3) 如果执行抓取动作，最可能的抓取目标是什么？"
    "请给出详细的物理推理过程。"
)

answer = vlm.understand_scene(
    image=Image.open("robot_scene.png"),
    question=scene_question,
)
print(answer)

八、性能基准与横向对比

8.1 核心评测结果

根据 NVIDIA 官方论文和 Artificial Analysis、RoboArena 等第三方评测：

8.2 生成质量分析

Cosmos 3 的一个显著优势是长视频一致性。得益于 MoT 架构的 AR-Diffusion 联合注意机制，生成视频在物体恒存性（object permanence）上表现优异——物体被遮挡后再次出现时，模型能保持其外观和物理属性的一致性，而不是"神奇消失"或"变成另一个物体"。

物理合理性方面，Cosmos 3 在以下测试中表现突出：

• 重力效果（物体下落方向和速度）
• 碰撞响应（接触后的反弹和摩擦）
• 液体行为（简单场景下的流动物理）
• 软体变形（有限条件下）

8.3 推理延迟基准

（注：以上数据基于社区实测，实际性能受 batch size、精度、推理优化程度影响）

九、生产级部署建议

9.1 推理优化技术

量化：Cosmos3-Nano 支持 INT8 量化，推理速度提升约 1.8x，显存占用降低约 50%：

from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0,
    llm_int8_skip_modules=["vision_encoder"],
)

model = AutoModelForCausalLM.from_pretrained(
    "nvidia/Cosmos3-Nano",
    quantization_config=quantization_config,
    device_map="auto",
)

KV Cache：对于多轮对话和长视频推理，启用 KV Cache 避免重复计算。

分块推理：长视频生成建议分段处理（每段 ≤ 121 帧），避免显存溢出，然后用时间轴拼接：

def generate_long_video(init_image, prompt, total_frames, chunk_size=121):
    """分块生成超长视频（避免显存溢出）"""
    chunks = []
    current_frame = init_image

    for start in range(0, total_frames, chunk_size):
        end = min(start + chunk_size, total_frames)
        actual_chunk = end - start

        chunk_video = cosmos.generate_video(
            init_image=current_frame,
            prompt=prompt,
            num_frames=actual_chunk,
        )

        chunks.append(chunk_video[1:])  # 去掉首帧（复用上一段末帧）
        current_frame = chunk_video[-1]  # 更新起始帧

    return torch.cat(chunks, dim=0)  # 时间轴拼接

9.2 混合推理架构建议

对于实际机器人应用，推荐以下架构：

感知层
├── RGB-D 相机 → RealSense / Azure Kinect
├── 触觉传感器（可选）
└── 机器人关节编码器 → 动作编码

Cosmos3 Policy 推理
├── 当前帧 + 历史帧 → Cosmos3-Nano → 动作序列 + 预测帧
└── 推理时间目标: <100ms（实时控制要求）

执行层
├── 动作序列 → 关节插值 → 机器人控制指令
└── 预测帧 → 可视化验证（操作员监控）

反馈闭环
├── 实际执行 → 新观测 → 重新规划
└── 异常检测 → 触发重规划或人工接管

9.3 局限性：需要冷静看待的边界

技术再好也有边界。Cosmos 3 目前的主要局限：

长视频一致性上限：超过 121 帧（Super 模型支持更长）后，物理一致性会逐渐退化。超长视频生成仍需要工程层面的分段策略。

复杂接触物理：多刚体接触、摩擦力的精细建模仍有不足。在需要高精度力控的任务中，仿真引擎（Isaac Sim）仍是必要的补充。

声音-视觉同步：当前版本的音视频同步能力有限，在语音交互场景中需要额外的唇音同步后处理。

真实物理验证不可替代：生成的合成数据在 Sim2Real 迁移中仍存在 gap。高安全等级应用（如手术机器人）需要结合真实物理测试。

十、总结与展望

10.1 Cosmos 3 的核心价值

回到本文开头的问题：Cosmos 3 到底带来了什么？

从技术范式角度：Cosmos 3 证明了"全模态统一建模"在物理 AI 领域的可行性。MoT 双塔架构将理解（AR）和生成（Diffusion）统一在同一个框架中，无需针对每个任务单独训练模型。这为"一个模型服务多种 Physical AI 任务"提供了工程可行的路径。

从产业角度：Cosmos 3 开源后，降低了物理 AI 研究的门槛。机器人团队不再需要从零构建仿真数据生成管线，直接在 Cosmos 3 的基础上做领域适应（domain adaptation）和后训练。NVIDIA 的目标用户是整个 Physical AI 生态。

从开发者角度：Hugging Face 上的开源模型让个人开发者也能玩转世界模型。虽然 16B 参数对硬件有要求，但 Nano 级别已经可以在消费级 GPU 上做一些研究性的探索。

10.2 未来展望

根据 NVIDIA 公布的路线路，Cosmos 系列的下一个方向包括：

• Cosmos3-Edge：面向边缘设备优化的 4B 版本，支持手机和嵌入式部署
• 多具身后训练模型库：针对不同机器人平台（Unitree、Franka、宇树等）专项优化后的模型
• 长视频生成能力：突破 300+ 帧限制，支持分钟级连贯视频
• 音频-动作联合建模：更强的音视频物理同步能力

此外，物理 AI 社区已经开始在 Cosmos 3 基础上构建更复杂的应用：World Lab 的空间智能研究、伯克利 RAIL 的机器人后训练、清华叉院的自动驾驶仿真……一个围绕世界模型的 Physical AI 开源生态正在形成。

10.3 给程序员的机会

如果你在关注 Physical AI 领域，现在是最好的切入时机：

• 应用层：在机器人、自动驾驶、智能工厂等领域，基于 Cosmos 3 构建下游应用
• 工具层：围绕世界模型的数据处理、评估基准、后训练框架有大量空白
• 研究层：Cosmos 3 的架构创新（MoT、绝对时间调制、统一动作表征）都值得深入研究

正如大语言模型重塑了 NLP 的应用方式，世界模型很可能成为 Physical AI 的基础设施工具。对于程序员来说，理解这套范式背后的设计哲学——统一建模、多模态融合、理解与生成的协同——远比学会调用一个 API 更有长期价值。

Cosmos 3 不是终点，而是物理 AI 世界模型时代的开始。

参考资料

1. NVIDIA. "Cosmos 3: Omnimodal World Models for Physical AI". GTC Taiwan, June 2026.
2. NVIDIA Cosmos Official: https://github.com/nvidia/cosmos
3. Hugging Face Collection: https://huggingface.co/collections/nvidia/cosmos3
4. OpenCSG Technical Analysis: https://www.opencsg.com/models/nvidia/Cosmos3-Super
5. Zhou et al. "On the Continuity of Rotation Representations in Neural Networks". CVPR 2019.
6. Bai et al. "Qwen3-VL Technical Report". 2025.
7. Khazatsky et al. "DROID: A Large-Scale Dataset for Robotic Manipulation". 2024.
8. RoboArena Benchmark Report. 2026.

本文首发于 程序员茄子，如需转载，请联系原作者。