Diffusion on Xiong Jia

SLAT

Wed, 02 Apr 2025 12:01:01 +0800

论文信息

信息概览

CVPR 2025

论文题目： Structured 3D Latents for Scalable and Versatile 3D Generation

论文单位： THU

是否开源： 是

总结： 输入文本或图像，输出3D模型，并且有灵活的输出格式选择和本地 3D 编辑功能。

论文细节

结构化潜在表示（SLAT）

SLAT 的核心思想是将3D资产的几何和外观信息编码为一个稀疏的3D网格 + 密集视觉特征的联合表示。具体设计如下：

稀疏3D网格结构

定义：对3D资产$\mathcal{O}$，定义一个分辨率为$N^3$（默认 $N=64$）的网格，仅标记与物体表面相交的“活跃体素”（active voxels），形成稀疏结构$\{\bm{p}_i\}_{i=1}^L$（$L \ll N^3$）。

优势：稀疏性支持高效高分辨率建模，同时保留局部性（便于后续编辑）。

局部潜在向量

每个活跃体素 $p_i$ 关联一个局部潜在向量 $z_i ∈ R^C$，用于编码该区域的几何和外观细节。

特征来源：通过多视角渲染（150张随机视角图像），用预训练的 DINOv2 提取视觉特征，投影到体素并平均聚合，得到初始特征$ f_i$，再通过稀疏VAE编码为 $z_i$。

编码与解码流程

编码过程

视觉特征聚合

渲染多视角图像 → DINOv2 提取特征 → 投影到 3D 网格，生成稀疏特征 $f = {(f_i, p_i)}$。

稀疏VAE编码

使用基于 Transformer 的编码器 E，将 f 映射为结构化潜在空间变量 $z = {(z_i, p_i)}$。同时，输入的特征还会根据p加上一个正弦位置编码并进行序列化以便于输入到网络中处理。

关键模块

3D Shifted Window Attention（Swin Transformer 这块我还没看懂），在稀疏体素间高效传递局部信息。

多格式解码

SLAT 支持通过不同解码器生成多种 3D 表示：

3D高斯（DGS）

每个 $z_i$ 解码为 $K=32$ 个高斯球（位置、颜色、透明度等），通过体积渲染损失$（L1 + SSIM + LPIPS）$训练。

辐射场（DRF）

解码为局部辐射体积（CP分解形式），用类似损失优化。

网格（DM）

通过稀疏卷积上采样到 $256^3$，用 FlexiCubes 提取网格，基于深度/法线图损失训练。

训练策略

先以 3D 高斯为目标训练 VAE，再固定编码器，单独训练其他解码器。

两阶段生成模型

稀疏结构生成

目标：生成3D资产的稀疏体素结构 $\{\bm{p}_i\}_{i=1}^L$

输入：文本（CLIP特征）或图像（DINOv2特征）。

模型：修正流变换器 $G_S$，生成低分辨率（$16^3$）的稠密特征网格$S$，解码为二值活跃体素网格$O$。

先把随机初始化的稠密特征网络与位置编码并在一起，然后通过3D卷积VAE压缩为低分辨率特征$\boldsymbol{S}\in\mathbb{R}^{16\times16\times16\times8}$，在这个latent空间中去噪，条件是输入的文本或图片，之后将生成的 S 解码为稠密二值网格$\boldsymbol{O}\in\{0,1\}^{64\times64\times64}$，再转换为稀疏活跃体素 $\{p_i\}$。

关键设计

使用 Conditional Flow Matching (CFM) 目标，优化噪声到数据的向量场。 $\mathcal{L}_{CFM}(\theta)=\mathbb{E}_{t,\boldsymbol{x}_0,\boldsymbol{\epsilon}}\|\boldsymbol{v}_{\boldsymbol{\theta}}(\boldsymbol{x},t)-(\boldsymbol{\epsilon}-\boldsymbol{x}_0)\|_2^2.$
引入 logit-Normal(1,1) 时间步采样，提升稳定性。

局部潜在生成

输入：上一步的稀疏结构 ${p_i}$ + 条件提示。

目标:为稀疏结构 $\{\boldsymbol{p}_i\}$ 生成局部潜在向量 $\{\boldsymbol{z}_i\}$

模型：稀疏变换器 $G_L$，直接生成潜在向量 ${z_i}$。

稀疏卷积下采样

将 64³ 体素打包为更短序列，提升效率。

跨注意力注入条件

文本/图像特征作为 Key-Value。

局部编辑能力

SLAT 的稀疏性和局部性天然支持灵活编辑：

细节变体生成

固定稀疏结构，仅重新生成 ${z_i}$（通过新文本提示引导）。

区域特定编辑

指定编辑区域的边界框，结合 Repaint 策略：
- 第一阶段：仅生成框内新结构。
- 第二阶段：生成框内细节，保持框外内容不变。

网络模型架构

3D-W-MHA: 3D窗口注意力机制 FFN：指任何前馈型的神经网络，可以有多个层，也可以没有隐藏层 MLP：是一种特定的 FFN，通常具有至少一层隐藏层，并且每层之间是全连接的

论文结果

该方法与其他方法的对比

重建质量的对比

可视化结果对比

更加细节的结果

SceneMotifCoder

Fri, 28 Mar 2025 13:13:17 +0800

论文信息

信息概览

3DV 2025 Oral

论文题目： SceneMotifCoder: Example-driven Visual Program Learning for Generating 3D Object Arrangements

论文单位： Simon Fraser University

是否开源： 是

总结： 文生图，生成物理上合理的多对象排列，比如对于像堆叠的盘子或书籍排列等几何约束较强的物体。

利用大型语言模型（LLM）的代码生成功能来创建可视化程序，以捕获常见 3D 对象排列的抽象。

论文思路

问题的定义

网络输入一个自然语言的文本描述，描述了希望生成的3D物体布局。例如，一个文本描述可能是“在桌面上排列几本书，书的背面朝向相同”，或“堆叠几个盘子，每个盘子稍微偏离前一个盘子”。

然后输出是一个3D物体布局，生成的布局根据输入的文本描述进行物体的排列和分布。这个布局是通过“视觉程序”表示的，通常包括了物体的位置信息、朝向、尺寸等细节。该布局必须符合文本描述的要求，同时保证物理可行性（例如避免物体重叠、确保平衡等）

网络的训练

SMC的学习过程分为两个阶段：学习阶段和推理阶段。

学习阶段

在学习阶段，SMC通过给定的物体布局示例来学习一个“motif程序”。

描述了物体的大小，位置等参数，不过这里的坐标，旋转都是与世界系对齐的，没有引入相对描述，例如“物体A放置在物体B的右侧”或“物体C的底部与物体D的顶部对齐”。

首先，SMC从示例布局生成一个初步的程序$P_0$，这个程序可能会较为简单或不完全准确。

然后，系统会根据这些示例优化程序，精炼出一个“motif程序”。这个程序可以描述物体如何在3D空间中排列。

最终，程序会被推广为一个元程序（meta-program），这个元程序能够生成布局的多种变体。这使得系统能够从少量的示例中学习到更为普遍的排列规律，并能够在面对新任务时进行推理和生成。

在这个过程中，SMC使用大语言模型（LLM）来生成和合成程序。程序的生成是通过逐步优化和学习来完成的，从而能够对输入的文本描述进行有效的映射。

learning框架

代码测试

输入数据 从"a stack of seven plates"这个glb模型出发，学习一个元程序

`1`	`python learn.py --file examples/a_stack_of_seven_plates.glb --desc "a stack of seven plates"`

首先会加载保存的数据,比如这里是七个盘子，那就是七种mesh，然后还会从这七个盘子中挑一个盘子出来作为世界坐标系，这样其他盘子的网格坐标都会需要一个转换。

def load_glb(file_path: str) -> tuple[gltf.GLTF2, list[Obj]]:
    '''
    Load a glb file.

    Args:
        file_path: string, the path to the glb file
    
    Returns:
        glb_file: GLTF2, the glTF 2.0 file
        objs_in_file: list, the objects in the file
    '''

    # TODO: Make less assumptions about the structure of the glTF file

    glb_file = gltf.GLTF2().load(file_path)
    objs_in_file: list[Obj] = []
    
    # Load the main scene and the scene's world nodes
    all_nodes = glb_file.nodes
    main_scene = glb_file.scenes[glb_file.scene]
    world_node_ids = main_scene.nodes
    
    # Load the objects in the world nodes
    for world_node_id in world_node_ids:
        main_node_ids = all_nodes[world_node_id].children

        # Load the objects in the main nodes
        # Each main node is a separate object
        for main_node_id in main_node_ids:
            main_node = all_nodes[main_node_id]

            # ----- Matrix -----
            # Note: This logic is not general!
            # Assumes that the mesh_root_node has a matrix for the mesh
            # And the main_node has a matrix for placing the mesh in the world
            if main_node.matrix:
                main_node_matrix = np.array(main_node.matrix).reshape(4, 4, order="F")
            else:
                translation = main_node.translation if main_node.translation else [0, 0, 0]
                rotation = main_node.rotation if main_node.rotation else [1, 0, 0, 0]
                scale = main_node.scale if main_node.scale else [1, 1, 1]
                translation_matrix = trimesh.transformations.translation_matrix(translation)
                rotation_matrix = trimesh.transformations.quaternion_matrix(rotation)
                scale_matrix = np.diag(scale + [1])
                main_node_matrix = translation_matrix @ rotation_matrix @ scale_matrix

            if len(main_node.children) > 0:
                mesh_root_node_matrix = all_nodes[main_node.children[0]].matrix
                if mesh_root_node_matrix is not None:
                    mesh_root_node_matrix = np.array(mesh_root_node_matrix).reshape(4, 4, order="F")
            else:
                mesh_root_node_matrix = None

            # ----- Mesh -----
            main_node_mesh = _load_all_meshes(glb_file, main_node)
            
            # Apply the mesh_root_node_matrix if it exists
            if mesh_root_node_matrix is not None:
                main_node_mesh.apply_transform(mesh_root_node_matrix)

            # ----- Bounding box -----
            # Compute the oriented bounding box of the mesh
            centroid = main_node_mesh.bounding_box_oriented.centroid + main_node_matrix[:3, 3]
            half_size = main_node_mesh.bounding_box_oriented.extents / 2
            main_node_bounding_box = BoundingBox(centroid, half_size, main_node_matrix[:3, :3])
            
            # ----- Obj -----
            # TODO: Allow the label to be provided separately
            label = main_node.extras["semantics"]["label"] if "semantics" in main_node.extras else "unknown"

            obj = Obj(label, main_node_bounding_box, main_node_mesh, main_node_matrix)
            objs_in_file.append(obj)

    return glb_file, objs_in_file

生成naive的代码

将一个 Arrangement 对象转换成一个 Program 对象。具体来说，它通过解析 Arrangement 中的每个 Object，并生成一系列代码，描述如何通过平移和旋转操作来创建这些对象并将它们放置到正确的位置和姿态。

def from_arrangement(cls, arrangement: Arrangement) -> Program:
    '''
    Create a program from an arrangement.

    Args:
        arrangement: Arrangement, an arrangement of objects

    Returns:
        program: Program, the program of the arrangement
    '''

    code = []
    code.append("objs = []")

    for i, obj in enumerate(arrangement.objs):
        label = obj.label
        centroid = obj.bounding_box.centroid.tolist()
        half_size = obj.bounding_box.half_size.tolist()
        coord_axes = obj.bounding_box.coord_axes

        # The object is initially aligned with the canonical coordinate system, so we need to rotate it to the correct orientation
        # For user convenience, the rotation operation is decomposed into three rotations around the x, y, and z axes
        # Here, we need to extract the three rotation angles needed to rotate the object to the correct orientation
        # In particular, we expect most objects only has a single rotation around the up axis (y axis), so we choose a rotation order of YXZ
        rotation_matrix = coord_axes
        y_angle = np.arctan2(rotation_matrix[0, 2], rotation_matrix[2, 2])
        x_angle = np.arcsin(-rotation_matrix[1, 2])
        z_angle = np.arctan2(rotation_matrix[1, 0], rotation_matrix[1, 1])
        
        code.append(f"obj_{i+1}_half_size = {half_size}")
        code.append(f"obj_{i+1}_centroid = {centroid}")
        code.append(f"obj_{i+1} = create('{label}', obj_{i+1}_half_size)")
        code.append(f"move(obj_{i+1}, obj_{i+1}_centroid[0], obj_{i+1}_centroid[1], obj_{i+1}_centroid[2])")

        for axis, angle in [("y", y_angle), ("x", x_angle), ("z", z_angle)]:
            if abs(angle) > 1e-5:
                code.append(f"rotate(obj_{i+1}, '{axis}', {np.rad2deg(angle).round(1)})")
        
        code.append(f"objs.append(obj_{i+1})")
    
    program = Program(code, arrangement.description)
    return program

对于上述输入的例子，结果为

Naive program:
objs = []
obj_1_half_size = [0.08909, 0.0143, 0.08853]
obj_1_centroid = [0.0, 0.0, 0.0]
obj_1 = create('plate', obj_1_half_size)
move(obj_1, obj_1_centroid[0], obj_1_centroid[1], obj_1_centroid[2])
objs.append(obj_1)
obj_2_half_size = [0.08909, 0.0143, 0.08853]
obj_2_centroid = [0.0, -0.00757, 0.0]
obj_2 = create('plate', obj_2_half_size)
move(obj_2, obj_2_centroid[0], obj_2_centroid[1], obj_2_centroid[2])
objs.append(obj_2)
obj_3_half_size = [0.08909, 0.0143, 0.08853]
obj_3_centroid = [0.0, -0.01514, 0.0]
obj_3 = create('plate', obj_3_half_size)
move(obj_3, obj_3_centroid[0], obj_3_centroid[1], obj_3_centroid[2])
objs.append(obj_3)
obj_4_half_size = [0.08909, 0.0143, 0.08853]
obj_4_centroid = [0.0, -0.02272, -0.0]
obj_4 = create('plate', obj_4_half_size)
move(obj_4, obj_4_centroid[0], obj_4_centroid[1], obj_4_centroid[2])
objs.append(obj_4)
obj_5_half_size = [0.08909, 0.0143, 0.08853]
obj_5_centroid = [0.0, -0.03029, -0.0]
obj_5 = create('plate', obj_5_half_size)
move(obj_5, obj_5_centroid[0], obj_5_centroid[1], obj_5_centroid[2])
objs.append(obj_5)
obj_6_half_size = [0.08909, 0.0143, 0.08853]
obj_6_centroid = [0.0, -0.03786, -0.0]
obj_6 = create('plate', obj_6_half_size)
move(obj_6, obj_6_centroid[0], obj_6_centroid[1], obj_6_centroid[2])
objs.append(obj_6)
obj_7_half_size = [0.08909, 0.0143, 0.08853]
obj_7_centroid = [0.0, -0.04544, 0.0]
obj_7 = create('plate', obj_7_half_size)
move(obj_7, obj_7_centroid[0], obj_7_centroid[1], obj_7_centroid[2])
objs.append(obj_7)

high-level的观察

def make_high_level_observations(llm_session: gpt.Session, naive_program: Program) -> None:
    '''
    Prompt the LLM to make high level observations of the naive program.

    Args:
        llm_session: Session, the LLM session
        naive_program: Program, the naive program to observe
    
    Returns:
        None
    '''

    llm_session.send("optimize_highlevel_count", {"program": naive_program.code_string, "description": naive_program.description})
    llm_session.send("optimize_highlevel_general_pattern", {"description": naive_program.description})
    llm_session.send("optimize_highlevel_xyz_pattern")
    llm_session.send("optimize_highlevel_xyz_displacements")

比如给gpt的prompt是： ‘Below is a program about a spatial motif of “a stack of seven plates”. Describe how many object types and how many are there for each type. Respond with a json-like text structure with the object types as keys and the counts as values. Here is the program: （naive的程序）

返回的结果如下：

在有了high-level的观察之后，调用大语言模型（LLM）对一个排列描述（description）进行图案类型（motif type）分类，并确保分类结果是有效的。

def classify_motif_type(llm_session: gpt.Session, description: str) -> str:
    '''
    Prompt the LLM to classify the motif type of the description.

    Args:
        llm_session: Session, the LLM session
        description: string, the description of the arrangement
    
    Returns:
        motif_type: string, the classified motif type
    '''

    with open("motif_types.yaml", "r") as f:
        motif_types = yaml.safe_load(f)["types"].keys()

    # ----- Validation function for this task -----
    def classify_validation(response: str) -> tuple[bool, str, int]:
        motif_type = response.strip().lower()
        valid = motif_type in motif_types or (motif_type.startswith("letter_") and motif_type[-1] in "abcdefghijklmnopqrstuvwxyz")
        error_message = f"The motif type '{motif_type}' is invalid. Valid motif types are: {motif_types}" if not valid else ""
        return valid, error_message, -1
    # ----- End of validation function -----

    motif_type = llm_session.send_with_validation("classify", {"description": description}, classify_validation)
    return motif_type

也就说，物体的排列必须是以下几种排列之一。

types:
  stack: multiple objects of the same type are placed orderly on top of each other
  pile: objects are placed on top of each other but not in an orderly manner (when in doubt between stack and pile, choose pile if the description contains the word "pile" explicitly)
  row: objects are placed next to each other in a row
  grid: objects are placed orderly in a grid, like a chessboard
  left_of: one object placed to the left of another object
  in_front_of: one object placed in front of another object
  on_top: one object placed on top of another object
  surround: objects are placed around a central object in a circular manner
  wall_vertical_column: objects are placed in a column from top to bottom vertically on a wall
  wall_horizontal_row: objects are placed in a row from left to right vertically on a wall
  wall_grid: objects are placed in a grid orderly and vertically on a wall (when in doubt between grid and wall_grid, choose wall_grid if the objects are placed on a wall)
  letter: objects are placed to form a letter of the alphabet
  rectangular_perimeter: objects are placed around the perimeter of a rectangular shape, facing inward

验证了物体排列合理性后，结合前文物体排序之类的信息，再去问gpt，优化出更高级的程序，比如之前naive的程序有7个create_plate，这一步会把该结构优化为for循环的结构，这样更加利于gpt捕捉空间中的高维结构。当然，还要验证gpt给出的代码是否满足这几个条件：（1）无语法错误

（2）无硬编码的对象属性列表，

（3）每个标签的对象数相同，

（4）对象放置在相同位置，

（5）对象的缩放和方向相同。

这一步极其容易报错。。

def optimize_motif_program(llm_session: gpt.Session, naive_program: Program, example_arrangement: Arrangement) -> Program:
    '''
    Prompt the LLM to optimize the naive program to create a motif program.

    Args:
        llm_session: Session, the LLM session
        naive_program: Program, the naive program to optimize
        example_arrangement: Arrangement, the example arrangement
    
    Returns:
        optimized_program: Program, the optimized motif program
    '''
    
    # ----- Validation function for this task -----
    def optimize_validation(response: str) -> tuple[bool, str, int]:
        program = gpt.extract_program(response, naive_program.description)

        validations = [
            validator.validate_syntax,
            validator.validate_naive_listing,
            validator.validate_num_objects,
            validator.validate_centroids,
            validator.validate_bounding_boxes,
        ]

        arguments = [
            [program],
            [program],
            [program, example_arrangement.objs],
            [program, example_arrangement.objs],
            [program, example_arrangement.objs],
        ]

        for i, (validation, argument) in enumerate(zip(validations, arguments)):
            valid, error_message = validation(*argument)
            if not valid:
                return valid, error_message, i
        
        return True, "", -1
    # ----- End of validation function -----

    optimize_response = llm_session.send_with_validation("optimize_lowlevel", None, optimize_validation)
    optimized_program = gpt.extract_program(optimize_response, naive_program.description)
    return optimized_program

优化后的结果如下：

objs = []

for i in range(7):
    plate = create('plate', [0.08909, 0.0143, 0.08853])
    move(plate, 0.0, i * -0.00757, 0.0)
    objs.append(plate)  # 仍然存储对象引用在objs列表中

此时，程序已经完成了从naive到motif的转变。然后还需要把motif的程序转换为meta的程序。

def observe_commonalities_and_differences(llm_session: gpt.Session, motif_type: str) -> None:
    '''
    Prompt the LLM to observe the high level commonalities and differences in programs of the same motif type.

    Args:
        llm_session: Session, the LLM session
        motif_type: string, the motif type
    
    Returns:
        None
    '''

    # Get all programs of the same motif type
    all_programs = ""
    if library.length(motif_type) > 0:
        loaded_programs = library.load(motif_type)
        for i, program in enumerate(loaded_programs):
            all_programs += f"Program {i + 1}. '{program.description}':\n{program.code_string}\n\n"
        print(f"Loaded {len(loaded_programs)} programs of motif type: {motif_type}\n")
    else:
        raise RuntimeError(f"No programs in library for motif type: {motif_type}")

    llm_session.send("generalize_high_level_commonalities", {"num_programs": str(len(loaded_programs)),
                                                             "motif_type": motif_type,
                                                             "all_programs": all_programs})
    llm_session.send("generalize_high_level_differences")
    llm_session.send("generalize_high_level_motif_reason", {"motif_type": motif_type})

上述程序的输出：

### Commonalities Across Programs:
1. **Consistent Use of the `create` Function**: Each program creates objects using the same type (e.g., 'plate') and size (e.g., `[0.08909, 0.0143, 0.08853]`).
2. **Modification of Object Positioning**: In all programs, object positioning is manipulated through the `move` function, typically modifying the coordinates along the primary axis of the motif (y-axis for stack, x-axis or z-axis for row/grid, and random offsets for pile).
3. **Consistency in Object Type and Size**: In each program variation, the same object type and size are used, maintaining a degree of consistency.
4. **Order and Spacing**: In most programs, objects are spaced with consistent intervals along the primary axis, although the spacing may vary (e.g., stack with a fixed offset, row with different spacing).

### Key Differences:
- The key differences between programs revolve around how the objects are positioned: 
   - A **stack** involves vertical alignment with consistent spacing.
   - A **row** involves horizontal alignment along one axis.
   - A **pile** involves random or unstructured placement, disrupting the uniformity.
   - A **grid** involves a two-dimensional arrangement, often across both x and y axes.

def prepare_meta_program_info(llm_session: gpt.Session, motif_type: str) -> None:
    '''
    Prompt the LLM to prepare information for writing the meta-program.

    Args:
        llm_session: Session, the LLM session
        motif_type: string, the motif type
    
    Returns:
        None
    '''

    llm_session.send("generalize_low_level_arguments", {"motif_type": motif_type})
    llm_session.send("generalize_low_level_structure", {"motif_type": motif_type})

def write_meta_program(llm_session: gpt.Session, motif_type: str, refine_comments: bool = True) -> Program:
    '''
    Prompt the LLM to write the meta-program.

    Args:
        llm_session: Session, the LLM session
        motif_type: string, the motif type
        refine_comments: bool, whether to refine the comments of the meta-program
    
    Returns:
        meta_program: program, the written meta-program
    '''

    # Get all programs of the same motif type
    if library.length(motif_type) > 0:
        loaded_programs = library.load(motif_type)
    else:
        raise RuntimeError(f"No programs in library for motif type: {motif_type}")

    # Get the previous meta-program if available
    if library.length(motif_type, is_meta=True) > 0:
        past_meta_program = library.load(motif_type, is_meta=True)[0].code_string
    else:
        past_meta_program = "# NO PAST META-PROGRAM AVAILABLE"

    # ----- Validation function for this task -----
    def generalize_validation(response: str) -> tuple[bool, str, int]:
        meta_program = gpt.extract_program(response, motif_type)

        batch_recreate_response = llm_session.send("generalize_low_level_batch_recreate")
        try:
            recreate_calls: dict[str, str] = json.loads(gpt.extract_json(batch_recreate_response))
            recreate_calls = list(recreate_calls.values())
        except json.JSONDecodeError as e:
            return False, f"Failed to decode the json response: {e}", -1

        valid, error_message = validator.validate_meta_program(meta_program, recreate_calls, loaded_programs)

        return valid, error_message, 0 if not valid else -1
    # ----- End of validation function -----

    generalize_response = llm_session.send_with_validation("generalize_low_level", 
                                                           {"motif_type": motif_type, 
                                                            "past_meta_program": past_meta_program}, 
                                                            generalize_validation)
    meta_program = gpt.extract_program(generalize_response, motif_type)

    # Refine the documentation of the meta-program
    if refine_comments:
        # ----- Validation function for this task -----
        def refine_comments_validation(response: str) -> tuple[bool, str, int]:
            meta_program = gpt.extract_program(response, motif_type)
            valid, error_message = validator.validate_syntax(meta_program, require_objs=False)
            return valid, error_message, -1
        # ----- End of validation function -----

        refine_response = llm_session.send_with_validation("generalize_refine_comments", 
                                                        {"motif_type": motif_type}, 
                                                        refine_comments_validation)
        meta_program = gpt.extract_program(refine_response, motif_type)
    
    return meta_program

其实上述步骤相当于就是一步步引导gpt写出正确代码的过程。对于这个例子，最后返回的示意meta程序是：

def create_stack(num_objects, obj_type, obj_size, starting_position, vertical_spacing, rotation_angle=0, axis_alignment='y'):
    """
    Creates a stack of objects based on the specified parameters. The objects are stacked along the given axis 
    with consistent spacing between each object.

    Parameters:
    - num_objects (int): The number of objects to be created and stacked. For example, 7 for a stack of seven objects.
    - obj_type (str): The type of object to be created (e.g., 'plate', 'cube'). Defines the kind of object to stack.
    - obj_size (list of floats): A list containing the half-size dimensions of the object in the x, y, and z directions.
      Example: [0.08909, 0.0143, 0.08853] for a plate. This defines the size of each object in the stack.
    - starting_position (list of floats): The initial [x, y, z] position of the first object. This sets the position of the 
      bottom-most object in the stack.
    - vertical_spacing (float): The vertical displacement (in meters) between the centers of two consecutive objects in the stack.
      For example, `-0.00757` meters.
    - rotation_angle (float, optional): The rotation angle (in degrees) for each object around its local axis. Default is 0 (no rotation).
      This can be used if you need to rotate the objects around their axes.
    - axis_alignment (str, optional): The axis along which the objects will be stacked. Options are 'x', 'y', 'z'. Default is 'y'.
      For example, use 'y' for vertical stacking, 'x' for horizontal stacking along the x-axis, and 'z' for stacking along the z-axis.

    Returns:
    - list: A list of all created objects that have been placed in the stack. The list contains the objects in the order they were stacked.

    Example call:
    create_stack(7, 'plate', [0.08909, 0.0143, 0.08853], [0.0, 0.0, 0.0], -0.00757)
    """
    
    objs = []  # Initialize an empty list to store the created objects

    # Loop to create and position each object in the stack
    for i in range(num_objects):
        # Create an object of the specified type with the given size
        obj = create(obj_type, obj_size)
        
        # Calculate the position based on the axis alignment and vertical spacing
        if axis_alignment == 'y':
            # For stacking along the y-axis (default)
            move(obj, starting_position[0], starting_position[1] + i * vertical_spacing, starting_position[2])
        elif axis_alignment == 'x':
            # For stacking along the x-axis
            move(obj, starting_position[0] + i * vertical_spacing, starting_position[1], starting_position[2])
        elif axis_alignment == 'z':
            # For stacking along the z-axis
            move(obj, starting_position[0], starting_position[1], starting_position[2] + i * vertical_spacing)

        # Apply rotation if provided
        if rotation_angle != 0:
            # Apply rotation around the x-axis by default
            rotate(obj, 'x', rotation_angle)  # This could be modified to rotate around y or z if needed

        # Append the created object to the list of objects
        objs.append(obj)

    return objs  # Return the list of objects that have been created and stacked

推理阶段

在推理阶段，给定一个新的文本描述，SMC首先从学习到的元程序库中检索出最合适的元程序。

接着，应用该元程序生成相应的3D物体布局。这个布局生成的详细过程是，首先根据每个对象的标签和边界框尺寸从对象数据集中检索mesh，比如从数据集中检索四本书出来。

检索的方式分为两种（这两种方式不能并行使用，论文中默认是第一种使用方法）：

1 将该物体的包围盒（bounding box）与所有可用3D模型的尺寸进行对比。然后，根据尺寸差异对所有模型进行排序，从前五个最匹配的模型中随机选一个作为最终用于该物体的3D模型；

2 基于语义描述和图像相似度匹配（使用CLIP模型），将每个物体的文本描述（例如“一个蓝色的陶瓷杯”）与一组3D模型的渲染图像进行对比。使用CLIP模型（如OpenCLIP）来计算描述与渲染图像之间的相似度得分，选择得分最高的模型作为物体的3D模型；

然后问LLM，这四本书的旋转方向是否可以不同（下图的例子就是不一样的旋转）；

然后元程序（例如 Stack(objects=[book1, book2, book3, book4])）会根据“堆叠”的规则来计算每本书在空间中的位置，这样就得到了一个初始的布局，又因为book1本身就是一个glb文件了，所以可以把四个模型一起合成为glb文件。

最后，为了避免物体之间出现穿透或悬空，SMC还会对整个场景执行一次几何优化，包括：确保书与书之间正好接触；保持整体物理稳定性（比如最底下那本书不会“悬空”）；如果出现尺寸冲突，可能会微调物体间距或缩放某些物体。

最后生成结果如下：

推理框架

整体框架

结果

输入同样的文本描述，SMC方法与其他文字生成模型的方法的对比。

Physics_Summary2

Mon, 10 Mar 2025 21:29:30 +0800

这篇文章主要总结了下Jiajun Wu他们组有关物理感知/机器人相关的工作，还有些近期的工作，与summary1部分内容相同。

Jiajun Wu 工作

Galileo: Perceiving Physical Object Properties by Integrating a Physics Engine with Deep Learning

2015 NeurIPS

只能输入初始的静态的位置，对一维的摩擦力+动量守恒的规律建模

Learning to See Physics via Visual De-animation

2017 NeurIPS(Spotlight)

输入三张图片，两两之间测量速度，预测二维平面上的动量守恒

Physical Primitive Decomposition

2018 ECCV

人们用锤子敲击物体的时候会拿起锤子的柄而非锤子的头，那么当机器人去操作的时候应该如何让它知道这个信息呢？

See, feel, act: Hierarchical learning for complex manipulation skills with multisensory fusion

2019 Science Robotics

Learning Physical Graph Representations from Visual Scenes

2020 NeurIPS(Oral)

Unsupervised Segmentation in Real-World Images via Spelke Object Inference

2022 ECCV(Oral)

对真实世界中的物体进行分割

Differentiable Physics Simulation of Dynamics-Augmented Neural Objects

2023 RAL

Physically Grounded Vision-Language Models for Robotic Manipulation

2024 ICRA

近期的一些实验

上次提到了Physdreamer，这应该算是Jiajun组里最新的结果了，简而言之就是给定视频的初始帧，利用生成模型生成视频中物体未来的动作，再用这个生成的结果作为监督信号优化物理场。优点是只需要一张图片作为输入，缺点是生成的视频不符合物理规律。如果考虑到实际机器人的操作的话，其实没必要像他们那样用生成的方式，而应该是比如说机器手自主探索环境中物体受力的影响，学习到一些信息后再进行操作。

而且我个人觉得视频生成模型在富含物理规律的生成方面做得并不够好，比如Nvidia在今年一月份发布的工作Cosmos应该可以代表目前最强的视频生成模型了（因为堆了很多数据），而且文中还专门提到了他们有很多操作相关的数据。我尝试了下这个模型，工作流如下：

生成1280*704的视频，长度为5秒，部分结果如下：

可以看出，当前模型的效果并不理想。在光影变化和广角视觉效果方面，它已经做得相当不错，能够呈现出较好的视觉效果。然而，在物理场模拟上仍存在明显不足，尤其是在处理流体、爆炸等高度非线性或具有剧烈突变的场景时，表现尤为欠缺。

我认为其中一个关键原因是物理属性的分布方式与像素空间中色彩的分布方式截然不同。色彩在像素空间中的分布通常可以近似为独立同分布（IID），而物理系统中的变量往往存在高度的相互依赖性和因果性。又想到目前许多灵巧手的研究正在采用扩散模型（Diffusion Models）来生成操作轨迹。然而，本质上，这种方法与视频生成的思想是相同的——它依赖于统计概率的相关性，而非物理上的因果律。具体来说，这些模型通常通过学习帧与帧之间的统计相关性，来预测并生成轨迹。但这种方法并不直接考虑物理系统的动力学约束，而是基于数据驱动的方式，在高维概率分布中寻找模式。这类似于视频生成模型如何学习帧与帧或像素之间的关联，而非物理世界中光线传播的真实物理机制。然而，物理系统的演化不仅仅是一个统计问题，更是因果驱动的——例如，在流体动力学、刚体碰撞或柔性物体操作中，每一个状态的变化都严格受偏微分方程或其他物理定律约束，而不是简单的统计相关性。

从这个角度来看，单纯依靠扩散模型生成轨迹，短期内可能在数据拟合上表现不错，但从长期来看，缺乏对物理约束的精确刻画，难以真正提升灵巧手的操作能力。这也是物理仿真不可或缺的原因之一——它能够提供真实的物理约束，使生成的轨迹不仅在统计上合理，而且符合物理因果关系，从而提升机器人操作的可靠性和可推广性。

部分理论解释

一些比较精彩的解释bySora物理悖谬的几何解释(这里还有很多理论我还没看明白，之后多去学习一下)

为什么数据点云是低维的，而非占满整个原始数据空间？因为自然现象满足大量的自然规律，这些规律的限制降低了数据样本点云的维数，而无法占满整个空间。比如，我们考察所有自然人脸照片构成的数据集，每个采样点是一张图片，像素的个数乘以3就是原始图像空间的维数。原始图像空间中的任意一点，都是一幅图片，但是极少的图片才是人脸图片，才会落在人脸图片流形上，因此人脸图片流形不可能占满整个原始图像空间。人脸需要满足很多自然的生理学规律，每个规律都会降低数据流形的维数，例如左右对称，就减少了近一半的像素，都有五官等确定的几何与纹理区域，每个器官的形状类似，描述的参数不多，因此进一步降低维数。最终控制人脸的基因非常有限，由此人脸图片流形的维数远远低于图片像素个数。再如，我们观察平面区域的稳恒态温度分布，由物理热扩散定理，稳定函数满足经典的Laplace方程，由其边界值所唯一确定。如果我们在区域内部有n平方个采样点，在区域边界有n个采样点，那么每个观察到的温度函数被表示为维数为n平方的向量，即原始数据空间维数为n平方，但是实际的流形维数为边界函数的维数n。由此可见，满足物理定律的观察样本构成的数据流形维数远远低于原始数据空间维数。
为什么点云集合是流形，即局部是连续光滑的？绝大多数情形下，物理系统是适定的，但在临界状态下，物理系统会发生突变（由灾变理论或者临界态理论来描述）。物理定律多由偏微分方程系统来描述，微分方程的解由初始值和边界值来控制，系统是适定的，意味着由于能量守恒、质量守恒、能量传递小于光速等物理限制，初边值逐渐变化时，解也随之逐渐变化。在偏微分方程的正则性理论中，这意味着边值的索伯列夫范数控制解的索伯列夫范等等。我们将解视为数据流形上的点，边值视为其对应的局部坐标（即隐空间中的对应隐特征向量）。从数据流形到隐空间的映射被称为是编码映射，从隐空间到数据流形的映射被称为是解码映射。正则性理论保证编码映射和解码映射是连续的乃至光滑的，解的唯一性保证这些映射是拓扑同胚或者微分同胚。边值可以任意局部扰动，即隐变量存在一个开欧式圆盘的邻域。这意味着满足特定物理定则的观察样本构成了数据流形。
数据流形上的概率分布如何表示？关于第三个问题的回答是：用传输变换，将数据概率分布变成计算机可以生成的高斯分布。这个传输变换可以在原始数据空间中进行，也可以在隐空间中进行。常用的传输变换包括最优传输变换和热扩散。我们用流体力学的观点来解释。假设整个隐空间是一个水箱，里面有某种溶剂，其密度为概率密度。我们扰动水箱，使得液体流动起来，使得溶剂密度发生变化。我们计算每个水分子的流向和流速，使得概率密度的熵一直增加，最后就得到高斯分布。例如，我们考虑人脸数据分布，这里每个水分子就是一张人脸图片。我们为人脸图片不断添加噪声，得到一系列图片，直至变成一张白噪声图片。这一系列图片就是水分子的运动轨迹。最后每张人脸图片变成白噪声，所有这些白噪声分布满足高斯分布。这一过程被称为是郎之万的动力学。反过来，给定一张白噪声，我们沿着水分子轨迹倒溯源头，就得到一张人脸图片。这就是扩散生成模型的原理（diffusion model）。当然，也可以直接用最优传输理论求解隐空间到自身的同胚，将数据分布变成高斯分布，这需要求解蒙日-安培方程。由此可见，数据分布的所有信息都由传输映射所包含，而传输映射被一个深度网络来表达。
在Sora生成的视频中，每一帧都异常逼真，但是当老奶奶吹了生日蜡烛的时候，蜡烛的火苗纹丝不动。如果我们将视野缩小到每一个令牌的区域，我们看到美轮美奂的真实画面，令牌之间的衔接也非常平滑自然，但是当相距较远的令牌之间有因果联系的时候，即吹出的空气影响火苗的跳动时，两个令牌之间的物理因果没有体现出来。这意味着Transformer用以表达令牌之间的统计相关性，无法精确表达物理因果律。虽然transformer可以在一定程度上操纵自然语言，但自然语言无法准确表达物理定律，而物理定律目前只有偏微分方程才能精密表达。这反应了基于概率的世界模型的某种局限性。
自然界的绝大多数物理过程都是稳恒态与临界态的交替变化。在稳恒态中，系统参数缓慢变化，容易获取观察数据；在临界态中（灾变态），系统骤然突变，令人猝不及防，很难抓拍到观察数据。因此，临界态的数据样本非常稀少，几乎在训练集中零测度。由此，Sora系统学习到的数据流形，绝大多数都是由稳恒态的样本所构成。物理过程中的临界态样本多分布在数据流形的边界。因此，在生成过程中，Sora非常容易生成稳恒态的视频片段，但是往往跳过临界态。但是在人类认知中，最为关键的观察恰恰是概率几乎为零的临界态。

Cosmos

Tue, 04 Mar 2025 16:22:05 +0800

Cosmos+ComfyUI 环境配置记录

配置ComfyUI 环境

官方推荐的是python=3.12版本，但是由于我的cuda是11.7版本，没有对应的pytorch，所以我改成了3.11版本的python及其对应的pytorch，这里的版本可根据需要自行修改。

在终端中输入：

conda create --name comfyui python=3.11
conda activate comfyui
conda install pytorch==2.5.1 torchvision==0.15.2 torchaudio==2.0.2 pytorch-cuda=12.1 -c pytorch -c nvidia

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI/
pip install -r requirements.txt -i https://pypi.mirrors.ustc.edu.cn/simple/

之后运行

`1`	`python main.py`

出现如下结果：

打开网站后结果如下

至此comfyUI配置完成

Cosmos 相关配置

下载语言模型并保存到ComfyUI/models/text_encoders/ 路径下

下载 vae 并保存到 ComfyUI/models/vae/ 路径下

下载 cosmos模型并保存到 ComfyUI/models/diffusion_models 路径下

ComfyUI 工作流配置

在官方文档中，下载对应的json文件并保存到comfyui下的workflow的文件夹（自己新建），下图以text2video为例

然后在网页端打开这个工作流直接运行就可以了

踩坑

`1`	`module 'torch' has no attribute 'float8_e4m3fn'`

torch版本太低了，升级到pytorch=2.5.1+cuda=12.1就好

Comfyui 基本使用方法

安装了两个插件还挺好用的，分别是AlekPet和VHS

Physics_Summary

Thu, 27 Feb 2025 12:49:57 +0800

尽管当前的视频生成模型已能产生令人满意的效果，但生成的结果中仍常出现不自然的现象(Sora)，这些现象往往违背了我们对几何和物理常识的理解，因此近年来，许多研究尝试将物理规律融入视频生成模型来得到更好的结果。与此同时，在机器人领域，大多数研究仍主要聚焦于机器人自身的运动轨迹生成，而对环境及交互物体的感知仍停留在视觉信息的层面，未能充分利用物理规律。因此，这篇文章总结了我对近期工作的一些总结，以及一点点对于这些工作在灵巧手操作上可能应用的思考。

我的想法大致如下：

整个工作的pipeline如下：

给定一个任务，利用LLM预测我们需要知道哪些物理属性（比如物体的摩擦系数）；
输入一段视频作为监督信号，从该视频的初始帧开始进行物理仿真，优化物理参数场；
得到较为精确的物理参数后，生成/仿真得到该物体在被施加一个力后的响应；
在已有的手物交互轨迹基础上，如果能准确预测物体对外力的响应，就能进一步微调手的施力方向和大小，或者将这些信息直接融入轨迹生成过程中，以提升交互精度。

一句话概括就是让机器人理解真实环境中的物理属性，从而更好地辅助操作实现。那么自然而然地会引出两个问题，

首先，如何从环境中恢复物体的物理属性并进行物理仿真？

其次，在机器人已知物体的物理属性后，如何利用这些信息优化灵巧手的操作？

Physics Simulation & Video Generation

事实上，给定视频恢复物理属性(pipeline2)与给定物理属性生成视频(pipeline3)互为反问题(不过我更关注的是生成物体对于外力的响应，并不需要那种精细的视频)。然而，近年来学界的研究更倾向于后者，这一领域的研究主要分为以下三个方向：

物理对齐 Physics Alignment

在语言模型中，对齐（Alignment）指的是通过一系列算法和工程手段，修正模型的行为，使其输出符合预设的安全边界和人类意图。与之对应的，修正视频模型的输出使其满足物理规则的过程就是物理对齐。作为对齐领域的代表性工作，InstructGPT 提出了两种对齐方法：

监督微调（Supervised Fine Tuning，SFT）人工标注高质量的提示（prompt）和回答（output）数据集，通过监督学习的方式微调模型。

基于人类反馈的强化学习（Reinforcement Learning from Human Feedback，RLHF）对同一个提示，模型输出多个回答，人工对这些回答进行比较打分；使用打分的结果训练一个反馈模型（Reward Model），用于评价模型输出的好坏；使用反馈模型对模型进行强化学习，比如近端策略优化（Proximal Policy Gradient，PPO）。

将这两种想法用于视频模型中是比较直观的。对于 SFT，我们就需要使用物理真实的视频作为输入。但是真实世界中的视频当然都是物理真实的，可能的问题是视频动态不够，导致模型没有接受到足够的动态信息。因此像 Cosmos 在预训练阶段就会保证数据能够反映真实物理规则。这主要是通过两点做到的：

收集包含大量动态的视频：包括驾驶视频、手部动作、第一人称视角、模拟结果等等。
对数据进行过滤：剔除质量低的、缺乏动态的、非物理等的视频，并提取一部分高质量视频作为后训练数据集。

尽管 Cosmos 的论文在 5.3.2 节专门讨论了物理对齐的问题，但是实际上并没有做更多的尝试，只是在几个场景中测试了 Cosmos 生成的结果是否吻合模拟/真实的物理。

对于 RLHF 而言，首要问题是需要一个反馈模型来判别模型输出的结果是否满足物理规律。这方向一个代表工作是 VideoPhy。这篇工作的核心是对市面上十二个视频模型的生成结果进行人工打分，然后训练一个打分网络 VideoCon-Physics。打分分为两个维度，每个维度得分只有 0 或 1：一个是语义的符合程度（Semantic Adherence，SA），一个是是否符合物理常识（Physical Commonsense，PC），结果如下：

Benchmark

可以发现成绩最好的是开源模型 CogVideoX-5B，但是也只是勉强及格的水平。这方向类似的工作还有 VideoScore，PhyGenBench。理论上有了打分模型之后我们就可以对视频模型进行强化学习对齐了，OnlineVPO 就使用了 VideoScore 作为反馈模型微调了 OpenSora 模型，使其在 VideoScore 得分上超越了其他模型。

整体上来说，物理对齐比较依赖预训练大模型的能力。对于语言模型来说，对齐往往会降低模型在基准测试上的分数，称为支付对齐税（Alignment Tax）。对于视频模型情况应该是类似的，增强其在物理动态方面的能力可能导致其他能力的削弱。因此，一个更本质的问题是，通过预训练的方式大模型是否能够足够泛化地学到物理规律？字节的工作 How Far is Video Generation from World Model? A Physical Law Perspective 是这个方向的一个初步探索。

二维平面模拟 2D Physics

Ok，如果视频模型短期内无法达到我们对于物理规律的需求，那我们是否可以通过加入物理模拟的方式增强这方面的能力呢？由于视频模型都是 2D 的，我们可以先从二维平面上的模拟开始，这一领域分为两个方向，一个是显式地加入物理规律并在屏幕空间上进行模拟，另一个则是隐式地推断物体的动力学信息。

屏幕空间模拟（Screen-space Simulation）指的是绕过 3D 模型，直接在屏幕空间中模拟物体的动态。这方面的一个代表性工作是 PhysGen。

Physgen 流程图

大致的流程分为三步：1. 给定一张初始图片，我们先做分割，并使用图像理解模型获取法向贴图、语义等信息，然后使用大语言模型推测对应的材质；2. 使用屏幕空间的 2D 模拟器进行模拟（刚体模拟）；3. 使用视频模型将模拟结果与法向贴图等整合起来，得到最终视频。可以发现，这个流程中其实并不需要大模型生成动态，大模型提供的是一个满足时间连续性的"渲染器"，将模拟结果渲染成视频。最近的 PhysAnimator 也是这个思路，不过将模拟的对象进一步扩展到了布料这样的软性材料。

当然，也有不显式加入物理模拟的方式来实现图片上的动力学的工作，而是通过分析图片中物体的振动规律得到信息，并利用这些信息来推断物体的物理特性和驱动它们运动的力，这一工作最早可以追溯到Davis的博士论文Visual vibration analysis。如果有了物体对于一个已知力的响应，那么我们是不是就可以在不知道物理规律的前提下分析一个物体对于未知的力的响应了呢（类似于反馈-控制，黑盒模型）？2024年的CVPR Best Paper Generative Image Dynamics 就做了这样的一件事。与PhysGen不同，这篇论文并没有显式地建模出物体的运动规律，而是只学习到了振动频率(事实上，物体振动频率满足该规律：$\omega = \sqrt{\frac{k}{m}}$)，即学习每个像素点的振动规律(利用傅里叶变换分解，学习的参数是傅里叶的系数)。在不考虑训练成本的情况下，相比于显式地模拟，这种方式的推理速度肯定更快，但是显然只能局限于振动这种简单的物理规律，当然，通过改变基函数的方式（比如把傅里叶级数换成勒让德级数）也许可以将该方法推广到更多真实情景，这也是一个值得探索的方向。

总的来说，在二维平面上的模拟的优点很明显，我们能够对生成的结果进行非常精确的控制，并且在小幅度内基本满足我们对物理规则的认知。但是缺点同样很明显，由于我们是在屏幕空间做分割和模拟，我们永远只能生成物体一面的结果，像布料的遮挡褶皱也无法处理。并且，生成结果的视角只能是固定的。这使得这类方法只适用于生成动态壁纸这样比较受限的应用，不能作为通用的视频生成方法。

不过我觉得PhysGen的思维范式很好，如果要继续往下做的话我更倾向于在该工作上的框架上去做。

三维空间模拟 3D Physics

既然 2D 的模拟终究是妥协，那不如我们直接回到三维模拟。回顾传统的图形管线，生成视频的过程大致可以分为准备3D 资产、进行模拟、渲染结果这三步。这三步中预训练的视频模型可以充当一个非常好的渲染器，比如下图展示的，Cosmos 可以将三维模拟的结果风格迁移到真实场景的视频。

Cosmos中的风格迁移

在有 3D 资产和物理参数的基础上，模拟也不是一个困难的问题。传统模拟算法在平衡模拟效果和速度上已经提供了非常多的选择。因此最大的问题在于第一步：对于用户给定的一个语言提示，或者是初始帧，如何获取对应的 3D 资产。对应这两种情况我们可以看到两种解决方法，一是训练文本生成 3D 资产的模型，二是从真实图片中重建。

首先，世面上已经有很多专注做文本生成 3D 资产的 AI，比如 Rodin，Meshy 等,可以直接将这些模型导入到像 Houdini、Blender 这样的图形软件中进行模拟。之前受到很多关注的 Genesis 想做的就是这个思路。另一方面，过程建模（Procedural Modeling）使用形式语言或者节点化的方式描述模型的生成过程，可以将 3D 模型与文本直接联系起来。比如 SVG 图片使用 html 标记语言，CAD 模型可以完全用代码表示，Houdini 用节点系统描述模型等等。在有了代码化的描述之后，我们就可以通过语言模型去生成这些代码，也就生成了 3D 模型。Infinigen 通过 Blender 构建了描述自然和室内场景的过程建模语言，因此可以实现文本生成三维场景。GPT4Motion 通过 Blender 实现了无训练，直接从文本生成视频的整个流水线。

如果我们的任务是从初始帧生成视频，就可以考虑从图片重建出 3D 模型。PhysMotion 使用的方法就是从单张图片进行 Gaussian Splatting 的重建，然后接入物质点法进行模拟，最后经过视频模型进行渲染。如果我们的单视角重建（本质上是对其他视角的生成任务）足够好，那么生成视频的质量就有保证。但是话又说回来，我们不正是应该利用预训练视频模型的能力来帮助单视角生成的任务吗？为什么反而抛弃了大模型在这方面的能力而只把大模型作为一个渲染器呢？

我们可以发现，如果只是用大模型去增强现有的图形管线，那么不可避免的需要很长的管线，并且没有充分利用大模型的能力。最理想的情况是，我们用最少的规则限制和控制信号，提供最基础的三维物理和几何的保证，其他的交给预训练模型补充细节。在这个方向上，CineMaster 是一个很有意思的尝试，只通过最简单的包围盒作为条件，就能实现很好的视频控制生成效果。

推断物理信息

前文提到的都是在有物理信息的情况下进行仿真/生成的工作(也就是pipeline3)，如果我们希望将这一概念应用于机器人操作，那么关键问题就在于：如何估计现实世界中物体的物理参数？这是一个极具挑战性的问题，因为目前市面上很少有数据集能够提供包括物体质量、弹性系数等在内的各种物理信息。因此，依赖于大规模数据集进行学习来解决这一问题变得非常困难，特别是当数据集质量较低且规模较小时，模型的泛化能力也会受到限制。那么，如何应对这一挑战呢？如果我们选择依赖物理仿真，是否能够提升模型的泛化能力呢？毕竟，像牛顿定律等自然科学规律是普适的。然而，物理仿真对算法的精度要求非常高。基于此，一个较为可行的初步思路是将模型学习与物理仿真结合：首先通过模型学习来获取物体的初始物理属性，如质量、速度等；然后借助传统物理模拟来预测物体未来的运动规律，最后再用神经网络做微调。

在这个方向，蒋陈凡夫他们组在此基础上做了很多相似的工作，最为出名的是PAC-Nerf 与PhysGaussian。他们的思想非常朴素，但是却很有用。其整体框架如下：

在此基础上，还有两个工作，分别是Physdreamer和DreamGaussian，但是都是一些incremental的工作而且做的都是偏生成方向。Physdreamer应该是这个领域较新的成果了，他们结合了PhysGaussian和DreamGaussian两篇工作，简单点说就是PhysGaussian用了多帧的真实视频作为输入(监督信号)，恢复物理属性后，再去预测渲染未来的视频帧，而Physdreamer则只输入视频的第一帧，由第一帧图片生成后续的帧，并将其作为监督信号，再接入PhysGaussian的框架。缺点是显而易见的，生成的视频质量肯定没办法和真实的视频相比的，而且二者之间的误差肯定会随着时间的推移增加，所以他们只选择了前面生成的10帧左右作为监督，那么也就无法生成长视频序列了。而且他们的结果如下:

这些评分的意思，比如上面表格的第一个内容表示，对于alocosia（这是一种植物）的视频生成，有86%的人认为他们生成的视频在motion realism的指标下比真实的视频还要好，不过都是人工打分的指标，感觉没啥参考性。而且如果想用到操作的领域，用生成去做肯定是不合适的。不过他们的工作中有一个我觉得还不错的点，他们对于所有的Gaussian点做了knn下采样，也就是只对所谓的driven-particle作仿真，这一点大大加快了仿真的速度。又联想到最近的一篇文章A Grid-Free Fluid Solver based on Gaussian Spatial Representation，这篇工作看格式应该是要投SIGGRAPH的，他们是在PhysGaussian的基础上加速了流体的仿真，简单点说就是原本3DGS核携带的信息是球谐函数，他们把这个信息改成了物理属性，或者可以这么理解，本来3DGS渲染的是RGB，他们改成了渲染速度矢量($V_x, V_y, V_z$)。这个思路我感觉挺好的，而且可以和之前knn下采样的思路结合，我们可以在这个基础上继续加新的东西，而且他们的代码还没有开源，所以我最近有时间的话想从头复现下这篇论文，顺便学习下cuda的代码。

总的来说，我个人感觉这个领域做的人比较少，而且这些工作的不足之处也非常明显，比如首先他们不能将物体的前景与背景分离开来(比如可以参考PhysGen的pipeline,并用LOTUS做分割?)，其次他们还是只能模拟简单的物理规律，比如他们都把花朵建模为了纯粹的弹性-质点模型，而且在物理规律模拟的过程中都是比较传统的算法，这对于机器人的操作来说都是必须要解决的问题，我感觉这个领域还是值得研究的。

机器人中的应用 Application in Robot

在机器人领域的调研中，最符合我idea的工作是这篇23年的RAL DANOs。

可以参考他们的视频作进一步的了解。

他们的工作是通过纯粹的视觉信息来估计物体的质量，重心，摩擦系数这些属性并辅助机械爪工作，由于是23年的工作，所以他们的框架还是建立在Nerf的基础上的，也就是先建立一个体素场，然后在体素的密度和质量之间，通过神经网络的方式建立一个映射，从而恢复出物体的属性。而且他们还在实物实验上验证了他们的结果，不过这个实物实验比较简单，就是一个肥皂在桌子上滑动，然后预测摩擦力/重力，算出物体的运动规律。

那么由这个工作出发，自然地会想到两条路径。首先，目前，3DGS技术已经被广泛应用，并且相比NeRF，其基于点云的表示方式在物理仿真中更具优势。因此，直接将 NeRF替换为3DGS是一个显而易见的改进方向。这个工作一眼就能看出来能和PhysGaussian结合，虽然我没找到相关工作，但肯定有人会去做，不过别人可能是普通的二爪机械手，我们是灵巧手，而且还能加入触觉信息，这也是我觉得一个可以探索的方向。

其次由这个工作，我还联想到了很多预训练上的工作，例如，在现实任务中，机械手可能难以直接抓取桌面上的一张卡片，而更合理的策略是先将卡片推到桌子的边缘，再进行夹取。本质上，这一推卡片的过程与上述预测摩擦力/重力的方法是相似的，都涉及物理信息的推理与利用。然而，据我观察，大部分机器人领域的研究仍然主要关注于抓取姿态的生成，即如何在几何层面找到最优的抓取方式，而对物体的物理属性（如摩擦、质心、变形）以及环境因素的考量较少。因此，我的研究想法正是希望从物理信息的角度出发，探索更加智能的抓取策略。（如果后续要做这个方向上的工作，我希望能从这个简单的任务（推卡片）开始做）

有人可能会质疑：如果目标是执行某些运动学任务（如推卡片、打乒乓球等），为什么不直接用端到端控制器进行学习？目前已有研究通过强化学习等方法，成功训练出了能够打乒乓球或羽毛球的机器人，是否还有必要引入物理建模？

首先，从直觉上来说，我觉得通过物理规律建模得到的结果可以泛化到很多未知的情境中，端到端的控制方法虽然可以在特定任务上表现出色，但它们通常是基于数据驱动的黑盒模型，容易受到环境因素（如颜色、光照变化等）的干扰。而基于物理规律的建模方法则能够泛化到更多未知场景，不依赖于特定数据分布。

其次，按照我文章一开始提出的overview，哪一个环节出现了问题，对于我来说都是可控的，这种可控性使得物理建模能够更好地与新兴的研究成果结合（比如之前提到的lotus），并进行模块化优化。而端到端学习往往难以解释模型的决策逻辑，并且对于计算资源的消耗量巨大。

第三，打乒乓球这种工作只能局限于运动学模型，而对于更精细的操作（如灵巧手抓取柔性物体、操纵复杂工具、物体局部形变等），物理仿真能够提供更完整的解释。例如，在精细抓取任务中，局部形变、摩擦力、微观接触点的作用不可忽视，而这些信息很难通过端到端的黑盒方法直接学习到。

Reference

Physics for Large Video Model

Physdreamer

Tue, 25 Feb 2025 00:00:00 +0000

论文信息

信息概览

ECCV 2024 Oral Presentation

论文题目： PhysDreamer: Physics-Based Interaction with 3D Objects via Video Generation

论文单位： MIT

是否开源： 是

总结： 一种基于物理学的方法，通过利用视频生成模型学习的对象动力学先验，赋予静态3D对象交互式动力学，也就是使静态3D对象能够以物理上似乎合理的方式动态响应交互刺激。

该方法使用3D高斯粒子表示物体，使用神经场建模材料属性，并通过可微分仿真（使用材料点法，MPM）模拟动态。

论文思路

问题：给一张图片，比如一朵花，想知道这朵花在微风吹过后的动态信息，也就是求一个物体对于新物理交互的响应。

但是求解这个响应，需要对物体的性质有较为准确的估计（比如两种弹性系数不同的弹簧，对其施加相同大小和方向的力，其变形显然是不一样的）。

而这个性质是很难测量的，或者说难以形成大规模的数据集以供学习。

但是人类能从观察物理世界和与物理世界互动中获得的物理先验知识，受此启发，作者从大量的视频先验中学习动力学先验，

为了简化，这篇文章只对弹性物体做了仿真，那么估计的物理属性，有质量、杨氏模量和泊松比。质量等于密度乘体积，论文中粒子的体积是体素的体积除以其中包含的粒子数，密度是给定的常数，泊松比也是给定的常数，所以最后优化的只是一个杨氏模量的场。

论文的关键思想是生成运动中物体的合理demo，比如一朵花，他把花离散为很多稠密的点，但这些点不是同构的，因此每个点的杨氏模量都不一样，然后按照物理属性去优化材质场E以匹配这个合成的运动。我们首先从某个视点为 3D 场景出发渲染静态图像。然后，我们利用图像到视频模型(SVD)生成一个短视频剪辑 {$I_0$， $I_1$， . . . ， $I_T$ }，描绘对象的真实运动，这个生成的模型是GT来监督模拟得到的图像，然后再通过可微分模拟和可微渲染来优化材料场E(x)和初始速度场$v_0$(x)，使得模拟的渲染视频与生成的视频匹配。但其实我觉得核心的部分还是图中下面的箭头，也就是PhysGaussian的工作比较重要。

细节部分

仿照PhysGaussian内部填充？

核心的仿真原理：

$$ \rho \frac{D v}{D t} = \nabla \cdot \sigma + f, \frac{D \rho}{D t} + \rho \nabla \cdot v = 0 $$

v 是欧拉视角，密度是常量，f是外力。

MPM的实现细节需要单独花时间细看。

总体可以概括如下：

$$ x^{t+1}, v^{t+1}, F^{t+1}, C^{t+1} = S(x^{t}, v^{t}, F^{t}, C^{t}, \theta , \Delta t) $$

F和C分别是局部变形场的梯度和应力场的梯度，$\theta$ 代表所有的物理量，在文章里代表E，$\Delta \approx 1 \times 10^{-4}$，仿真了100步。

对于每一步，按如下公式渲染：

$$ \hat{I}^t = F_{render}(x^t, \alpha, R^t, \Sigma, c) $$

R代表所有粒子的旋转矩阵，

优化的参数是杨氏模量和初始帧的速度，损失函数定义如下：

$$ L^t = \lambda L_1(\hat{I}^t, I^t) + (1-\lambda)L_{D-SSIM}(\hat{I}^t, I^t) $$

创新点(MPM加速)

高斯模型包含成千上万个点，这对于模拟来说效率较低。因此，本文采用了下采样方法，每个下采样后的点能够有效描述其对应领域的信息。此外，下采样对3D几何形状（3DGS）的表征同样至关重要。因为3DGS表征存在过于局部化的问题（不同区域之间的表征可能会出现突变或不连贯），这会导致空间表征的不连续性。通过下采样后，每个点包含了其领域的信息，从而有可能推动表征向混合高斯模型（mixture-Gaussian）方向发展，使得空间的整体表示更加连续。这样的方法可能为将三维场景表示为一串序列提供了思路，可以进一步应用于MLLM。例如，可以将该序列视作一个Encoder-Decoder模型，并通过重建信息作为监督信号进行训练。

结果

数据集：八个真实场景，大部分是花，这个作为对照组

其实没什么意义，因为本身这篇论文是在前两篇的基础上做的，而且PhysGaussian没有优化物理参数，DreamGaussian没有物理假设。。

讨论

视频生成的方式

用SVD采样得到了14帧的信息作为监督。

疑问的点，text-prompt怎么设计，比如花在空中摇摆，或者被人碰了一下，怎么去量化这个幅度？

loss的设计

用生成得到的视频监督是否合理？因为整个3DGS的参数很多，这篇文章只是监督了E，而其他的位置，速度等信息都是仿真算出来的，所以DoF，或者说优化的参数空间其实比较小。但是如果要学习更多的物理信息，只用SVD去监督肯定不合理。

其次，生成得到的视频离真实场景还是有差别，所以还是要做一个trade-off，一种方法是减少生成视频对模型的影响，例如使用结构损失作为损失函数，或者将生成的视频帧作为guidance来进行distillation，另一种是降低估计的Dof，想这篇文章做的那样，固定泊松比和质量，只估计杨氏模量，第三种方式是提高视频生成的能力，脱离SDS损失函数的监督，转向全监督学习，即让生成的视频与真实场景之间有更多直接的监督。

Generative Image Dynamics

Mon, 17 Feb 2025 00:00:00 +0000

论文信息

CVPR 2024 Best Paper

论文题目： Generative Image Dynamics

是否开源： 否

总结：

一种从静态图像生成动态运动的方法，特别是针对自然的振荡运动，如树木在风中摇动、花朵或蜡烛火焰的摆动等。核心思想是使用频谱体积，这是一种基于频率的像素运动表示，通过真实视频序列进行学习。

细节

输入单张图片$I_0$, 输出${\hat{I}_1, \hat{I}_2, ..., \hat{I}_T}$，

用LDM从输入的单张图片中预测谱体积 $\mathcal{S}=\left(S_{f_0},S_{f_1},...,S_{f_{K-1}}\right)$ ，然后再利用这个谱体积恢复$\mathcal{F}=(F_1,F_2,...,F_T)$，即后面T个时刻的运动。$F_t(p)$ 代表t时刻$I_0$中第p个像素的位置。（$I_t^\prime(\mathbf{p}+F_t(\mathbf{p}))=I_0(\mathbf{p})$）

spectral volume（谱体积）： 从视频中提取的每像素轨迹的时间傅里叶变换。

频谱分析->解决生成视频的长期时间一致性??

k个频率，(x,y)+- 共4K个channel

对于一张 $H \times W$的图片，每个像素p可以表示为$I_{t}(p) = \Sigma_{k} [Asin(k \omega x t) + B cos(k \omega x t)]$

值得阅读的参考论文

Myers Abraham Davis. Visual vibration analysis. PhD thesis, Massachusetts Institute of Technology, 2016.