从“转身就穿帮“到 9 FPS 实时漫游：我拆了一遍 Latent 3D Gaussian Memory

关注

原创最新推荐文章于 2026-11-07 21:41:43 发布 40 阅读 AI 写同款· GEO 优化 ›

ORB-SLAM3 class VertexAccBias : public g2o::BaseVertex＜3,Eigen::Vector3d＞ ◄──── EdgeAccRW ──────► VertexAccBias(VAk)（上一关键帧，固定）在纯 IMU 短窗口内，零偏与重力的分解本就病态；陀螺零偏只影响旋转预积分，与视觉观测的旋转部分（相机朝向）直接对应，相对容易估计；加计零偏影响速度、位置预积分，且与重力向量在测量方程中线性组合，存在。会让边刷新用零偏一阶修正后的预积分测量（速度、位置部分）；，视觉残差对零偏的雅可比明明是零，怎么会有信息传过去？刷新依赖零偏的中间项。把视觉信息传递到零偏估计，这句话怎么理解？是安全的，框架会兜底。阅读详情

从今天觉醒,技术赋予每一个人数字生命

从"转身就穿帮"到 9 FPS 实时漫游：我拆了一遍 Latent 3D Gaussian Memory

交互式世界模型（你按方向键，模型实时生成前方画面）最近很火，但自己跑过这类 Demo 的人都见过同一个尴尬场面：在一个房间里转一圈回到原位，墙上的画变了、桌子没了——模型"记不住路"。最近一套名为 L3G-World 的系统把这个问题做到了实时（9 FPS），核心是一个叫 Latent 3D Gaussian Memory（L3G） 的记忆结构。这篇文章我不复述论文，而是用 100 行可运行的 PyTorch 代码，把它的三个关键设计拆给你看。

Abstract artistic visualization of spatial memory:

学完这张路线图，你能： ① 说清世界模型为什么会"转身穿帮"；② 手写一个带 latent 特征的高斯记忆，实现 spawn / refine / 渲染三步；③ 理解 38.6×、359× 这些数字省在哪；④ 知道这套思路的边界。

一、背景与痛点：记忆为什么越来越重

世界模型要"记路"，主流就两条路，各有硬伤：

纯时序上下文：把历史帧塞进 Transformer 的注意力窗口。类比一下：每说一句话都把整段聊天记录重读一遍。流越长，上下文越长，延迟和显存线性膨胀，长程探索直接扛不住。
显式 3D 记忆（点云/高斯 + RGB 渲染）：把记忆渲染成 RGB 图，再喂回视频生成器。问题在于，主流视频生成器吃的是 VAE 压缩后的 latent，不是 RGB。所以每帧都要多跑一次 VAE 编码——相当于把照片洗出来再用扫描仪扫回电脑。这一步就足以让实时性泡汤。

不解决的代价很实际：漫游类应用（游戏、具身智能仿真）里，一致性一崩，沉浸感归零；而跑得动的方案又贵到没法部署。

二、方案设计：两条核心决策

L3G-World 的思路可以压缩成两句话：

记忆应该随"场景大小"增长，而不是随"流长度"增长。 在房间里转 10 圈，记忆不该变厚 10 倍——你看到的一直是同一个房间。
记忆里直接存 VAE latent 特征，渲染出来就是 latent 特征图，跳过 VAE 重编码。 相当于直接用"母语"记笔记，省掉每帧的翻译开销。

架构上，记忆更新器和视频 DiT 交替自回归：DiT 生成新画面 → 更新器从新画面里提炼观测，在新区域 spawn 高斯、在旧区域 refine 高斯 → 记忆渲染成 latent 特征图，作为 DiT 下一步的条件。

我明确放弃的方案：完整复刻官方系统（没有公开权重，诚实起见本文只做概念验证 Demo，不包装成生产方案）；NeRF 式记忆（渲染要逐像素 ray marching，天生慢）；单纯加长上下文窗口（治标不治本）。

三、核心实现：100 行 PyTorch 搭迷你版

环境：Python 3.11 + torch 2.5.1（CPU 即可，pip install torch==2.5.1 --index-url https://download.pytorch.org/whl/cpu）。全部代码保存为 latent_gaussian_memory.py，直接 python latent_gaussian_memory.py 运行。

3.1 数据结构：每个高斯存一个 latent 特征

import torch, math

class LatentGaussianMemory:
    """关键区别：feat 是 VAE latent 特征（这里是 4 维），不是 RGB。"""
    def __init__(self, feat_dim=4, device="cpu"):
        self.feat_dim, self.device = feat_dim, device
        self.xyz     = torch.empty(0, 3, device=device)        # 位置
        self.scale   = torch.empty(0, 1, device=device)        # 尺度（本 Demo 渲染未用到）
        self.opacity = torch.empty(0, 1, device=device)        # 不透明度
        self.feat    = torch.empty(0, feat_dim, device=device) # latent 特征

    def __len__(self): return self.xyz.shape[0]

    @torch.no_grad()
    def spawn(self, xyz, feat, scale=0.5, opacity=0.9):
        n = xyz.shape[0]
        self.xyz     = torch.cat([self.xyz, xyz], 0)
        self.scale   = torch.cat([self.scale, torch.full((n,1), scale, device=self.device)], 0)
        self.opacity = torch.cat([self.opacity, torch.full((n,1), opacity, device=self.device)], 0)
        self.feat    = torch.cat([self.feat, feat], 0)

3.2 记忆更新：新区域 spawn，旧区域 refine

    @torch.no_grad()
    def refine(self, new_xyz, new_feat, thresh=0.8, lr=0.5):
        """观测落在已有高斯附近 -> 滑动平均精修；否则 spawn 新高斯"""
        if len(self) == 0:
            self.spawn(new_xyz, new_feat); return 0, new_xyz.shape[0]
        d = torch.cdist(new_xyz, self.xyz)          # (N_new, N_mem)
        dmin, idx = d.min(dim=1)
        hit = dmin < thresh
        for i in torch.nonzero(hit).flatten().tolist():
            j = idx[i].item()
            self.feat[j]    = (1-lr)*self.feat[j] + lr*new_feat[i]
            self.xyz[j]     = (1-lr)*self.xyz[j]  + lr*new_xyz[i]
            self.opacity[j] = ((1-lr)*self.opacity[j] + lr*0.99).clamp(max=0.99)
        if (~hit).any():
            self.spawn(new_xyz[~hit], new_feat[~hit])
        return int(hit.sum()), int((~hit).sum())

这就是"记忆随场景而非时间增长"的全部魔法：重访旧区域时只 refine，不 spawn。

3.3 直接渲染进 latent 空间 + 主循环

def render_latent(mem, cam_pos, yaw, H=32, W=32, fov=60.0):
    """输出 (C,H,W) 的 latent 特征图 —— 真实系统里它直接进 DiT，无需 VAE 重编码"""
    C = mem.feat_dim
    out = torch.zeros(C, H*W, device=mem.device)
    if len(mem) == 0: return out.view(C, H, W)
    rel = mem.xyz - cam_pos
    cy, sy = math.cos(yaw), math.sin(yaw)
    x =  cy*rel[:,0] + sy*rel[:,2]          # 世界系 -> 相机系
    z = -sy*rel[:,0] + cy*rel[:,2]          # z 朝前
    y =  rel[:,1]
    front = z > 0.1                          # 坑点①：必须先裁掉身后点
    sel = torch.nonzero(front).flatten()
    if sel.numel() == 0: return out.view(C, H, W)
    x, y, z = x[front], y[front], z[front]
    f = 0.5*W / math.tan(math.radians(fov)/2)
    u = torch.round(f*x/z + W/2).long()
    v = torch.round(H/2 - f*y/z).long()
    inside = (u>=0)&(u<W)&(v>=0)&(v<H)
    sel, u, v, z = sel[inside], u[inside], v[inside], z[inside]
    order = torch.argsort(z, descending=True)          # 远->近做 alpha 合成
    trans = torch.ones(H*W, device=mem.device)
    pix = v*W + u
    for k in order.tolist():
        p = pix[k].item()
        a = float(mem.opacity[sel[k],0]) * float(trans[p])
        out[:, p] += a * mem.feat[sel[k]]
        trans[p] *= (1.0 - float(mem.opacity[sel[k],0]))
    return out.view(C, H, W)

if __name__ == "__main__":
    torch.manual_seed(0)
    mem = LatentGaussianMemory(feat_dim=4)
    landmark_xyz  = torch.randn(64,3) * torch.tensor([6.,2.,6.])   # 一个"房间"
    landmark_feat = torch.randn(64,4)                              # 地标的真值 latent

    def observe(cam):
        d = torch.cdist(landmark_xyz, cam[None,:]).squeeze(1)
        vis = d < 8.0
        return (landmark_xyz[vis] + 0.1*torch.randn(vis.sum(),3),
                landmark_feat[vis] + 0.05*torch.randn(vis.sum(),4))

    steps = 40                                   # 相机绕房间走一整圈
    for t in range(steps+1):
        ang = 2*math.pi*t/steps
        cam = torch.tensor([4*math.cos(ang), 0., 4*math.sin(ang)])
        n_ref, n_sp = mem.refine(*observe(cam))
        if t % 10 == 0:
            print(f"step {t:02d} | memory={len(mem):3d} | spawn={n_sp:2d} | refine={n_ref:2d}")

    # 一致性检查：走完一圈后，起点视角的渲染 vs 真值渲染
    cam0, yaw0 = torch.tensor([4.,0.,0.]), math.pi/2     # 面向房间中心
    gt = LatentGaussianMemory(feat_dim=4)
    gt.spawn(landmark_xyz, landmark_feat, opacity=0.99)
    err = (render_latent(mem, cam0, yaw0) - render_latent(gt, cam0, yaw0)).abs().mean()
    print(f"重访视角 latent 平均误差: {err.item():.4f}")

四、效果验证

跑起来后盯两个指标（成功标准写死）：

记忆饱和：第一圈 spawn 很多，第二圈开始 spawn 应掉到接近 0，memory 总数稳定不再涨——这就是"随场景增长"。对照组很简单：把 refine 改成无脑 spawn，你会看到 memory 随步数线性膨胀（40 步 × 每步约 20 个观测），行为退化成传统方案。
重访一致性：最后的 latent 平均误差 应远小于随机特征的均值量级（本设置下 4 维标准正态的逐维 |差| 期望约 0.8），带噪观测下误差应稳定在 0.1 以下。误差大，说明 refine 没收敛或匹配阈值不对。

玩具之上，完整系统的实测数字更有说服力：相比此前最高效的 3D 记忆基线，3D 基元数量最多减少 38.6×，记忆更新快 3.2×，记忆渲染快 359×（渲染提速最猛，正是因为省掉了 VAE 重编码），最终在单卡上跑到 9 FPS 的实时生成，且在长程探索中保持空间一致性。

五、踩坑记录与边界

三个真实会踩的坑：

坑①：相机后方的点没裁。 z<=0 时除法会把 u/v 翻到画面里，渲染图出现诡异"鬼影条纹"，而且不报错。排障：投影前 z > 0.1 掩码。
坑②：匹配阈值单位不一致。 我曾把观测归一化到 [-1,1] 再匹配，阈值却按"米"设 0.8，结果所有观测都命中同一个高斯，记忆塌缩成一个点。排障：打印 dmin 分布，发现值域完全不对——匹配必须统一在世界坐标系。
坑③：torch.cdist 的 N×M 距离矩阵。 高斯到几万级后内存爆炸。Demo 无所谓，上规模必须分块算距离或换近似近邻索引。

边界也要说清楚：本文是概念验证，真实系统的 latent 特征来自训练好的 VAE，更新器是学出来的网络而非最近邻规则；该思路对静态场景天然友好，动态物体（会动的桌椅、行人）需要额外机制；9 FPS 离游戏的 60 FPS 还有距离。下一步值得做的：把 refine 换成可学习模块、给高斯加时间戳处理动态场景、用球谐系数让 latent 特征具备视角相关性。代码在手，坑已标注，轮到你了。