VGGT: 几何重建作为世界模型的 reconstruct 维度

1. 动机：传统几何重建在什么地方失效

一辆自动驾驶车驶入隧道。GNSS 信号在 50 米内衰减为噪声，IMU 漂移开始累积，前向 6 路相机持续以 10 Hz 输入。系统需要在 100 ms 内回答两个问题：相机相对于隧道结构的位姿是什么？前方 30 米处那个反射点距离车头多远？

经典视觉流程 (SIFT 特征 → 最近邻匹配 → 五点法位姿初值 → RANSAC 剔除外点 → bundle adjustment 联合优化) 在这种场景下并不缺数据，缺的是假设的成立。隧道壁面纹理稀疏，特征匹配会大面积失败；反光点违反 Lambertian 漫反射假设，深度三角化崩溃；RANSAC 的内点比例随匹配质量恶化而急剧下降。Schönberger 与 Frahm 的 COLMAP [6] 把每一步都做到了工程极致，但级联式流程注定了每一环的失败都会向下游放大。Triggs 等人 2000 年那篇捆集调整综述 [7] 列举了所有可能的失败模式，并提供了对应的鲁棒化技术——但每一项都需要在线检测哪种失败发生了，再决定切换到哪种应对策略。

VGGT [1] 提出的方案是：把整条流程压成一次前向传播。给 24 层 transformer 投喂 $N$ 张图像，吐出每帧的内外参、稠密深度图、稠密点图，附带每个像素的置信度。不迭代，不优化，不切换分支。1 秒内完成的几何重建。

VGGT 在世界模型四维框架中占据 reconstruct 维度，与 V-JEPA [8] 的 predict、Wan2.2 [9] 的 simulate、Depth Anything 3 [4] 的 measure 正交。四个维度回答同一个问题——“机器如何持有一份对物理世界的内部表征”——但切入角度互不重合：predict 关心可观测信号在潜空间的时间演化，simulate 关心从动作条件生成像素序列，measure 关心从单视图回到度量空间的最小充分映射，reconstruct 关心从多视图反演完整 3D 几何。本文聚焦最后这一维度。

2. 形式化：把渲染方程倒着求解

世界向相机投射图像的过程，由渲染方程给出：

I(\mathbf{x}) = \int_{\Omega} f(\mathbf{x}, \omega_i, \omega_o) L_i(\mathbf{x}, \omega_i) (\omega_i \cdot \mathbf{n}) \, d\omega_i

这是一个从场景几何 $D$ 、相机位姿 $\{g_i\}$ 、材质与光照映射到像素的前向过程。3D 重建做的是它的逆映射：观测 $\{I_i\}_{i=1}^N$ 已知，求解 $(D, \{g_i\})$ 。这个逆问题在数学上是病态的——多个 3D 场景可以产生相同的图像集合——经典方案靠先验 (刚性、Lambertian、充足纹理) 把解空间压窄到唯一。

VGGT 把这套先验从手工设计的几何约束改写成了网络的归纳偏置。具体地，模型学习映射

f_\theta : \{I_i\}_{i=1}^N \mapsto (\{D_i\}, \{g_i\}, \{P_i\}, \{C_i\})

其中 $D_i$ 是帧 $i$ 的深度图， $g_i \in \mathrm{SE}(3) \times \mathbb{R}^4$ 是外参加内参， $P_i$ 是帧 $i$ 局部坐标系下的稠密点图， $C_i$ 是逐像素置信度。这四个量之间存在恒等式约束：

P_i(j) = g_i \cdot D_i(j) \cdot \tilde{\mathbf{x}}_i(j)

其中 $\tilde{\mathbf{x}}_i(j)$ 是齐次像素坐标。知道 $\{D, g\}$ 即可解析地导出 $P$ ，反之知道 $\{P, g\}$ 即可解析地导出 $D$ 。这条恒等式后面会派上关键用场。

把这件事变成可以直接旋转的 3D 场景：一个立方体 + 12 个散点摆在原点附近，浏览器里拖动旋转、滚轮缩放、按钮切换视角。把主相机切到俯视/侧视/前视任一视角时——立方体退化为正方形、散点重叠——可以直观看到"单一视角永远丢一个维度的信息"；再切回 3D 自由视角，丢失的几何马上回来。VGGT 在多帧 token 序列上做 alternating attention，本质就是让网络学会自动完成这种"多视角 → 完整 3D"的融合。

3D 几何的多视图融合：拖动旋转，单击视角按钮看每个相机看到什么

Loading 3D scene...

一个含 8 顶点立方体 + 12 个散点的简化 3D 场景。拖拽鼠标自由旋转、滚轮缩放；右上三个按钮把主相机切到俯视/侧视/前视，对应位置上同时悬浮一个相机 frustum 显示该视角的视锥。注意：每个单视角看到的都是 2D 投影（点重叠、立方体退化为正方形），只有把三个视图的信息融合才能反演 3D 几何——这是 VGGT 多帧 alternating attention 在数据流上的几何动机。

const W = container.clientWidth;
const H = container.clientHeight || 540;

const scene = new THREE.Scene();
scene.background = new THREE.Color(0x1a1a2e);

const mainCam = new THREE.PerspectiveCamera(45, W / H, 0.1, 100);
mainCam.position.set(4.2, 3.0, 5.0);

const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
renderer.setSize(W, H);
renderer.domElement.style.display = 'block';
container.appendChild(renderer.domElement);

const controls = new OrbitControls(mainCam, renderer.domElement);
controls.enableDamping = true;
controls.dampingFactor = 0.08;
controls.minDistance = 3;
controls.maxDistance = 18;

// --- Reference grid (XZ plane) + axes ---
const grid = new THREE.GridHelper(6, 12, 0x334155, 0x1f2937);
grid.position.y = -1.6;
scene.add(grid);

const axesGroup = new THREE.Group();
const axColors = [0xef4444, 0x22c55e, 0x3b82f6]; // X red, Y green, Z blue
const axDirs = [
    new THREE.Vector3(1, 0, 0),
    new THREE.Vector3(0, 1, 0),
    new THREE.Vector3(0, 0, 1)
];
axDirs.forEach((d, i) => {
    const arr = new THREE.ArrowHelper(d, new THREE.Vector3(0, 0, 0), 2.2, axColors[i], 0.18, 0.1);
    axesGroup.add(arr);
});
scene.add(axesGroup);

// --- 8-vertex cube wireframe (matches the 2D version's geometry exactly) ---
const cubeGeom = new THREE.BoxGeometry(2, 2, 2);
const edgesGeom = new THREE.EdgesGeometry(cubeGeom);
const cube = new THREE.LineSegments(edgesGeom, new THREE.LineBasicMaterial({ color: 0x60a5fa, linewidth: 2 }));
scene.add(cube);

// Cube vertices as small dots (so wireframe corners are visible)
const cubeVertGeom = new THREE.SphereGeometry(0.06, 12, 12);
const cubeVertMat = new THREE.MeshBasicMaterial({ color: 0x93c5fd });
for (let i = 0; i < 8; i++) {
    const v = new THREE.Mesh(cubeVertGeom, cubeVertMat);
    v.position.set((i & 1) ? 1 : -1, (i & 2) ? 1 : -1, (i & 4) ? 1 : -1);
    scene.add(v);
}

// --- 12 deterministic-seeded scatter points (same seed as 2D version) ---
let s = 7;
function r() { s = (s * 1103515245 + 12345) & 0x7fffffff; return s / 0x7fffffff; }
const scatterGroup = new THREE.Group();
for (let i = 0; i < 12; i++) {
    const px = (r() * 2 - 1) * 1.4;
    const py = (r() * 2 - 1) * 1.4;
    const pz = (r() * 2 - 1) * 1.4;
    const hue = (i * 30) % 360;
    const color = new THREE.Color(`hsl(${hue}, 70%, 65%)`);
    const sphere = new THREE.Mesh(
        new THREE.SphereGeometry(0.11, 18, 18),
        new THREE.MeshBasicMaterial({ color: color })
    );
    sphere.position.set(px, py, pz);
    scatterGroup.add(sphere);
}
scene.add(scatterGroup);

// --- Three "view cameras" with frustum helpers (XY top-down, XZ side, YZ front) ---
const viewDefs = [
    { name: '俯视 (XY)', pos: [0, 6, 0.01], up: [0, 0, -1], color: 0xef4444 },
    { name: '侧视 (XZ)', pos: [6, 0, 0], up: [0, 1, 0], color: 0x22c55e },
    { name: '前视 (YZ)', pos: [0, 0, 6], up: [0, 1, 0], color: 0x3b82f6 }
];
const helperCams = viewDefs.map((vd, idx) => {
    const c = new THREE.PerspectiveCamera(35, 1, 0.1, 12);
    c.position.set(...vd.pos);
    c.up.set(...vd.up);
    c.lookAt(0, 0, 0);
    c.updateProjectionMatrix();
    const helper = new THREE.CameraHelper(c);
    // r147 CameraHelper has no setColors(); tint the whole helper material instead
    helper.material.color = new THREE.Color(vd.color);
    helper.material.transparent = true;
    helper.material.opacity = 0.55;
    scene.add(helper);
    // Small colored marker sphere at the camera position so the viewer can tell
    // which frustum is which (matches the matching button color)
    const marker = new THREE.Mesh(
        new THREE.SphereGeometry(0.13, 18, 18),
        new THREE.MeshBasicMaterial({ color: vd.color })
    );
    marker.position.set(...vd.pos);
    scene.add(marker);
    return { cam: c, helper: helper, def: vd };
});

// --- Controls UI: 4 buttons (3 views + auto-rotate toggle) ---
const ctrlBar = document.createElement('div');
ctrlBar.className = 'three-viz-controls';
container.appendChild(ctrlBar);

function flyTo(targetPos, targetUp, duration) {
    const startPos = mainCam.position.clone();
    const startUp = mainCam.up.clone();
    const endPos = new THREE.Vector3(...targetPos);
    const endUp = new THREE.Vector3(...targetUp);
    const t0 = performance.now();
    controls.autoRotate = false;
    autoRotateBtn.classList.remove('active');
    function step() {
        const t = Math.min(1, (performance.now() - t0) / duration);
        const k = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
        mainCam.position.lerpVectors(startPos, endPos, k);
        mainCam.up.lerpVectors(startUp, endUp, k).normalize();
        mainCam.lookAt(0, 0, 0);
        controls.update();
        if (t < 1) requestAnimationFrame(step);
    }
    step();
}

viewDefs.forEach((vd, i) => {
    const btn = document.createElement('button');
    btn.textContent = vd.name;
    btn.style.borderColor = '#' + vd.color.toString(16).padStart(6, '0');
    btn.style.color = '#' + vd.color.toString(16).padStart(6, '0');
    btn.addEventListener('click', () => {
        // move slightly back along the camera direction so the scene fits
        const scale = 1.05;
        flyTo([vd.pos[0] * scale, vd.pos[1] * scale, vd.pos[2] * scale], vd.up, 700);
    });
    ctrlBar.appendChild(btn);
});

const resetBtn = document.createElement('button');
resetBtn.textContent = '复位 (3D)';
resetBtn.addEventListener('click', () => {
    flyTo([4.2, 3.0, 5.0], [0, 1, 0], 700);
});
ctrlBar.appendChild(resetBtn);

const autoRotateBtn = document.createElement('button');
autoRotateBtn.textContent = '自动旋转';
autoRotateBtn.addEventListener('click', () => {
    controls.autoRotate = !controls.autoRotate;
    controls.autoRotateSpeed = 1.2;
    autoRotateBtn.classList.toggle('active', controls.autoRotate);
});
ctrlBar.appendChild(autoRotateBtn);

const hint = document.createElement('div');
hint.className = 'three-viz-hint';
hint.textContent = '拖拽=旋转  滚轮=缩放  右键=平移';
container.appendChild(hint);

// --- Render loop ---
let raf = 0;
function animate() {
    raf = requestAnimationFrame(animate);
    controls.update();
    renderer.render(scene, mainCam);
}
animate();

// --- Resize + dispose hooks (consumed by three-viz shortcode) ---
window['_threeViz_vggt-3d-multiview'] = {
    onResize(w, h) {
        if (!w || !h) return;
        mainCam.aspect = w / h;
        mainCam.updateProjectionMatrix();
        renderer.setSize(w, h, false);
    },
    dispose() {
        cancelAnimationFrame(raf);
        controls.dispose();
        renderer.dispose();
        scene.traverse(o => {
            if (o.geometry) o.geometry.dispose();
            if (o.material) o.material.dispose();
        });
    }
};

3. 架构：DINOv2 trunk + Alternating Attention + 五头输出

flowchart TD
    I1[Frame 1] --> P1[DINOv2 patchify]
    I2[Frame 2] --> P2[DINOv2 patchify]
    I3[Frame 3] --> P3[DINOv2 patchify]
    I4[Frame N] --> P4[DINOv2 patchify]
    P1 --> T[24-layer Alternating Attention trunk]
    P2 --> T
    P3 --> T
    P4 --> T
    T -.camera tokens.-> H1[Camera Head]
    T -.patch tokens.-> H2[Depth DPT Head]
    T -.patch tokens.-> H3[Point Map DPT Head]
    T -.patch tokens.-> H4[Track Head]
    T -.patch tokens.-> H5[Confidence Head]
    H1 --> O1[内外参 g_i]
    H2 --> O2[深度图 D_i]
    H3 --> O3[点图 P_i]
    H4 --> O4[2D 轨迹]
    H5 --> O5[置信度 C_i]

3.1 Trunk: DINOv2 patchify

每张输入图像 (518×518) 由冻结的 DINOv2 [5] 切成 patch token，附加两类特殊 token：相机 token $\mathbf{c}_i$ 聚合帧级位姿信息，register token $\mathbf{r}_i$ 作为帧内部状态的暂存区。冻结 DINOv2 而非端到端微调是一个值得展开的选择。语义骨干训练时见过物体边界、表面法线、场景布局；这套先验对下游几何头是稳定的输入分布。若骨干随训练漂移，几何头就必须持续追踪一个移动目标，优化曲面会显著更难。

3.2 Alternating Attention 与复杂度

VGGT trunk 把 24 层 frame-wise self-attention 与 24 层 global self-attention 交替堆叠 (论文称 L=24，总注意力层数为 2L=48)。前者让每帧 token 仅与同帧内的 token 计算注意力，后者让所有帧的所有 token 互相计算注意力。

复杂度核算如下。令 $N$ 为帧数， $M = HW$ 为每帧 patch token 数 (518×518 输入、patch=14 时 $M \approx 1369$ )，注意力按 token 对数计算。

Frame-wise self-attention：每帧内独立做 self-attention，复杂度 $O(M^2)$ 每帧，全部 $N$ 帧合计 $O(N M^2)$ 。
Global self-attention：所有 $N \cdot M$ 个 patch token 之间做 self-attention，token 对数为 $(NM)^2$ ，复杂度 $O(N^2 M^2)$ 。

VGGT 一层 alternating 由两类块顺次构成，总复杂度

\underbrace{O(N M^2)}_{\text{frame-wise}} + \underbrace{O(N^2 M^2)}_{\text{global}} = O(N^2 M^2 + N M^2)

注意 global 项写作 $O(N^2 M^2)$ 而非 $O((NM)^2)$ 没有区别——这两者代数恒等，写法不同只是强调因子。原文献意图说明的是：如果把 frame-wise attention 替换为同样规模的 global attention，每层仍是 $O(N^2 M^2)$ ，alternating 设计本身并没有降低 global attention 的渐近复杂度。它降低的是常数因子与显存峰值：frame-wise 层在 batch 维度上完全并行，KV cache 只需保存单帧，不必驻留全部 $NM$ token。在 $N=20$ 、 $M=1369$ 时，frame-wise 一层的注意力矩阵峰值显存是 global 一层的 $1/N = 1/20$ 。这才是真正的节省。

那么它解决了什么问题？纯 global attention 在前向上没有显式的局部归纳偏置——24 层之后跨帧信息混合得很彻底，但单帧内部的几何细节可能被全局上下文稀释。纯 frame-wise 永远无法建立跨视图对应。交替方案以可承受的显存预算保留两种机制：每一个 global 层结束后立刻接一个 frame-wise 层把跨视图信息往帧内压实，反过来每一个 frame-wise 层结束后立刻接一个 global 层把帧内更新散播给其它帧。论文 Table 5 的消融 (本文 3.4 节) 直接证明了这一点。

3.3 五个预测头

经过 trunk 之后 token 被分发到五个头：

Camera Head：从相机 token $\{\mathbf{c}_i\}$ 读取，输出每帧外参 (四元数 + 平移) 与内参 (焦距、主点)。
Depth DPT Head [10]：从 patch token 读取，输出逐像素深度。
Point Map DPT Head：同样从 patch token 读取，但独立参数化，直接输出帧局部坐标系下的 3D 点。
Track Head：跨帧的 2D 点轨迹，用于配合外部光流或匹配监督。
Confidence Head：与深度/点图同分辨率的置信度图。

为什么相机与稠密几何要分头？相机参数活在 $\mathrm{SE}(3)$ 这个 6 维李群上，深度图是 $H \times W$ 的稠密标量场。两类输出的统计结构、损失尺度、对噪声的鲁棒性都不一样。把它们塞进同一个解码器会强迫网络同时建模两种截然不同的输出分布。分头之后共享 trunk 仍保证两者互相约束。

4. 过完备预测：从 Table 6 与 Table 3 看到的现象

VGGT 训练时同时回归 $\{D, g, P, \text{track}\}$ 四类量。三类几何量之间存在恒等式 $P = g \cdot D \cdot \tilde{\mathbf{x}}$ ——理论上只回归两个即可。论文要论证的是：把恒等式约束的几何量全部作为预测目标，比只预测最小子集训练效果更好；推理时从深度+相机组合出点图，比直接预测点图更准。

4.1 Table 6: 多任务消融

VGGT 论文 Table 6 在 ETH3D 数据集上消融三个损失项，指标是稠密点图的 Accuracy、Completeness、Overall (均为距离误差，越低越好)：

$\mathcal{L}_{\text{camera}}$	$\mathcal{L}_{\text{depth}}$	$\mathcal{L}_{\text{track}}$	Acc. ↓	Comp. ↓	Overall ↓
off	on	on	1.042	0.627	0.834
on	off	on	0.920	0.534	0.727
on	on	off	0.976	0.603	0.790
on	on	on	0.901	0.518	0.709

来源：Wang et al., VGGT, CVPR 2025, Table 6。

最具诊断价值的是去掉哪一项造成的退化最大。去掉相机监督让 Overall 从 0.709 涨到 0.834 (+17.6%)，远超去掉深度的 +2.5% 和去掉轨迹的 +11.4%。这与一个朴素直觉冲突：稠密点图任务的目标是稠密点云，深度图本身就是稠密的、像素对齐的，相机参数只是 6+4 个标量，按理说稠密监督应该是主导。但实验结果反着：相机损失对点图精度的贡献比深度损失大一个量级。一个解释是相机参数承担了"几何全局一致性"这个稠密损失无法直接施加的约束——深度图可以在每个像素上独立正确而在全局尺度上互相冲突，而正确的相机参数强迫所有帧的深度共享一个尺度。三者共同监督时网络被迫学到一个内部一致的几何表征。

4.2 Table 3: 组合 vs 直接

更反直觉的是推理阶段。VGGT 给点图准备了一个专用的 DPT 头，本意是让网络直接学到端到端的点图预测能力。但当作者把"直接预测的点图"与"先预测深度再用预测的相机做反投影得到的点图"对比时：

Method	Acc. ↓	Comp. ↓	Overall ↓	推理时间
DUSt3R [2]	1.167	0.842	1.005	~7s
MASt3R [3]	0.968	0.684	0.826	~9s
VGGT (Point head)	0.901	0.518	0.709	~0.2s
VGGT (Depth + Cam)	0.873	0.482	0.677	~0.2s

来源：Wang et al., VGGT, CVPR 2025, Table 3 (ETH3D)。

直接预测点图与"深度+相机反投影"的差距：Overall 从 0.709 降到 0.677，相对改善 4.5%。这不是噪声，4.5% 在 ETH3D 上对应几十名次的排名差距。原作者的原话是 “decomposing a complex task (point map estimation) into simpler subproblems (depth map and camera prediction)"。

用自然语言表述这个发现：过完备预测在 ETH3D 点图重建的 Overall 指标上让组合预测显著优于直接预测，差距来自把"局部几何 (深度) + 全局几何 (相机)“分别求解再合成，比让一个头同时处理两种尺度更稳定。

把原文那个写作 $P_{\text{composed}} = f(D, g) > P_{\text{direct}}$ 的不等号换成上面这段自然语言——原写法把两种点图的精度比较硬塞进一个标量大小不等号，符号上是不严谨的。

4.3 为什么过完备策略有效：几何先验从算法转移到了网络

这一节是本文的作者视角。

经典 SfM 流程里有一个看起来不起眼但承担重活的步骤：对极几何约束 (epipolar constraint) 检查。两个相机看同一个 3D 点，这个点在两幅图像上的投影必须满足 $\mathbf{x}_2^T F \mathbf{x}_1 = 0$ ，其中 $F$ 是基础矩阵。SfM 用 RANSAC 反复抽样估计 $F$ ，把不满足这条约束的匹配判为外点剔除。这条约束并非可学习参数——它来自针孔相机模型 + 刚体场景假设，是一条硬编码的几何先验。

VGGT 没有显式写出对极约束，但 Table 6 显示加入相机损失带来的提升占了去掉任何单项中的最大份额。这意味着：网络在学习同时预测相机与深度时，被迫在内部表征里建立起类似对极约束的全局一致性机制。损失函数 $\mathcal{L}_{\text{camera}}$ 强制相机参数与 ground truth 对齐，损失 $\mathcal{L}_{\text{depth}}$ 强制深度图与 ground truth 对齐，两者共同存在时，点图损失 $\mathcal{L}_P$ 沿恒等式 $P = g \cdot D \cdot \tilde{\mathbf{x}}$ 把梯度同时反传给相机头与深度头——网络只能找到一组让两个头同时正确且互相一致的参数。这套自洽性约束正是对极几何在学习目标里的等价物。

换言之，VGGT 把 3D 重建的传统几何先验从算法转移到了网络架构本身。RANSAC 检查 epipolar constraint 是 hand-crafted prior，VGGT 的过完备多任务训练是 learned prior，但两者实现的都是同一件事：用 3D 重建问题的内在几何结构 (恒等式 + 投影关系) 把网络的可行解空间压窄到几何上自洽的子流形。区别在于经典流程把先验写成 if-else 与几何代数，VGGT 把它写成损失函数的耦合关系，让 SGD 自动找到满足所有耦合的参数点。

这个视角也解释了组合预测为什么比直接预测更准。直接预测点图相当于让网络在一个不被恒等式约束的输出空间里直接拟合 ground truth，模型可以利用所有可用容量去记忆数据。组合预测相当于让网络在被恒等式约束的子空间内拟合 ground truth——容量更小但解一定几何自洽。当测试分布与训练分布有偏移时，“几何自洽"是更强的归纳偏置，泛化得更好。Table 3 上 4.5% 的差距正是这个归纳偏置带来的额外鲁棒性。

更进一步，把 VGGT 与 Depth Anything 3 [4] 对照能看到表示哲学的差异。VGGT 的几何编码是 dense over-parametrized 的：每像素深度 + 每像素点图 + 每帧相机参数 + 每像素置信度，四个量之间有恒等式约束因此存在冗余。DA3 的 depth-ray 是 minimal sufficient 的：每像素一个深度标量 + 一个方向向量，刚好够还原 3D 点，没有冗余。两种表示对应两种工程哲学——稠密表征容忍信息冗余以换取直接可用 (任何下游任务都能从冗余里挑自己需要的)，稀疏表征追求最小充分以换取可组合 (表征本身就是几何上规范化的接口)。哪种更好取决于下游：要做新视角合成或 BEV 投影，VGGT 的稠密输出可以直接喂进 NeRF [11] 或 Gaussian Splatting [12] 的重建流程；要做尺度统一的多任务系统，DA3 的最小表征更易复用。VGGT 与 DA3 在 reconstruct 与 measure 两个维度上正好示范了过完备与最小充分两种范式如何各自走到自己的极致。

5. 实验：在静态场景之外它在哪里失效

VGGT 在 Co3Dv2、DTU、ETH3D、ScanNet、7-Scenes 等基准上全面 SOTA，论文图表充分。本文不重复列表，只指出预期的失效域。

VGGT 的训练数据集合 (Co3D、MegaDepth、ScanNet++、BlendedMVS 等) 共享一个底层假设：场景是 Lambertian 漫反射、近似刚性、纹理充足。这与 VGGT 的内部归纳偏置一致——稠密点云表征隐含"每个像素对应一个稳定的 3D 点”，恒等式 $P = gD\tilde{\mathbf{x}}$ 假设深度是良定义标量。任何破坏这些假设的场景都会让模型退化：

透明物体：玻璃杯的深度不是良定义的，视线穿过表面到达背后的物体。VGGT 会在透明区域产生不确定的预测，置信度头通常能标出这个区域但不会自动修复。

镜面反射：镜中的虚像满足光路反射定律，几何上是"对相机来说在镜面后方”，但实际不存在物理实体。VGGT 的稠密点云无法区分实像与虚像，会在镜面后方生成幽灵点。

动态场景：VGGT 假设所有帧观察同一个静态 3D 场景。一辆经过路口的车在不同帧里占据不同位置，违反刚性假设。轨迹头能部分缓解但无法解决——动态物体的"3D 点"在世界坐标系里随时间变化，不能用单一点图表示。

这些失效模式在自动驾驶场景里全部存在：挡风玻璃、湿滑路面的镜面反射、移动车辆与行人。VGGT 的过完备策略提供了一个天然的不确定性信号：在容易失败的区域，直接预测的点图与组合预测的点图分歧会增大，差异本身可以作为检测器。Table 3 上 4.5% 的全局差距在失败区域可能放大到 50% 以上，足以触发降级 (回落到 LiDAR 或停止使用该区域的几何输出)。

6. 与系列其它三维的关系

VGGT 占据 reconstruct 维度。

与 predict (V-JEPA 2.1)：V-JEPA 在潜空间预测时间演化，VGGT 在单时刻反演空间结构。两者表征的对象互补——V-JEPA 不关心几何度量，VGGT 不关心时间动力学。一种自然的组合是把 VGGT 的几何输出作为 V-JEPA 潜空间的额外条件，让时间预测受几何约束。具体参见 V-JEPA 2.1 dense features 与几何 grounding 的关系。
与 simulate (Wan2.2)：Wan2.2 在像素空间生成未来视频，几何一致性是其根本难题——预测的未来帧常含微妙的几何畸变 (车辆扭曲、透视偏移)。VGGT 路径与之相反：先回到几何空间再投影，几何一致性由构造保证而非由生成模型学习。参见视频世界模型的边界。
与 measure (DA3)：第 4.3 节已展开。dense over-parametrized 与 minimal sufficient 是两种工程哲学，VGGT 与 DA3 各占一极。参见 Depth Anything 3 的几何接地。
数学基础：稠密点图与深度图之间的冗余可以通过 SVD 在低秩子空间表示，相关的低秩近似工具参见 SVD 与低秩近似。

四个维度构成对世界模型这个概念的四种正交切片：从同一组多视图输入出发，predict 关心潜空间时间外推、simulate 关心像素空间动作条件生成、measure 关心最小充分几何接口、reconstruct 关心完整 3D 几何反演。没有任何一个维度足以独立支撑下游应用——自动驾驶同时需要四种。

7. 局限与开放问题

分辨率瓶颈：VGGT 输入 518×518。车载相机原始分辨率通常在 1920×1080 至 3840×2160 之间。下采样到 518 后，远距离行人 (50 米外 < 30 像素) 几乎消失。直接扩大输入会被 global attention 的 $O(N^2 M^2)$ 复杂度按平方惩罚。Sliding window 或 token compression 都是工程方向，但与 VGGT 的全局一致性优势直接冲突——窗口化必然丢失跨远距帧的对应。

帧数扩展： $N$ 帧的 global attention 复杂度按 $N^2$ 增长。论文 demo 多在 $N \leq 32$ ，6-8 路相机的车载场景 (10 Hz × 5 秒 × 6 路 = 300 帧) 接近 $10^5$ 量级的 token 总数，远超当前架构的容量。Register token 的多尺度压缩、稀疏 attention pattern、流式增量更新都是研究方向，但目前没有公开结果证明可扩展到这个量级。

动态场景：第 5 节讨论的根本失效模式。可能的方向是把场景显式分解为静态主结构与独立运动的物体，对每个动态实例单独建几何 (类似 NeRF 系列的 dynamic scene 扩展)。但这把 VGGT 的"单次前向重建一切"承诺破坏了——需要一个前置的运动分割模块，又退回到分阶段流程。

与生成模型的耦合：把 VGGT 的几何输出喂进 Gaussian Splatting 或 NeRF 做新视角合成是直接的工程实践，但端到端联合训练 (几何反演与渲染前向同时优化) 仍是开放问题。理论上恒等式约束在两个方向都成立，应该可以构造对称损失，但优化稳定性、内存预算都未在公开文献中解决。

References

[1] Wang, J., Chen, M., Karaev, N., Vedaldi, A., Rupprecht, C., Novotny, D. (2025). “VGGT: Visual Geometry Grounded Transformer.” CVPR 2025 Best Paper. arXiv:2503.11651

[2] Wang, S., Leroy, V., Cabon, Y., Chidlovskii, B., Revaud, J. (2024). “DUSt3R: Geometric 3D Vision Made Easy.” CVPR 2024. arXiv:2312.14132

[3] Leroy, V., Cabon, Y., Revaud, J. (2024). “Grounding Image Matching in 3D with MASt3R.” ECCV 2024. arXiv:2406.09756

[4] Yang, L., Kang, B., Huang, Z., Wang, Z., Xu, X., Feng, J., Zhao, H. (2025). “Depth Anything V3: Recovering the Visual Space from Any Views.” arXiv:2511.10647

[5] Oquab, M., Darcet, T., Moutakanni, T., Vo, H., Szafraniec, M., Khalidov, V., et al. (2023). “DINOv2: Learning Robust Visual Features without Supervision.” TMLR 2024. arXiv:2304.07193

[6] Schönberger, J. L., Frahm, J.-M. (2016). “Structure-from-Motion Revisited.” CVPR 2016. openaccess.thecvf.com — 原始 COLMAP 论文，前 arXiv 时代。

[7] Triggs, B., McLauchlan, P. F., Hartley, R. I., Fitzgibbon, A. W. (2000). “Bundle Adjustment — A Modern Synthesis.” Vision Algorithms: Theory and Practice, Springer LNCS 1883. semanticscholar.org — 捆集调整经典综述，无 arXiv 版本。

[8] Assran, M., Bardes, A., Fan, D., Kirsch, A., Garrido, Q., Ballas, N., et al. (2025). “V-JEPA 2: Self-Supervised Video Models Enable Understanding, Prediction and Planning.” arXiv:2506.09985

[9] Wan Team, Alibaba Tongyi Lab (2025). “Wan: Open and Advanced Large-Scale Video Generative Models.” arXiv:2503.20314

[10] Ranftl, R., Bochkovskiy, A., Koltun, V. (2021). “Vision Transformers for Dense Prediction.” ICCV 2021. arXiv:2103.13413 — DPT 原文，VGGT 的 dense head 设计来源。

[11] Mildenhall, B., Srinivasan, P. P., Tancik, M., Barron, J. T., Ramamoorthi, R., Ng, R. (2020). “NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis.” ECCV 2020. arXiv:2003.08934

[12] Kerbl, B., Kopanas, G., Leimkühler, T., Drettakis, G. (2023). “3D Gaussian Splatting for Real-Time Radiance Field Rendering.” SIGGRAPH 2023. arXiv:2308.04079

1. 动机：传统几何重建在什么地方失效#

2. 形式化：把渲染方程倒着求解#

3. 架构：DINOv2 trunk + Alternating Attention + 五头输出#

3.1 Trunk: DINOv2 patchify#

3.2 Alternating Attention 与复杂度#

3.3 五个预测头#

4. 过完备预测：从 Table 6 与 Table 3 看到的现象#

4.1 Table 6: 多任务消融#

4.2 Table 3: 组合 vs 直接#

4.3 为什么过完备策略有效：几何先验从算法转移到了网络#

5. 实验：在静态场景之外它在哪里失效#

6. 与系列其它三维的关系#

7. 局限与开放问题#

References#

相关文章