世界模型与FlashWorld：从“在梦中学习“到秒级3D场景生成

文章转载自： 敢敢AUTOHUB

1. 世界模型

1.1 什么是世界模型

世界模型是一种交互式预测模型，在动作的条件下模拟时空环境。与大语言模型（LLM）预测句子中的下一个词不同，世界模型预测的是下一个状态——即当前状态在接收到控制输入后的即时未来。用更简洁的表述：LLM学习语言的结构，世界模型学习因果的结构。

这个定义中最关键的词是"动作"。标准视频模型基于概率预测下一帧 ，而世界模型基于干预预测下一个状态 。那个 （t时刻的动作）是区分世界模型与视频生成模型的分界线。视频模型像一个你只能旁观的梦，世界模型则像清醒梦（lucid dream）——你可以在其中采取行动并观察后果。

想象接球时发生了什么。你的眼睛接收一个场景：投球者的手臂、飞行中的球、风、刺眼的阳光。从这些感官数据的洪流中，你的大脑构建了一个关于正在发生什么的压缩模型，关键是，还有即将发生什么的模型。它预测球在未来几百毫秒内的轨迹，然后向你的手发送一个运动指令。你接住了球。整个循环——观察、预测、行动——在不到一秒的时间内完成，不涉及任何语言或"思考"。世界模型在计算上做的正是同样的事情。

1.2 为什么语言和代码不够

2026年3月，科技博客Not Boring的作者Packy McCormick与General Intuition CEO Pim De Witte联合发表了一篇约两万英文字的长文"World Models: Computing the Uncomputable"，其中有一个生动的思想实验：试着仅用文字描述拍手这个动作——双手在空间中的位置、以皮秒为单位的变化、接触点、声音、手掌如何挤压对方、两掌之间的空气发生了什么。你做不到。语言是对现实一种极度有损的压缩。

代码呢？代码是一种非常精确的语言，但要编写一个能描述曼联比赛中数千名球迷行为的模拟程序，在传统计算中至少是一个  的问题。每个人、每面旗帜、每把椅子、每个球，都必须被显式计算，而且它们之间的交互也需要计算。

世界模型绕过了这个问题。它将那些动态的、在计算上难以大规模模拟的情况，压缩成神经网络中的一次固定成本操作。整个体育场作为一次固定成本的前向传播被模拟出来。场景的复杂度不会让"引擎"在推理时指数级地慢下来，因为世界的模式已经在训练阶段被吸收进了权重。

赫尔曼·黑塞在1946年获诺贝尔文学奖的小说《玻璃球游戏》中描绘了一个致力于纯粹思想的知识乌托邦卡斯塔利亚。主角约瑟夫·克内希特最终选择离开这个完美的符号世界，走向混乱的、具身的、不可预测的现实。McCormick在文中写道："大语言模型就是我们的卡斯塔利亚人。它们是符号的精湛操弄者，但完全运作在表征的领域。它们能描述拍手，但不能拍手。"

1.3 动作：终极压缩形式

世界模型背后的一个关键洞察是：动作是终极压缩形式。

考虑当你决定向左迈步避开水坑时发生了什么。你的大脑处理了视觉场景（人行道、水坑、周围的人、路缘、驶来的公交车），预测了即时未来，评估了选项，然后选择了一个。一个外部观察者看不到你脑袋里面的东西，不知道你到底在想什么。他们不需要知道。他们看到所有那些近乎瞬时计算的输出：向左迈步。

对计算机而言，动作是绕过模拟成本的作弊码。如果人类大脑比最好的LLM效率高得多，那么我们可以通过观察人类如何回应环境中无数变量来几乎免费获得所有那些计算。每一个动作携带了足够的信息来预测接下来会发生什么，直到下一个动作更新画面。

在传统模拟引擎中，每一种可能的行为都必须被编码。如果你想让一千个球迷对进球做出逼真反应，你需要为每种类型的反应写规则。计算成本随着Agent数量和交互复杂度扩展。在世界模型中，成本固定为一次神经网络传播。随机的、混乱的、人类的现实已经被烘烤进了学习到的权重中。

1.4 世界模型简史：四个浪潮

世界模型的历史可以追溯到1990年。于尔根·施密德胡伯（LSTM之父）发表了《让世界可微分》，提出构建一个循环神经网络，赋予它两个任务：学习预测模拟世界中接下来会发生什么，以及用这个模拟世界来训练一个Agent在其中行动。第二年，Richard Sutton在《Dyna》中主张学习、规划和反应应该统一在一个单一架构中。

但在1990年，全世界的计算能力大约是今天的百万亿分之一。这两篇论文在当时几乎就是科幻。

第一浪潮（2018-2019）："这真的能行吗？"

2018年3月，David Ha和Schmidhuber发表了题为《世界模型》的论文，问了一个问题：Agent能在自己的梦中学习吗？他们构建了一个有三个组件的系统：视觉模型（V）将原始像素压缩成紧凑表示，记忆模型（M）学习预测接下来会发生什么，控制器（C）决定做什么。他们让Agent完全在世界模型幻想出的梦境中练习，然后将学到的策略迁移回实际环境。它成功了。

同期，SimPLe算法在Atari 100k基准上证明，仅用10万步真实环境步骤（大约两小时的游戏时间）就能学会玩26个Atari游戏。

第二浪潮（2020-2022）："世界模型能达到人类水平吗？"

Danijar Hafner在Google DeepMind开发的DreamerV2成为第一个在55个游戏的Atari基准上达到人类水平的世界模型Agent，完全在想象中训练，在单块GPU上。

同年，MuZero在《Nature》上发表。它采用了几乎完全相反的哲学方法——从未生成任何可观察的东西，完全在自己发明的抽象潜在表征中规划。MuZero纯粹通过观察和结果，从零开始学习了包括规则、游戏动态和价值函数在内的一切，在Go、国际象棋和将棋上匹配了AlphaZero，同时还泛化到了57个Atari游戏。

MuZero的成功意味着该领域出现了两个对立的思想流派：生成式世界模型（产生可观察的未来）和潜在世界模型（在抽象空间中预测）。

2022年，Yann LeCun发表了《通向自主机器智能的路径》，提出了JEPA（联合嵌入预测架构），反对完全生成像素，主张预测未来状态的抽象表征，刻意丢弃不可预测的视觉细节。

同年，IRIS将世界建模重新定义为在图像token学习词汇上的语言建模，把LLM的扩展特性直接带入了世界建模。IRIS是第一个在与人类相同的可用游戏数据量下、通过想象学习方法超过人类的模型。

第三浪潮（2023-2024）："世界模型能真正实现交互吗？"

GAIA-1（2023年）在Wayve开发，将序列建模方法扩展到90亿参数并在真实世界驾驶视频上训练，确认了LLM中观察到的扩展定律也适用于视觉世界模型。

DIAMOND（2024年）使用扩散模型直接预测未来帧，视觉保真度有了实质性提升，而这种丰富度直接转化为更好的Agent表现。DIAMOND在反恐精英游戏数据上训练，从大约87小时的素材、在单块GPU上，产生了一个完全交互的、可玩的神经游戏引擎。

Google DeepMind的Genie（2024年）是一个110亿参数的模型，在未标注的2D平台游戏互联网视频上训练，完全从零学习了一个动作空间。

第四浪潮（2025-2026）："模型能在真实世界中行动吗？"

Comma.ai完全在学习到的世界模型内部训练了一个驾驶策略，并将其部署在openpilot中——这可以说是第一个由世界模型训练的Agent驱动的消费产品。

Meta的V-JEPA 2在超过一百万小时的视频上通过自监督掩码预测进行预训练，仅在62小时机器人数据上微调，就在新环境中零样本部署在真实的Franka机械臂上执行取放任务。

GAIA-2（2025年3月）将扩散方法推向了多摄像头自动驾驶模拟，可以再现真实驾驶的全部复杂性。

1.5 当前格局：三条技术路线的竞争

当前世界模型领域存在三条主要技术路线，它们从不同方向逼近同一个目标——产生能泛化并在各种环境中做事的Agent。

潜在世界模型（Latent World Models）

以Yann LeCun的JEPA为代表。不预测像素，而是在抽象的压缩空间中做预测，刻意丢弃不可预测的视觉细节。优势是计算效率高、规划速度快。劣势是更难评估（你不能看着输出直观判断它是否合理）、迭代速度慢、存在表征坍缩问题。AMI Labs拿着10.3亿美元赌这条路线。

生成式世界模型（Generative World Models）

产生人类可观察的、交互式的未来。优势是可解释性强、泛化能力好（理论上捕获了所有视觉信息）。劣势是计算成本高。General Intuition、Wayve、Decart、Runway都在这条路线上。Google DeepMind的Genie 3也属于此类。

VLA（视觉-语言-动作模型）

以Physical Intelligence为代表。取一个理解场景的VLM，加上一个动作头，将人类语言指令翻译成机器人指令。优势是可以复用LLM的巨大基础设施和数据。劣势是物理动作不能干净地映射到token，分布外泛化较差。Physical Intelligence以56亿美元估值融资6亿美元，Skild也在这条路线上。

这三条路线并非完全对立。正如McCormick所写："我个人不认为VLA和世界模型真的在竞争。它们试图从不同方向达到在物理世界中行动。VLA是语言优先的，世界模型是视频-动作优先的。两者可能会趋同。"

1.6 FlashWorld在世界模型版图中的位置

在这个宏大的图景中，FlashWorld扮演着一个特殊而关键的角色：高效的3D资产生成器。

世界模型需要大量的3D交互数据来训练。GWM（Gaussian World Models）论文展示了如何将3D高斯表示深度嵌入到动力学学习的循环中，但它需要大量的3D场景数据。FlashWorld可以在几秒钟内从文本或图像生成多样化的3D场景，为世界模型提供近乎无限的训练环境。

这种组合指向了一个更宏大的愿景：Real-to-Sim-to-Real闭环。机器人拍摄真实环境图片，FlashWorld将其扩展为完整的3D场景，世界模型在重建的场景中学习动力学并训练策略，最终将策略部署回真实世界。

2. FlashWorld技术深度解析

2.1 问题定义：3D生成的"不可能三角"

在FlashWorld出现之前，3D场景生成领域长期面临一个根本性的矛盾。现有方法大致分为两条路线：多视角（MV）导向的扩散方法和3D导向的直接生成方法。前者能够生成画质极高的多视角图像，但各视角之间缺乏几何一致性，因为它们本质上是独立生成的二维图像；后者直接输出3D高斯表示（3D Gaussian Splatting, 3DGS），天然保证了几何一致性，但生成的画面往往模糊、细节不足。

更关键的问题在于速度。以CAT3D为代表的高质量方法需要77分钟才能完成一次生成，Director3D需要7分钟，即便是相对快速的Prometheus也需要15秒。这样的速度在实际应用中几乎不可接受——无论是游戏资产的批量生产、机器人仿真环境的快速构建，还是AR/VR内容的实时创作，都需要秒级的响应。

FlashWorld同时解决了这三个维度的问题：速度（A100上7秒，H100上4秒）、画质（T3Bench IQA评分4.12，远超Director3D的3.24）、以及3D一致性。

Github项目地址：https://github.com/imlixinyang/FlashWorld

图1：FlashWorld整体架构。左侧为双模态预训练阶段，右侧为跨模态后训练阶段。

2.2 核心方法：双模态预训练 + 跨模态蒸馏

FlashWorld的方法论可以用一句话概括：先让同一个模型同时学会两种生成模式，再让高质量的模式"教"一致性好的模式。

双模态预训练（Dual-mode Pre-training）

在预训练阶段，FlashWorld构建了一个基于DiT（Diffusion Transformer）的统一骨干网络，同时支持两种工作模式：

MV导向模式接收带噪声的多视角图像潜在表示，通过DiT Blocks进行去噪，直接输出去噪后的多视角潜在表示，再由VAE解码器还原为像素级图像。优化目标是多视角重建损失 ，关注每个视角图像的视觉质量。

3D导向模式同样接收带噪声的输入，但在DiT Blocks输出之后，额外经过一个3DGS解码器，将特征转换为3D高斯参数（位置、颜色、不透明度、尺度和旋转），然后通过可微分渲染器从新视角渲染出图像。优化目标是3D一致性损失 ，确保从任意视角渲染的结果在几何上是自洽的。

图2：FlashWorld双模态预训练架构。左侧为MV导向模式，右侧为3D导向模式。

关键设计在于：这两种模式共享同一个DiT骨干网络的权重。模型在预训练阶段就同时学到了"如何生成高质量图像"和"如何保持3D一致性"两种能力。

跨模态后训练（Cross-mode Post-training）

预训练完成后，3D导向模式的视觉质量仍然不如MV导向模式。FlashWorld引入了跨模态蒸馏技术来弥合这一差距：冻结MV导向模式作为"教师"，让3D导向模式作为"学生"进行学习。蒸馏的核心机制基于DMD（Distribution Matching Distillation）损失。

图3：不同3D场景生成方法的对比。FlashWorld在速度和质量上均取得显著优势。

直观理解：教师告诉学生"从这个视角看，图像应该长什么样"，学生在保持自身3D一致性的前提下，学习生成与教师同等质量的渲染结果。

此外，后训练阶段还引入了OOD（Out-of-Distribution）Co-training策略，混入大量单张图片和文本Prompt，配合随机采样的相机轨迹，极大提升了模型在开放世界场景下的泛化能力。

图4：Flashworld 去噪流程。模型仅在4个关键步骤进行去噪，即可生成高质量的3D场景。

3. 代码实现深度解析

FlashWorld的开源代码仓库结构清晰，核心文件包括：app.py（推理系统与Web服务）、cli.py（命令行批量生成）、models/（模型定义）、utils.py（工具函数）、quant.py（FP8量化加速）。以下逐一拆解关键实现。

3.1 GenerationSystem：推理流水线的核心

app.py中的GenerationSystem类是整个推理流程的入口。它的初始化过程揭示了FlashWorld的模型组成：

class GenerationSystem(nn.Module):
    def __init__(self, ckpt_path=None, device="cuda:0", ...):
        self.latent_dim = 48          # 潜在空间通道数
        self.temporal_downsample_factor = 4
        self.spatial_downsample_factor = 16  # 480x704 -> 30x44
        self.feat_dim = 1024          # 3D特征维度
        self.denoising_steps = [0, 250, 500, 750]  # 仅4步去噪

        model_id = "Wan-AI/Wan2.2-TI2V-5B-Diffusers"

        # VAE编码器：将图像压缩到潜在空间
        self.vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae")

        # 文本编码器：UMT5，处理文本提示
        self.text_encoder = UMT5EncoderModel.from_pretrained(
            model_id, subfolder="text_encoder")

        # DiT骨干：基于Wan2.2的5B参数Transformer
        self.transformer = WanTransformer3DModel.from_pretrained(
            model_id, subfolder="transformer")

        # 3DGS重建解码器：将特征转换为高斯参数
        self.recon_decoder = WANDecoderPixelAligned3DGSReconstructionModel(
            self.vae, self.feat_dim, ...)

几个值得注意的设计细节。FlashWorld基于万象（Wan）2.2的5B参数视频扩散模型构建，这是一个已经在大规模视频数据上预训练过的模型。latent_dim=48表示潜在空间的通道数，spatial_downsample_factor=16意味着480x704的输入图像在潜在空间中被压缩为30x44的特征图。denoising_steps = [0, 250, 500, 750]定义了仅4步的去噪调度——传统扩散模型通常需要20-50步去噪，FlashWorld通过跨模态蒸馏将步数压缩到4步，这是其速度优势的关键来源之一。

3.2 反馈机制：迭代精化的秘密

FlashWorld的推理过程并非简单的单次前向传播，而是包含一个精巧的反馈循环。在generate方法中：

for i in range(len(self.denoising_steps)):
    t_ids = torch.full((noisy_latents.shape[0],),
                       self.denoising_steps[i], device=self.device)
    t = self.timesteps[t_ids]

    if self.use_feedback:
        # 将上一步的预测结果作为额外条件输入
        _condition_latents = torch.cat(
            [condition_latents, prev_feats, prev_latents_pred], dim=1)

    if i < len(self.denoising_steps) - 1:
        out = self.forward_generator(
            noisy_latents, raymaps, _condition_latents, t,
            text_embeds, cameras, cameras,
            image_height, image_width, need_3d_mode=True)

        latents_pred = out["3d"]  # 使用3D模式的预测

        if self.use_feedback:
            prev_latents_pred = latents_pred
            prev_feats = out['feat']

        # 在预测结果上重新加噪，进入下一步
        noisy_latents = self.scheduler.scale_noise(
            latents_pred,
            self.timesteps[...self.denoising_steps[i + 1]...],
            torch.randn_like(noise))
    else:
        # 最后一步：直接输出3DGS参数，跳过渲染和重编码
        ...

这段代码展示了FlashWorld的核心推理逻辑：在每一步去噪中，模型不仅输出当前步的预测结果，还将上一步的预测潜在表示（prev_latents_pred）和特征（prev_feats）作为额外条件输入到下一步。这种反馈机制使得后续步骤能够在前一步的基础上进行精化，而不是从零开始预测。

在前3步（i=0,1,2）中，模型执行完整的3D模式推理：DiT去噪 -> 3DGS解码 -> 渲染 -> VAE编码回潜在空间。最后一步（i=3）则跳过渲染和重编码，直接输出最终的3DGS参数，避免了不必要的计算开销。

3.3 forward_generator：双模态输出的实现

forward_generator方法是理解FlashWorld双模态设计的关键：

def forward_generator(self, noisy_latents, raymaps, condition_latents,
                      t, text_embeds, cameras, render_cameras,
                      image_height, image_width, need_3d_mode=True):
    # DiT前向传播：输入 = 噪声潜在表示 + Ray Map + 条件
    out = self.transformer(
        hidden_states=torch.cat(
            [noisy_latents, raymaps, condition_latents], dim=1),
        timestep=t,
        encoder_hidden_states=text_embeds,
        return_dict=False,
    )[0]

    # 分离2D预测（48通道）和3D特征（1024通道）
    v_pred, feats = out.split([self.latent_dim, self.feat_dim], dim=1)

    # 2D模式：直接从噪声预测中恢复潜在表示
    sigma = ...
    latents_pred_2d = noisy_latents - sigma * v_pred

    if need_3d_mode:
        # 3D模式：特征 + 潜在表示 -> 3DGS参数 -> 渲染 -> 重编码
        scene_params = self.recon_decoder(feats, latents_pred_2d, cameras)
        images_pred, _ = self.recon_decoder.render(
            scene_params, render_cameras, ...)
        latents_pred_3d = self.vae.encode(images_pred)

    return {
        '2d': latents_pred_2d,    # MV模式输出
        '3d': latents_pred_3d,    # 3D模式输出
        'scene': scene_params,     # 3DGS参数
        'feat': feats              # 用于反馈的特征
    }

DiT的输出被分为两部分：前48个通道是速度预测v_pred，用于2D模式的去噪；后1024个通道是3D特征feats，用于3DGS重建。这种设计使得同一个Transformer同时服务于两种模式，而不需要两个独立的网络。

3.4 PixelAligned3DGS：像素对齐的高斯生成

3DGS重建的核心在于models/reconstruction_model.py中的PixelAligned3DGS类。它将每个像素位置映射为一组3D高斯参数：

class PixelAligned3DGS(nn.Module):
    def __init__(self, embed_dim, sh_degree=2,
                 num_points_per_pixel=2, ...):
        # 每个像素生成的高斯参数
        self.gaussian_channels = [
            3 * (sh_degree + 1) ** 2,  # 球谐系数（27维，2阶）
            2,   # UV偏移
            1,   # 深度
            1,   # 不透明度
            3,   # 尺度（xyz三个方向）
            4,   # 旋转（四元数）
        ]
        # 每个像素生成2个高斯点
        self.gs_proj = nn.Conv2d(
            embed_dim,
            num_points_per_pixel * sum(self.gaussian_channels),
            3, 1, 1)

    def forward(self, x, cameras):
        local_gaussian_params = self.gs_proj(x)
        features, uv_offset, depth, opacity, scales, rotations, mask = 
            local_gaussian_params.split(self.gaussian_channels, dim=-1)

        # 从相机参数和深度计算3D位置
        rays_o, rays_d = create_rays(
            cameras, uv_offset=uv_offset, h=h, w=w)
        depth = trunc_exp(depth)  # 截断指数，确保深度为正
        xyz = rays_o + depth * rays_d

        # 尺度与像素大小成正比
        pixel_size = torch.sqrt(fx.pow(2) + fy.pow(2)) * depth
        scales = (torch.sigmoid(scales) *
                  (scale_range[1] - scale_range[0]) +
                  scale_range[0]) * pixel_size

        rotations = F.normalize(rotations, dim=-1)

        return torch.cat(
            [xyz, opacity, scales, rotations, features], dim=-1)

几个精妙的设计值得关注。num_points_per_pixel=2意味着每个像素位置生成2个3D高斯点，在保持计算效率的同时提供了足够的几何表达能力。深度值通过trunc_exp（截断指数函数）激活，确保深度始终为正值。高斯的尺度与像素大小成正比（pixel_size * sigmoid(scales)），这使得近处的高斯自然地比远处的更小，符合透视投影的几何关系。

3.5 Ray Map：相机感知的条件输入

FlashWorld使用Ray Map作为相机位姿的条件输入，这是其实现多视角一致性的关键机制：

def create_raymaps(cameras, h, w):
    rays_o, rays_d = create_rays(cameras, h, w)
    # 射线方向 + 射线原点在射线方向上的投影残差
    raymaps = torch.cat([
        rays_d,
        rays_o - (rays_o * rays_d).sum(dim=-1, keepdim=True) * rays_d
    ], dim=-1)
    return raymaps

Ray Map是一个6通道的特征图，前3个通道是每个像素对应的射线方向，后3个通道是射线原点相对于射线方向的正交分量。这种表示方式比直接使用相机矩阵更加紧凑，同时为DiT提供了逐像素的空间位置信息。

3.6 FP8量化：推理加速的工程优化

quant.py实现了FP8动态量化，这是FlashWorld在工程层面实现快速推理的重要手段：

def per_tensor_quantize(tensor: torch.Tensor):
    finfo = torch.finfo(torch.float8_e4m3fn)
    min_val, max_val = tensor.aminmax()
    amax = torch.maximum(min_val.abs(), max_val.abs())
    scale = finfo.max / amax.clamp(min=1e-12)
    qweight = (tensor * scale).clamp(min=finfo.min, max=finfo.max)
    qweight = qweight.to(torch.float8_e4m3fn)
    scale = scale.float().reciprocal()
    return qweight, scale

class FP8DynamicLinear(torch.nn.Module):
    def forward(self, x):
        qinput, x_scale = per_tensor_quantize(x)
        output = fp8_gemm(
            A=qinput, A_scale=x_scale,
            B=self.weight, B_scale=self.weight_scale,
            bias=self.bias, out_dtype=x.dtype,
            native_fp8_support=self.native_fp8_support)
        return output

FlashWorld将DiT中所有Transformer Block内的Linear层替换为FP8量化版本。权重在初始化时被静态量化为FP8格式，激活值在每次前向传播时动态量化。在支持FP8的GPU（如H100，计算能力>=9.0）上，这利用了硬件原生的torch._scaled_mm指令，将矩阵乘法的吞吐量提升约2倍，同时显存占用减半。

3.7 可微分渲染与输出格式

FlashWorld使用gsplat库实现3D高斯的可微分渲染，支持梯度检查点以在训练时节省显存。渲染过程将3D高斯参数投影到指定相机视角，通过alpha混合生成RGB图像和深度图。

输出支持三种格式：SPZ（Niantic的压缩高斯格式，文件体积小，适合Web端传输）、PLY（标准点云格式，兼容各种3D软件）、以及MP4视频（通过在关键帧之间插值相机轨迹实现平滑视角过渡）。

def export_gaussians(gaussians, opacity_threshold=0.00,
                     T_norm=None, ply_path=None, spz_path=None):
    xyz, opacity, scale, rotation, feature = gaussians.split(
        [3, 1, 3, 4, (sh_degree + 1)**2 * 3], dim=-1)

    # 反激活函数，转换为标准格式
    opacity = torch.log(opacity / (1 - opacity))  # inverse sigmoid
    scales = torch.log(scales + 1e-8)              # inverse exp

    if spz_path:
        cloud = spz.GaussianCloud()
        cloud.sh_degree = sh_degree
        cloud.positions = xyzs.flatten().cpu().numpy()
        cloud.scales = scales.flatten().cpu().numpy()
        cloud.rotations = rotations[:, [3, 0, 1, 2]].flatten().cpu().numpy()
        cloud.alphas = opacities.flatten().cpu().numpy()
        cloud.colors = f_dc[..., :3].flatten().cpu().numpy()
        cloud.sh = f_dc[..., 3:].flatten().cpu().numpy()
        spz.save_spz(cloud, spz.PackOptions(), spz_path)

4. 快速上手

# 基础依赖
pip install torch==2.6.0 torchvision==0.21.0
pip install triton transformers omegaconf ninja numpy einops

# 核心依赖（特定版本）
pip install git+https://github.com/nerfstudio-project/gsplat.git@32f2a54
pip install git+https://github.com/huggingface/diffusers.git@447e832
pip install git+https://github.com/nianticlabs/spz.git@a4fc69e

# 克隆仓库
git clone <https://github.com/imlixinyang/FlashWorld.git> && cd FlashWorld

# Web界面启动（24GB显存）
python app.py --offload_t5 --offload_transformer_during_vae
# 访问 <http://localhost:7860/app>

# 命令行批量生成
python cli.py --input_dir ./examples --output_dir ./output 
    --video --spz --ply --video_fps 15

CLI模式使用未压缩的高斯参数，渲染质量优于Web界面，适合用作基准对比。

5. GWM与FlashWorld的互补关系

5.1 GWM：将3DGS嵌入动力学学习

GWM（Gaussian World Models）论文提出了一种将3D Gaussian Splatting深度嵌入到机器人操作动力学学习中的方法。它的核心架构包含两个关键组件：

3D Gaussian VAE利用Transformer架构和最远点采样（FPS），将成千上万个高斯点压缩成固定数量（例如 ）的潜在特征。编码过程利用了Cross-Attention：

这确保了模型既能捕捉全局几何，又能保留局部细节。

Latent Diffusion Transformer将未来状态预测建模为条件生成问题：。采用EDM框架来参数化去噪器，使模型既能作为模仿学习的视觉编码器，又能作为模型预测控制的模拟器。

在RoboCasa的多任务模仿学习设置下，GWM相比基线BC-transformer在多个Pick-and-Place任务上取得了显著提升（部分任务成功率从2%提升到20%），证明了显式3D结构确实帮助策略理解了空间关系。

5.2 两者的互补性

FlashWorld和GWM虽然侧重点不同（一个是静态场景生成，一个是动力学预测），但实际上是互补的：

FlashWorld是GWM的"造梦师"。GWM需要大量的3D交互数据来训练，FlashWorld可以快速生成多样化的3D仿真环境，为GWM提供近乎无限的OOD训练数据。

GWM是FlashWorld的"驱动引擎"。FlashWorld生成的是静态3DGS场景，而GWM赋予了这些高斯原语随时间演变的能力（即物理动力学）。

技术趋同。两者都选择了DiT作为核心骨干，并都致力于将3DGS压缩或蒸馏到高效的潜在空间中进行处理。这标志着3D视觉与机器人学习正在向"Latent 3D Diffusion"这一统一范式收敛。

6. 总结

FlashWorld通过双模态预训练和跨模态蒸馏的组合，在3D场景生成领域实现了速度、质量和一致性的统一。其技术路线的核心洞察在于：与其在两种范式之间做取舍，不如让它们在同一个模型中共存，再通过蒸馏将各自的优势融合。

从工程实现的角度看，FlashWorld的代码展现了多项值得借鉴的设计：基于反馈机制的迭代精化、像素对齐的3D高斯生成、FP8动态量化加速、以及灵活的模型卸载策略。