51c深度学习~合集13
为了利用VGGT在头部嵌入层面的标记的空间局部性和时间对应性，我们引入了一种时间重排序和头部级自适应异常值过滤技术，该技术帮助HTTM高效合并标记，同时保留其独特性，从而在长输入序列上实现高达7倍的显著加速，且性能无下降。如图2所示，我们面对的不是简单的＂红苹果＂和＂绿苹果＂，而是像＂一只金毛猎犬在公园草坪上追赶红盘＂、＂盘子里放着鲜红的草莓、黄香蕉和深紫色的葡萄＂这样高度复杂的场景。在图5中，我
我自己的原文哦~ https://blog.51cto.com/whaosoft143/14340104
#xxx
....
#xxx
....
#xxx
....
#xxx
....
#xxx
....
#xxx
....
#Over++
生成式特效合成新SOTA，完美保留原片，支持文本+蒙版双控
今天想和大家聊一篇非常酷的论文，它来自 北卡罗来纳大学教堂山分校 (UNC)、马里兰大学 (UMD) 和电影特效巨头 光影魔幻工业（ILM）——没错，就是那个制作了《星球大战》特效的传奇公司。这篇名为《Over++》的论文，正试图用 AI 彻底改变视频特效制作的游戏规则。
- 论文标题：Over++: Generative Video Compositing for Layer Interaction Effects
- 核心机构：University of North Carolina at Chapel Hill (UNC), University of Maryland (UMD), Industrial Light & Magic (ILM)
- 论文地址：https://arxiv.org/abs/2512.19661
- 项目主页：https://overplusplus.github.io/
在影视后期制作中，当一个角色或物体（前景）被放置到新的场景（背景）中时，最耗时耗力的工作之一，就是手动为它们添加与环境交互的特效，比如脚踩在水坑里溅起的水花、身体在墙壁上投下的阴影、飞速的汽车扬起的尘土。这些细节决定了画面的真实感。传统方法需要特效师像“手工艺人”一样，逐帧精心雕琢。
近年来，虽然视频生成模型层出不穷，但它们要么像“脱缰的野马”，在生成特效的同时，把原始的前景和背景内容也改得面目全非；要么像需要“保姆级”指导的工具，得提供精确到每一帧的蒙版（Mask）才能工作，费时费力。
上图展示了现有修复模型（如 VACE）的局限性，即便给了蒙版，也未必能生成理想的船尾浪花效果。而 Over++（最右）则成功做到了。
为了解决这个痛点，作者提出了一个全新的任务——增强合成（Augmented Compositing），并推出了实现这一任务的框架 Over++ 。这个名字也很有意思，它致敬了 1984 年图形学经典论文中提出的“Over”合成操作（即前景叠加于背景之上），而“++”则意味着对这一基础操作的强大“增强”——自动补全那些缺失的物理交互。
简单来说，Over++ 的目标是：在完全保留原始前景和背景内容的前提下，根据简单的文本指令（比如“生成烟雾”）或粗略的区域圈定，就能自动、逼真地生成两者之间的交互特效。
Over++ 是如何工作的？
Over++ 的设计思路十分巧妙。它不像其他模型那样试图“重新绘制”整个视频，而是专注于“添加”缺失的特效。
上图就是 Over++ 的整体框架。我们可以看到它的工作流程：
- 输入：
- 一个已经简单合成好的、但缺少交互特效的视频（）；
- 一个可选的、用于指定特效大致区域的蒙版视频（）；
- 以及一句描述你想要什么特效的文本（）。
- 核心处理：
- 模型 会接收这些信息，并利用一个预训练的视频扩散模型作为骨干，在噪声视频 的引导下，进行去噪生成。
- 关键点：它将无特效的输入视频 和蒙版 作为强大的条件注入到生成过程中。
- 输出：
- 一个带有逼真、动态交互特效的最终视频（）。
这个框架最核心的优势在于，它将生成过程严格约束在“添加特效”这个任务上，从而极大地保证了原始视频内容的保真度。
巧妙的数据策略：从“有”到“无”，再从“无”到“有”
训练这样一个模型，最大的挑战是去哪里找大量的“有特效”和“无特效”的成对视频数据呢？总不能让特效师手动去“P 掉”成千上万个视频里的特效吧。
作者提出了一套非常聪明的数据构建流程：
- 创建配对数据：他们反其道而行之。
- 首先，收集一批本身就带有特效的视频（）；
- 利用 Omnimatte 等先进的视频分层技术，将视频分解为“干净的背景”（）和“带特效的前景”（）；
- 然后，再用分割工具从“带特效的前景”中抠出“纯净的前景主体”（）；
- 最后，将这个“纯净的前景”重新叠加到“干净的背景”上，就得到了一份“无特效”的视频（）。
- 这样，就轻松构建了 (, ) 这样的完美配对数据。他们用这种方法构建了包含 54 个真实视频 和 573 个合成视频 的配对数据集。
- 引入非配对数据：仅有配对数据还不够，模型可能会在学习过程中“忘记”如何理解丰富的自然语言指令。为此，他们还引入了 460 个非配对视频。
- 这些视频是直接用文本到视频（T2V）模型生成的，只包含各种特效，没有对应的无特效版本。
- 在训练时，通过一种特殊的“无条件”训练技巧（将 和 的条件置空），让模型能同时学习这些纯文本驱动生成的样本。
这种“配对+非配对”的混合训练策略，使得 Over++ 既能精确地学习到如何添加特效，又保持了对文本指令的高度敏感和强大的编辑能力。
消融实验证明（如下图）：如果没有非配对数据（Unpaired Data）的加持，模型就无法理解“Blue smoke”（蓝色烟雾）这样的具体文本指令，只能生成默认的白色烟雾。
实验效果：不仅效果逼真，而且“指哪打哪”
论文进行了详尽的实验，来证明 Over++ 的强大之处。
定性对比：效果一目了然
在无蒙版引导的纯文本生成任务中，研究者将 Over++ 与 AnyV2V、LoRA-Edit 以及商业软件 Runway Aleph 等前沿方法进行了比较。
从上图可以直观地看到（图中红色框内为特效区域），其他方法或多或少都会改变原始视频的内容、外观甚至构图，而 Over++（最左侧“Ours”）则能在完美保留主体和背景的同时，精准地生成所需的船尾浪花、阴影和水面倒影。
定量对比：数据遥遥领先
在量化指标上，Over++ 同样表现出色。研究者设计了一个名为 的新指标，用于衡量生成特效的方向是否与真实特效一致。
如上表所示，无论是在特效方向准确性（46.27）、内容保真度（SSIM 0.80），还是视频质量（VMAF 29.30）等多个维度，Over++ 都全面超越了现有方法。
用户研究：专业人士和普通人都点赞
研究者还邀请了包括 14 名专业 VFX 特效师在内的 30 名用户进行了一项用户研究。结果显示，在与各类方法的两两对比中，Over++ 在“文本遵循度”、“蒙版匹配度”和“内容保真度”上获得了压倒性的好评率（win rate）。
丰富的可控性与应用场景
Over++ 最令人兴奋的地方在于其高度的灵活性和可控性，为视频创作流程带来了多种可能。
从上图的四个案例中，我们可以看到：
- 蒙版引导：用户可以提供一个粗略的蒙版，精确控制特效（如烟雾、水花）在视频中的时空位置。
- 文本编辑：可以直接用文本改变特效的属性，比如将默认的烟雾改成“Red smoke”（红色烟雾）。
- 强度缩放（CFG Scaling）：通过调整 CFG 参数，可以控制特效的强度，比如实现从“轻微的水花”到“更猛烈的水花”的渐变。
更棒的是，模型对于不完美的蒙版也具有极强的鲁棒性。
在上图中，即使用户的蒙版（上）错误地圈中了人和阴影，或者（下）画了一个毫不相关的圆形区域，Over++ 依然能智能地理解意图，只在正确的位置生成阴影和水花。
此外，它还支持 关键帧蒙版（Keyframe Mask）。用户只需在少数几个关键帧上标注蒙版，模型就能自动插值，在整个视频片段中生成连贯、自然的特效，大大减轻了标注负担。
写在最后
目前作者已经放出了代码仓库，但还未开放代码和模型。
....
#StreamAvatar
太可怕了，数字人也可以像真人一样交互了！StreamAvatar：不仅能说还能听！高保真实时交互数字人新突破！
数字人，这个未来感十足的概念，正以惊人的速度走进我们的生活。然而，如果你关注过这个领域，或许会发现一个痛点：高保真的数字人往往难以做到“实时”和“交互”。想让数字人不仅能流畅地“说”，还能自然地“听”，甚至全身都能灵活互动，这在技术上一直是个巨大的挑战。传统的扩散模型虽然在生成质量上表现出色，但其高昂的计算成本和非因果架构，让它们在实时流媒体应用面前显得力不从心。
今天，清华大学、中国人民大学、腾讯混元和南京大学等机构的研究人员为我们带来了 StreamAvatar，一项旨在打破这一僵局的创新成果。StreamAvatar 首次实现了基于扩散模型的高保真、实时、流式交互式人体数字形象生成，让数字人真正做到了“能说会听”，并且能流畅表达全身的姿态和手势，为教育、娱乐和虚拟助手等应用场景带来了无限可能。
- 论文标题：StreamAvatar: Streaming Diffusion Models for Real-Time Interactive Human Avatars
- 作者：Zhiyao Sun, Ziqiao Peng, Yifeng Ma, Yi Chen, Zhengguang Zhou, Zixiang Zhou, Guozhen Zhang, Youliang Zhang, Yuan Zhou, Qinglin Lu, Yong-Jin Liu
- 机构：清华大学, 中国人民大学, 腾讯混元, 南京大学
- 论文链接：https://arxiv.org/abs/2512.22065
- 项目主页：https://streamavatar.github.io
背景与动机：数字人交互的“不可能三角”
长久以来，数字人生成领域面临着一个“不可能三角”：高质量、实时性、强交互性。尤其是基于扩散模型的方法，虽然在图像和视频生成方面取得了显著突破，但在实时交互场景中仍有三大挑战：
- 实时流式传输的困境：扩散模型通常需要迭代去噪，并且其非因果的双向注意力机制需要一次性处理整个视频序列，这与流媒体的实时性需求格格不入，计算成本也极为高昂。
- 长时生成稳定性的挑战：当数字人需要进行长时间交互时，现有方法容易出现误差累积和身份漂移，导致生成内容缺乏一致性和稳定性。
- 说话-听觉交互的不足：大多数数字人模型只专注于“说话”的生成，却忽略了“听”这一重要的交互环节。在真实的对话场景中，如果数字人只知道说而不会听，缺乏自然的反应和肢体语言，就会显得极不自然，互动体验大打折扣。此外，现有交互方法通常仅限于头部和肩部区域，无法表达丰富的全身姿态和手势。
StreamAvatar 正是为了解决这些痛点而生，旨在实现高保真、实时、全身交互的数字人视频生成。
核心方法：两阶段加速与交互增强
StreamAvatar 提出了一种创新的两阶段自回归适应与加速框架，将高保真人体视频扩散模型成功适配为实时、流式的交互式生成器。
图1：StreamAvatar概述，展示了其两阶段框架如何实现实时、流式、交互式视频生成。
1. 第一阶段：自回归蒸馏 (Autoregressive Distillation)
这一阶段的核心目标是将原始的双向扩散模型（通常是 Diffusion Transformer, DiT）重新架构并蒸馏成一个因果（causal）、少步骤的生成器，以支持实时流式处理。
图2：两阶段自回归适应与加速框架总览。原始双向DiT首先转换为块因果DiT，然后通过蒸馏和对抗性精炼实现实时生成。
- 重构架构：将原始 DiT 的固定生成窗口拆分成更小的块（例如，参考帧块和后续生成块），并强制块间因果注意力及块内双向注意力。这种设计允许模型在保持局部动态的同时进行自回归生成。为了高效推理长视频，还采用了滚动KV缓存。
- 蒸馏流程：通过 Score Identity Distillation 技术，将复杂的双向教师模型的能力蒸馏到一个简单的块因果学生模型中。
为了确保长视频生成的稳定性和一致性，StreamAvatar 引入了两个关键机制：
- Reference Sink (参考汇 / 参考帧注意力汇) ：为了防止“注意力汇”现象导致的上下文丢失，模型将参考图像的特征作为“汇”（Sink）保留在注意力计算中，有效防止长时间生成中的身份漂移。
- Reference-Anchored Positional Re-encoding (RAPR，参考锚定位置重编码) ：这是一种改进的位置编码策略，它以参考帧为锚点，允许模型更好地理解和利用帧间的相对位置信息，从而在无需长视频训练的情况下，显著提高长视频生成的一致性。
图3：Vanilla RoPE 与 Reference-Anchored Positional Re-encoding (RAPR) 的比较。RAPR在不依赖长视频训练的情况下，有效改善了长视频生成的效果。
2. 第二阶段：对抗性精炼 (Adversarial Refinement)
经过第一阶段蒸馏后的模型虽然具备了实时能力，但可能存在视觉伪影和时间不一致性。为此，StreamAvatar 引入了对抗性精炼，其中最关键的是一个新颖的一致性感知判别器 (Consistency-Aware Discriminator) 。
- 双分支判别器设计：该判别器具有“局部真实感分支”和“全局一致性分支”：
- 局部真实感分支：评估单个生成帧的视觉真实感。
- 全局一致性分支：通过参考帧特征与所有后续帧特征的交叉注意力，明确惩罚生成视频与参考帧之间的身份和时间不一致性。
- 通过对抗训练，结合相对对抗损失和梯度惩罚，进一步优化生成器，使其输出的视频在质量和一致性上达到更高水平。
3. 交互行为：能说会听的“灵魂”
为了使数字人能够自然地进行交互，StreamAvatar 在模型中加入了对说话和听觉行为的精准控制。
- 音频掩码 (Audio Mask)：StreamAvatar 采用 TalkNet 等方法获取音频掩码来区分说话和听觉阶段。重要的是，音频掩码是在 Wav2Vec 特征提取之后应用，通过乘法调制这些特征，而非直接修改原始音频波形。这保留了音频特征的高保真度，同时提供了精确的时间控制。
- 音频相关注意力模块：模型扩展了 Transformer Block，引入了两个专门的注意力模块：
- Audio Attention (音频注意力) ：在说话片段中引入“说话线索”，驱动富有表现力的人体动作。
- Interact Audio Attention (交互音频注意力) ：在听觉间隔中引入“听觉线索”，生成自然的反应行为。
图4：交互式人体生成模型中Transformer block的架构。原始block通过添加音频相关的注意力模块，以支持说话和听觉的条件生成。
通过这些机制，StreamAvatar 能够实现说话和听觉状态之间的平滑过渡，生成符合语境的表情、手势和反应，从而展现出远超传统“只说不听”方法的真实感和连贯性。
实验与结果：SOTA性能与惊人效率
StreamAvatar 在定性和定量实验中均展现了卓越的性能。
图5：与最先进的说话数字人视频生成方法的定性比较。
图6：与基线在交互式数字人视频生成上的定性比较。StreamAvatar在听觉阶段能自然地对音频做出反应。
定量结果与效率分析：
在说话数字人视频生成方面，StreamAvatar（作为一个仅有 3 步的因果模型）在多项指标上均达到或超越了现有SOTA方法。
- 卓越的生成质量与一致性：在 FID (Fréchet Inception Distance)、ASE (Action Synchrony Error)、IQA (Image Quality Assessment)、Sync-C (Audio-Lip Synchronization Consistency) 等关键指标上，StreamAvatar 取得了最佳或次佳成绩。特别值得一提的是，它在实现高运动幅度的同时，保持了较低的异常率。
- 惊人的效率提升：
- 基准对比：在单张 H20 GPU 的基准测试下，生成 720p 分辨率、5 秒的视频，StreamAvatar 仅需 20秒。相比之下，其他先进方法如 StableAvatar 需要 12 分钟，OmniAvatar 需要 36 分钟，HunyuanVideo-Avatar 更是需要 74 分钟！这无疑是数量级的效率飞跃。
- 实时部署：值得注意的是，20秒生成5秒视频尚未达到实时标准（RTF=4）。但论文进一步指出，在采用双 H800 GPU 进行优化部署（并行处理 DiT 去噪和 VAE 解码）时，模型实现了 1.20秒的总延迟和
RTF<1 的性能，真正做到了实时流式生成。
表1：与最先进的说话数字人视频生成方法的定量比较。StreamAvatar在多项指标上表现出色，尤其在生成时间上优势显著（注：表中时间为单卡H20测试数据）。
在交互式数字人生成方面，StreamAvatar 也显著优于仅说话的基线模型，证明了其在生成丰富听觉动作方面的能力。
用户研究： 用户研究结果进一步印证了 StreamAvatar 的优势。参与者在“音频-嘴唇同步”、“运动动态”、“时间连续性”、“视觉质量”和“身份保持”等五个维度上，都更倾向于 StreamAvatar 生成的视频。
图7：用户研究结果：StreamAvatar在多项用户感知指标上均优于或与SOTA基线持平。
写在最后
StreamAvatar 的出现，无疑是数字人交互领域的一个重要突破。它不仅将扩散模型带入了实时、流式的全新范式，更通过对“听觉”行为的精准建模，赋予了数字人更加自然的“灵魂”。数字人不仅能对你的话语做出回应，眼神、表情甚至细微的手势都能传达出“我在认真听你讲”的信息，这种交互体验是前所未有的。
最后看一下研究团队放出的展示结果：
，时长01:25
以上是单人的效果，看完感觉天塌了，这竟然是生成的！
，时长00:54
以上是交互的Demo，感觉数字人主播不仅交互得到位，还挺真诚的！
最后上大招，看段有意思的，“非著名歌手”Yann Lecun（观看时一定打开音频）:
，时长02:27
我感觉除了牙齿，真的是很完美了！
....
#Improving the Diffusability of Autoencoders
Scale Equivariance：低代价提升 Autoencoder 可扩散性的实用技巧
本文提出「可扩散性」概念：Autoencoder latent 高频分量过盛会拖累 LDM 学习，为此作者用“下采样-等变”正则强制对齐 RGB 与 latent 频谱，仅微调 20 K 步即可让 DiT/B 在 ImageNet 256×256 上 FID 从 2.06 降至 1.74，视频生成同步提升，代码已开源。
本文属于是 VAE 性质探索类型的文章。
可扩散性 (Diffusability) 这个词一般来说指代：一个数据分布 "有多容易被扩散模型学会"。可扩散性高意味着说明这个分布容易拟合。可扩散性低意味着建模难度更高。
本文作者对现代 Autoencoder 进行了谱分析，并且识别到 latent space 中存在高频分量。
作者认为这种高频分量与扩散过程相互干扰，影响了生成质量。
为了削弱这个问题的影响，本文提出 Scale Equivariance：一种简单的正则化技术，通过强制 Scale Equivariance 对齐各个频率的 latent space 和 RGB space。只需对代码进行少量改动，执行最多 20K 步的微调，即可提升图像生成和视频生成性能。
本文还有一篇同期工作 EQ-VAE (EQ-VAE: Equivariance Regularized Latent Space for Improved Generative Image Modeling (ICML 2025))，两者在方法上很像，英雄所见略同。
下面是对本文的详细介绍。
1 提升 Autoencoder 的可扩散性
论文名称：Improving the Diffusability of Autoencoders (ICML 2025)
- 论文地址： https://arxiv.org/pdf/2502.14831
01 论文解读：
Autoencoder 频谱分析
本文认为对于 Autoencoder 而言，有三个特性对其构成的 Latent Diffusion Models 的实用性至关重要，分别是：
- 重建质量 (Reconstruction Quality)：决定生成保真度的上限。
- 压缩效率 (Compression Efficiency)：决定生成的速度和成本。
- 可扩散性 (Diffusability)：往往决定其实用性，低可扩散性意味着你需要更复杂，更重的 Diffusion Backbone，影响 LDM 的质量。
本文首先分析了常用图片和视频 Autoencoder 的 latent 表征的频谱特性。
1.1 频谱分析方法：Blockwise 2D DCT
分析的方法也很直观，使用的是 Blockwise 2D DCT。一种对 2D 信号进行离散余弦变换 (Discrete Cosine Transform, DCT) 的技术，将信号从空域转化到频域。DCT 会把原始的信号表示为一组水平和垂直余弦基底的系数，这些基底以不同的频率振荡。
比如，给定 2D Block 空域信号 ，其中 代表位置 处的 pixel intensity。2D DCT 得到 2D Block 频域信号 ，其中 代表对应水平和垂直余弦基底的系数。
在实践中，作者将输入的 2D 信号拆分为大小为 的非重叠 Block，并独立处理每个 channel。
按照上述做法，作者进行了频域分析，下面的横轴是从 0 到 的 zigzag 顺序的 index，代表了从最低频 到最高频 的 DCT 系数的 index。
令 表示按照频率上升的顺序。给定一个 Block，对于每个频率 ，可以计算归一化的幅值为：
定义频率特性 (Frequency Profile) 为在标准 zigzag 顺序下，归一化幅值的序列。
1.2 频谱分析结果
作者训练了一系列具有不同 channel size 的 FluxAE 模型，对于每个模型，计算所有 channel，所有 Block 下，256 个样本的平均频率特性。结果如下图 1 所示，展示了 Flux autoencoders 和 RGB 空间的频率特性。结果：
- 相比于 RGB 空间，FluxAE 的频率特性中高频分量显著增加。
- 随着 Autoencoder 的 bottleneck channel 数的增加，高频分量变得更加显著了。
作者假设这个原因是更多的 bottleneck channel 数允许 autoencoder 捕获到更加精细，高频的细节。而有限的容量优先考虑更加平滑，低频的细节。随着其容量增加，模型编码到额外的高频分量，以一种非结构化的方法不均匀地分布在不同 channel 之间。
图1：不同 bottleneck size 下，FluxAE Autoencoders 的 latent 频率特性和 RGB 频率特性。1) autoencoder 的 latent 频率特性与 RGB 频率特性，在分布上很不同。2) latent channel size 越大，高频幅值也增加
也就是说，核心发现是：latent space 的高频分量显著增多，与 RGB space 频谱的分布截然不同。随着 channel size 增加 (提升重建性能)，这个现象更加明显。
那么，Autoencoder 的高频分量增多了，有什么影响呢？
作者假设说这种相对平滑的频谱分布会损害频谱自回归特性，且证明了这种高频分量会影响最终的 RGB 结果，引入明显的视觉伪影。作者说明标准的 KL 正则化不足以解决这个问题，且甚至会加剧这个问题。
为什么呢？
LDM 中常用的 VAE 的训练，一般来讲是鼓励：latent 分布与标准高斯分布对齐。
KL 正则项本来是好事，它使得扩散模型的任务变简单了，因为 latent 分布更 "像" 高斯分布了，而扩散模型实际上链接的就是 latent 分布与标准高斯分布。这样一来，看上去任务变 "简单" 了。
但是实际上，把 latent 分布与标准高斯分布对齐，还会有副作用。
标准高斯分布可以视为是一种噪声，而且是非扩散的结构性的噪声。
VAE 的核心机制是：
KL 项是：
当你 加大 KL 权重时，模型会被迫：
- 把 拉向 。
- 把 拉向 。
就相当于是在 latent 表征中引入更多随机噪声。
当 KL 变强时：
- latent 中的高频细节首先被噪声破坏，频谱更 "杂"。
- 频谱分布变 "更平坦" (high-frequency 被抬高)。
这就使得 diffusion model 在 latent 上建模时，不得不同时拟合：1) 有意义的语义结构，和 2) 无意义的高频噪声，使得扩散过程更艰难 (less diffusability)。
如下图 2 所示，更高的 KL 正则化会引入更多高频信号，削弱 diffusability。
图2：使用不同 KL 正则化强度训练的 FluxAE autoencoder 的频谱。KL 正则化的好处：把 latents 分布推向高斯分布，为扩散模型减负。坏处：由于随机噪声，为 latents 引入了高频信号，使得 LDM 也要被迫建模
1.3 削弱 latent 表征中的高频分量：一种简单的正则化策略
为了削弱 latent 表征中的高频分量，本文采取的做法是：一种简单有效的**正则化策略 (Regularization strategy)：缩放等变性 (Scale Equivariance)**。
本文认为好的正则化策略应该注重两个方面：
- 在 latent space 中压缩高频信号。
- 防止 Decoder 增强这些信号，因为对于最终结果的影响很重要。
具体做法：
在不同频率处对齐 latent space 和 RGB space。
怎么对齐？
一种直接的做法是：在 latents 空间和 RGB 空间，都截断一部分高频信号。然后训练 decoder，对齐截断之后的 latents 表征和截断之后的 RGB 信号。
关于这里作者初步的做法是：Chopping High Frequencies (CHF)。
这个 CHF 的做法就是非常简答粗暴：对 latents 表征和 RGB 空间做 DCT ，然后 mask 掉高频信号。再把修改后的部分通过 inverse DCT 反变换回空域，得到待训练的 latents 表征和 RGB 空间。
其中， 是 的 binary mask，代表被 mask 掉的频率：
式中， 控制截断的频率。
实验结果如下图 3 所示，可以看到 Autoencoder 可以学会改变其 latents 频率特性，把输入编码到低频区域，同时无需太多牺牲重建质量。
图3：逐渐去除高频分量，RGB，FluxAE 以及 FluxAE+CHF 的重建结果。第1行：RGB 退化很少。第2行：但对于 FluxAE，随着 latents 空间的高频信号被去除，重建结果出现迅速的退化。第3行：CHF 正则化帮助 autoencoder 更依赖于低频区域，压缩结果更好
有了这个初步实验，作者进一步提出了一种更简单的做法：直接下采样，不用做 DCT 了。
对于 Decoder，强制 Scale Equivariance：保证下采样的 latents 与下采样的 RGB 表征相对应。
对输入 和 latents 表征 下采样得到 以及 。这个过程会去除掉 RGB 和 latents 信号的高频分量。在实践中采用 双线性下采样。
正则化方法：确保 与下采样的 latent 的重建结果 一致。Autoencoder 使用下面的目标函数训练：
其中， 代表用于重建的距离度量函数，使用 mean squared error loss 和 perceptual loss。 代表正则化强度。
图 4 是 FluxAE 的谱分析实验结果。
目标1：在 latent space 中压缩高频信号。
本文给出的 Scale Equivariance (SE) 正则化降低了高频分量，使得与 RGB 空间的频谱特性更加接近了。
目标2：防止 Decoder 增强这些信号，因为对于最终结果的影响很重要。
图5显示 SE 保留了更多内容，因为高频分量被压缩了。
图4：FluxAE latents 使用以及不使用 scale equivariance (SE) 正则化的 DCT 谱分析结果。使用 SE 对 Autoencoder 进行微调之后，其频谱更像 RGB 了
图5：FluxAE 使用以及不使用 scale equivariance 微调的 ImageNet 重建指标对比。随着去除了更多的高频细节，带有正则化的 AE 一致性地取得了更好的重建质量
1.4 实验结果
Image Autoencoder
对于 image autoencoder，作者使用 FluxAE（ 空间压缩， 16 latent channel）， 空间压缩， 16 latent channel）。对于所有的实验，使用 batch size 32，微调 10,000 steps（相当于一共看了 320,000 张图片）。
LDM benchmark：ImageNet 256×256
Model：DiT (添加了几个最近的改进)
实验结果如下图 6 所示。可以看到本文提出的正则化技术大幅提升了 diffusability，相比于原始的 FluxAE 以及不用 SE 正则化微调的 FluxAE，效果都有提升。
图6：ImageNet 实验结果
对于 CMS－ ，提升减少了。原因是本文的 training pipeline 会损害其性能。只使用 Reconstruction Loss 微调 10,000 步之后（其默认不使用 KL 正则化），FID 性能从 11.69 退化到了 13．59。
Video Autoencoder
对于 video autoencoder，作者使用 CogVideoX-AE (4×8×8 压缩，16 latent channel)，LTX-AE (8×32×32 压缩，32 latent channel)。对于所有的实验，使用 batch size 32，在图像和视频联合数据集上，微调 20,000 steps (Image batches 被视为是单帧视频)。
Dataset：Kinetics-700
Model：DiT
实验结果如下图 7 所示。SE 正则化训练之后的 DiT 的性能明显更好。本文的 training pipeline 使得 DiT-B 在 CogVideoX-AE 上训练得更好，在 LTX-AE 上分数更差。而添加本文的正则化策略之后，可以大幅提升每种情况 LDM 的性能。
图7：Kinetics-700 实验结果
而且，作者观察到 video autoencoders 的提升比 image autoencoders 更明显。作者将原因归结为两点：
- Frechet Distances 的提升不是线性的 (它们的值较小，很难继续改进)。
- video autoencoders 的 latent 结构更加不规则，为改善 latent space 的可扩散性带来更多空间。
消融实验结果
1) Scale Equivariance 会损害重建性能吗？
下图 8 展示的是 ImageNet 和 Kinetics 的 50,000 张样本的 PSNR, SSIM, LPIPS, FID 结果。ImageNet 和 Kinetics 分别对应 image 和 video autoencoders。从图里可以看到，重建质量前后基本相似。
图8：正则化对 image 和 video autoencoder 重建质量的影响。image autoencoder 用 ImageNet-1K 中采样的 50,000 张图片评估。video autoencoder 用 Kinetics-700 中采样的 50,000 个视频评估
2) 调整 KL 正则项的权重可以改进 LDM 性能吗？
如图 9 所示，提升 KL 正则化强度对于小模型 DiT-S/2 来讲，可以提升生成性能，但是代价是会损害重建性能。而且，对缩放性有限，对于大模型 DiT-L/2 来讲，表现较差。
但是，本文提出的 SE 正则化，可以在提升生成性能的同时，不损害重建质量。
图9：KL 正则化强度对微调 FluxAE 的影响，评价指标为重建质量以及 DiT-S/2，L/2 性能。提升 KL 正则化强度对于小模型，可以提升其生成性能，但牺牲重建质量。而且，缩放性质也有限，DiT-L/2 表现较差。本文的 SE 正则化可以提升 LDM 性能，不损害重建，且缩放性好
3) SE 正则化强度的影响
图 10 中，作者展示了 SE 正则化强度的影响。提升正则化强度会使得重建质量恶化。作者选择 0.25，来维持重建性能，同时改善生成质量。
图10：不同 SE 正则化强度做微调的重建性能
4) DCT 频率裁剪的影响
这个实验目的是为了检验下采样正则化的影响。SE 正则化训练的目的是削弱 latent 表征中的高频分量。那么削弱的效果如果达到了，那么应该在 DCT 高频分量裁剪之后，带有 SE 正则化训练的 autoencoder 的重建效果不错才对。
因此，这个实验中作者做法是：从 latents 中逐步去除高频 DCT 分量，并评估重建质量。
如上图 5 所示为：FluxAE，使用正则化微调的 FluxAE，不使用正则化微调的 FluxAE，在 ImageNet 验证集的 512 个样本的重建指标。
现象：随着横轴的 cut ratio 增加，表明去除了更多的高频分量。此时，带有正则化 latents 的 autoencoder 一致性地收获了更好的重建指标。
结果：结果表明正则化在对齐 latent 和 RGB 空间的频谱特性方面的作用。
....
#EQ-VAE
为 VAE 注入空间变换等变性，重塑更“好学”的 latent space
ICML 2025 提出 EQ-VAE：用隐式等变正则让 latent 对旋转/缩放保持 τ∘E(x)=E(τ∘x)，微调 1 epoch 即可使 DiT-XL/2 生成 FID 从 19.5 降至 14.5，训练提速 4 倍，连续与离散 VAE 通用，代码已开源。
本文属于是 VAE 探索类型的文章。
本文的核心观点是：本文作者认为现有的 Autoencoder 对于缩放 (scaling)，旋转 (rotation) 这样的语义保留的操作，缺乏等变性 (Equivariance) 。
这里的等变性指的是：
如果输入经过某个变换 (例如旋转、平移、缩放)，模型的输出也会以 "同样的方式" 变化，那么模型就对该变换是 equivariant 的。
那么基于这一点，本文提出了 EQ-VAE，目的是在 latent space 中强调等变性。
只需要按照 EQ-VAE 的范式微调 VAE，即可增强 DiT，SiT，REPA，MaskGIT 等生成式模型。
下面是对本文的详细介绍。
1 EQ-VAE：为 VAE 注入空间变换等变性
论文名称：EQ-VAE: Equivariance Regularized Latent Space for Improved Generative Image Modeling (ICML 2025)
论文地址：https://arxiv.org/pdf/2502.09509
项目主页：https://eq-vae.github.io/
1 EQ-VAE 论文解读：
1.1 现有 LDM 的关键组件：Autoencoder
现代的 Latent Generative Model 一般分为两步：
- 通过 Autoencoder 将高维度图像压缩到低维度 latent space。这个 latent space 既可以像 SD-VAE那样时连续的，也可以像 VQ-GAN那样是离散的。latent space 保留了重要的语义和结构信息，丢弃了高频信息。
- 通过生成式模型，在这个 latent space 上建模，生成高质量的图片。
在推理过程中，生成式模型首先采样一个 latent code，然后通过 Autoencoder 解码回原始图像空间。
虽然现在大量研究着眼于生成式模型的架构，训练目标，以及优化策略，对于 Autoencoder 的研究却同样重要。
latent space 的重要性体现在两方面：
- 影响计算效率：latent space 的维度远低于图像的维度，加速生成式模型的收敛速度。
- 影响模型生成高保真度图片的能力。
很多知名的工作，如 DiT，SiT，SD3，FLUX 等都使用了 LDM里提出的 SD-VAE。LDM 探索了两种正则化策略：
- 基于连续的策略：使用 KL 散度对齐 latent 分布和高斯先验，产生平滑且结构化的 latent space。
- 基于离散的策略：将 latent space 限制为一组有限的 learned embedding。
这里我们以基于连续的策略的 Autoencoder 为例进行介绍：
给定输入图像 ，Autoencoder 的编码器 将其编码为压缩的表征 。Autoencoder 的解码器 将压缩的表征再解码回图片 。训练方法：
式中：
- ：包括一个 reconstruction loss，和一个 perceptual loss（比如 LPIPS）。
- ：包括对抗损失。
- ：是与高斯先验的正则化项（regularization term）。
正则化会带来一个 tradeoff：更强的正则化，例如增加 KL 散度项的权重的好处是：会得到更加光滑，更好学的 latent space。这个 latent space 就会在第二阶段被生成式模型用上。但是缺点是：会降低 latent space 的信息量，丢失掉一些高频细节，影响重建能力。
Autoencoder 保存细节信息的能力，限制了生成式模型生成高保真图片的能力。
1.2 Autoencoder 缺乏等变性
本文探索的问题是：我们能不能获得更适合生成式建模的 latent space，在不妥协重建质量的同时，改善整体的生成式建模？
本文的做法是从 Autoencoder 给出的 latent space 入手：
作者观察到 Autoencoder 存在一个关键的问题：其 latent 表征对于一些基本的空间操作 (如缩放，旋转这样的语义保留的操作)，缺乏等变性 (Equivariance) 。这个缺点会为 latent space 带来不必要的复杂度，迫使生成模型学习一些本可以避免的非线性关系。
在定义等变性之前，首先定义空间变换。
比如， 代表一张定义在二维坐标系 上的图片。 现在对坐标系 施加空间变换 之后，图片变为：
变换后则图片可以记作： 。
等变性： 对于图像 和变换 而言，如果满足：
则称 latent 表征 对图像 的变换 是等变的。
空间变换都有哪些类型呢？ 本文关注缩放和旋转：
最终的变换是缩放和旋转的组合： 。 然后均匀采样： $0.25<s_x, s_y<1,="" ~="" \theta="" \in\left(\frac{\pi}{2},="" \pi,="" \frac{3="" \pi}{2}\right)$="" 。下采样使用双三次插值。<="" p="">
为了测试 Autoencoder 对于空间变换是否具有等变性，作者对 latent 表征施加了缩放和旋转的变换 ，并测试重建效果。对比：
- ：对 latent 变换，再解码后的输出。
- ：对 image 变换，再编码解码后的输出。
如下图1和2所示为在缩放变换之后，用 SD－VAE 和 EQ－VAE 重建出来的图像的对比。缩放变换用在两处：对原始图像的缩放变换以及对 latent 表征的缩放变换。可以看到二者存在明显的差异：在对 latent 表征缩放变换之后，使用 SD－VAE 的重建质量很差，但是 EQ－VAE 可以维持重建效果。
图1：latent space 等变性。在缩放变换之后，用 SD-VAE 和 EQ-VAE 重建出来的图像的对比。缩放变换用在两处：对原始图像的缩放变换以及对 latent 表征的缩放变换。在对 latent 表征缩放变换之后，使用 SD-VAE 的重建质量很差，但是 EQ-VAE 可以维持重建效果
图2：latent space 等变性。在缩放变换之后，用 SD-VAE 和 EQ-VAE 重建出来的图像的对比。缩放变换用在两处：对原始图像的缩放变换以及对 latent 表征的缩放变换。在对 latent 表征缩放变换之后，使用 SD-VAE 的重建质量很差，但是 EQ-VAE 可以维持重建效果
图3：使用或者不使用 EQ-VAE 的 SD-VAE 和 SDXL-VAE 的重建结果对比。重建结果测量的是 1) 对 x 做空间变换以及 2) 对 latent 表征做空间变换再解码后的结果之间的 RFID。相比 baseline 而言，本文方法显著降低了 RFID，提升了在 latent 变换下的图像保真度
综合图 1-3 的结果，不难发现：
- 如果是对原始图像施加变换，即 的情况：Autoencoder 可以很好地重建原始图像。
- 如果是对 latent 表征施加变换，即 的情况：会导致重建质量显著下降。 关于这个现象的原因，作者认为是：
- Autoencoder，比如 SD－VAE 中常用的卷积架构，对于空间变换不满足等变性。
- Autoencoder 的训练目标，比如 KL 散度 + 重建损失，没有能够显式或者隐式地鼓励等变性。
因此，造成了 ，因此造成了 latent space 结构复杂化。
1.3 为 VAE 注入等变性：显式正则化
本文提出的 EQ-VAE，通过对 latent space 的规范，从而提升对于空间变换的等变性。EQ-VAE 实现的效果如图 4 所示，EQ-VAE 实现了更加平滑的表征，使得训练更加高效。
图4：SD-VAE 和 SDXL-VAE，在使用或者不使用 EQ-VAE 情况下得到的 latent space 的可视化，从视觉上直观表明本文的正则化可以在不影响重建质量的前提下得到更加平滑的 latent 表征
那么要如何为 VAE 引入等变性呢？
那么一种拍脑袋的做法是直接在训练 VAE 时，给上式 1 加一个等变性的 constraint loss：
式中， 采样自空间变换。
但是作者通过实验发现这种 Explicit Equivariance Regularization 的做法不太行，如图5所示。
图5：Implicit vs. Explicit Equivariance Regularization 结果。显式的正则化会带来 mode collapse 问题，本文提出隐式正则化，可以提升生成模型性能
原因是，优化上式 5 会得到＂trivial solution＂（退化解），优化这个 loss 时，模型可以轻松达到很低的损失，但这种＂解＂完全没有实际意义。比如，Encoder 可以退化成把 latent 表征一律输出为常值 。
1.4 隐式正则化
为了解决显式正则化的问题，本文提出了隐式正则化，从式 1 变为下式 6 。 对齐的是：
- 空间变换后的原始图像： 。
- 对 latent 做空间变换，再经过解码器输出的重建结果： 。
式中，当空间变换为恒等变换（Identity Transformation）时，式 6 就退化为了式 1 。 在实做中，为了维持住 Autoencoder 的采样能力，作者以 的概率采样 ，使得式 6 退化回式 1。
因此，最终训练目标可以写成：
式中， 从 均匀采样，默认设置 。
对于离散 Autoencoder 的情形，比如 VQ－GAN，编码嚣输出的连续特征 会被映射到最近的 codebook，通过量化形成离散的 latent space。应用本文方法很自然直接。应用的时候，把空间变换 作用到量化之前的 latent representation 中。
1.5 实验结果
Autoencoder：作者在 OpenImages 上微调全部的 Autoencoder，以 10 的 Batch Size 微调 5 个 epoch。
生成式模型：DiT，SiT，REPA，MashGIT，在 ImageNet 上训练。
首先，作者在连续的 SD-VAE，SD-VAE-16，SDXL-VAE 以及 SD3-VAE 上进行验证。为了评估正则化对于生成式模型的影响，在 latent code 上训练 DiT-B。
结果如下图 6 所示。可以观察到，使用了 EQ-VAE 之后：
- 所有 Autoencoder 的等变性误差 (Equivariance Errors) 都下降了。
- EQ-VAE 维持了重建性能 (RFID)。
- EQ-VAE 提升了生成性能 (GFID)。
这些结果表明 GFID 和 Equivariance Errors 之间存在相关性。
对于离散的 Autoencoder，作者在 VQ-GAN 上做了验证，然后图像生成模型使用 MaskGIT。结果如下图 6 所示。可以观察到，使用了 EQ-VAE 之后：等变性误差同样下降，生成性能也上升了。
图6：使用或者不使用 EQ-VAE 的 Autoencoders 的对比
其他几种生成式模型的结果如图 7 所示。本文方法对 DiT 和 SiT 的生成性能提升显著。比如 DiT-XL/2 在训练了 400K iterations 的时候，GFID 从 19.5 提升到 14.5。
而且，EQ-VAE 作用在生成模型训练的 Stage 1，与 REPA 刚好是互补的，使得收敛速度就更快了。比如使用 EQ-VAE 训练 1M iteration 就可以达到 5.9 的 GFID，不用的话则需要训练 4M iteration 才可以达到 5.9 的 GFID。
图7：ImageNet 256×256 GFID 上使用 SD-VAE-FT-EMA 或者 EQ-VAE 的生成模型的结果比较。不使用 CFG
对于离散 Autoencoder，生成模型 MaskGIT 的结果如图 8 所示。使用 EQ-VAE 训练的 MaskGIT 模型训练 130 epochs 就达到 6.80 的 GFID，训练到 300 epochs 可以达到 5.91 的 GFID。
图8：EQ-VAE 改善 MaskGIT 生成性能
与 SOTA 的对比如图 9 所示，相比于 REPA 使用 1/4 的训练 epochs (200 vs 800 epochs)，EQ-VAE 就已经可以实现相当的性能 (1.70 vs 1.42)。
图9：使用 CFG 的 ImageNet 256×256 对比结果
1.6 消融实验结果
要使用什么样的空间变换？
如下图 10 所示为空间变换消融实验结果。结论：鼓励缩放变换等变性可以大幅提升生成性能。混合缩放，旋转变换进一步提升性能，证明二者具有互补属性。
各向异性的缩放虽然更有利于生成性能，但是会损害重建性能。因此，默认使用旋转+各向同性的缩放。
图10：空间变换消融实验结果
EQ-VAE 要微调几步？
下图 11 的横轴代表使用 EQ-VAE 微调的 Epoch 数，纵轴代表使用微调后的 Autoencoder 给出的 latent 上训练的 DiT-B/2 的 GFID 性能。可以发现，微调仅 1 Epoch 就可以大幅提升 DiT 的生成性能。
图11：EQ-VAE 仅仅微调 1 Epoch 就可以提升生成式建模的性能
性能的提升并非增量训练的结果
这个实验个人觉得非常重要，也很有说服力。为了验证 EQ-VAE 所带来的性能的提升并非增量训练的结果，本文作者给了图 12 的结果。
图12：增量训练 vs 等变性正则化结果对比
SD-VAE† 是把 SD-VAE 使用式 1 去微调 5 Epochs 之后的 Autoencoder。
可以看到，额外的增量训练，对于生成性能 GFID 的影响可以忽略不计。
SD-VAE-EMA-FT 是 SD-VAE 的后续版本，在 LAION-Aesthetics 上进一步微调后的版本。其对于 GFID 的影响也很小。
但是，EQ-VAE 大幅改进了生成性能。
这个结果证明，EQ-VAE 对于生成性能的提升所带来的帮助并非增量训练所致。
....
#Generalization of Diffusion Models Arises with a Balanced Representation Space
密歇根大学新研究：能泛化的扩散模型，源于其学到了均衡的表征空间
最近，来自密歇根大学和佐治亚理工学院的研究团队发表了一篇引人深思的论文，直击当前AIGC领域的一个核心痛点：我们每天都在使用的扩散模型，究竟是在真正地“创作”，还是仅仅在“背诵”它见过的训练数据？
这篇论文提出了一个全新的视角，认为区分“记忆”与“泛化”的关键，不在于模型结构本身，而在于其内部形成的“表征空间”（Representation Space）是“尖峰状的”（spiky）还是“均衡的”（balanced）。
这一发现不仅为我们提供了一个优雅的理论框架来理解扩散模型的泛化之谜，还带来了两个立即可用的“大礼包”：一个高效的记忆样本检测器，以及一种无需训练的模型内容编辑方法。
- 论文标题: Generalization of Diffusion Models Arises with a Balanced Representation Space
- 机构: 密歇根大学；佐治亚理工学院
- 论文地址: https://arxiv.org/abs/2512.20963
- 代码仓库: 待发布
背景：记忆与泛化之谜
扩散模型，如Stable Diffusion，以其惊人的图像生成能力改变了内容创作的生态。然而，一个悬而未决的问题始终困扰着研究者和用户：这些模型生成的图像，有多少是真正新颖的创作，又有多少只是对训练集中现有图像的“像素级复制”或“高仿”？
理论上，扩散模型的训练目标（去噪分数匹配）存在一个简单的“最优解”，那就是完全记住所有训练样本，并在生成时原样输出。如果模型走了这条“捷径”，那么隐私泄露（复现训练集中的人脸、个人信息）和版权风险将不堪设想。
但在实践中，我们又确实看到了大量新颖、多样且高质量的生成结果。这种理论与实践的脱节，正是本文要解决的核心问题。作者们另辟蹊径，不再纠结于复杂的网络结构，而是深入模型的“内心世界”——表征空间，去一探究竟。
方法： “尖峰”与“均衡”的表征之争
为了在理论上把问题讲清楚，研究者首先从一个简化的双层ReLU去噪自编码器（DAE）入手。他们发现，模型的行为会根据训练数据和参数量的不同，分裂出两种截然不同的模式：
1. 记忆模式 (Memorization)
当模型参数量充足（过参数化），而可供学习的有效样本较少（例如，数据集中存在大量重复或高度相似的图像）时，模型会选择“偷懒”。它不再学习通用的视觉规律，而是将单个训练样本直接编码进网络权重里。
如下图（左）所示，当用少量孤立的图像训练模型时，其权重矩阵（W1）的每一列几乎就是一张训练图像的“复刻”。
这种“死记硬背”反映到表征空间上，就会形成所谓的“尖峰状”表征 (Spiky Representation) 。如下图所示，当一个被记住的样本输入模型时，只有极少数（甚至一个）神经元被激活，且激活值极高，仿佛一座陡峭的山峰。这说明模型仅仅是识别出了“哦，这是我背过的第N个样本”，然后就直接调用对应的权重来恢复图像，缺乏对内容深层次的理解。
2. 泛化模式 (Generalization)
相反，当训练数据足够丰富、多样，模型无法通过“背书”来降低损失时，它被迫学习更本质的东西——数据的局部统计特性（例如，某一类物体的平均特征和主要变化方向）。
如下图所示，当用海量图像训练时，权重矩阵不再是任何一张具体图像的复制，而是演变成了更抽象的、类似主成分分析（PCA）基底的特征。
这种模式下，模型生成的表征就是“均衡的” (Balanced Representation) 。如上图底部所示，一个泛化样本的表征会激活多个神经元，且能量分布相对均匀。这表明模型正在从不同维度（如轮廓、纹理、颜色）对输入进行组合式理解和编码，为生成新颖内容打下了基础。
更重要的是，研究者通过对Stable Diffusion和DiT等真实世界模型的雅可比矩阵进行分析，发现这一“尖峰vs均衡”的二元法则同样适用！这成功地将简化理论的洞察，推广到了我们日常使用的复杂AIGC模型中。
由于真实数据往往是不平衡的（有的样本多，有的样本极少），真实模型通常处于“混合状态”——即对常见数据进行泛化，而对罕见数据进行记忆。这也就很好的解释了为什么同一个模型既能创作又能“背书”(掌握"常见"套路，记住"罕见"难题)。
实验与应用：从理论到实践的两大“利器”
基于上述发现，论文展示了两个极具价值的实际应用。
应用一：高效的无提示词记忆检测
既然“记忆”会产生“尖峰表征”，那么我们是不是可以通过检测表征的“尖峰程度”来判断一个样本是否是记忆样本？
答案是肯定的。研究者提出了一个极其简单而有效的方法：计算中间层表征的标准差（Standard Deviation, STD）。一个向量的标准差越大，意味着其数值分布越不均匀，也就越“尖峰”。
这个方法（下表中Ours）的优势在于：
- 无需Prompt: 传统的检测方法通常需要知道生成这张图的提示词，而新方法直接分析图像本身，适用范围更广。
- 速度快: 只需一次前向传播和简单的数学计算，非常高效。
- 精度高: 如下表所示，该方法在LAION、ImageNet和CIFAR10三个数据集上的AUC指标分别达到了0.987、0.995和0.998，全面超越了以往的方法。
这一工具对于平台方审核AIGC内容、检测潜在的版权和隐私风险，具有重大的实用价值。
应用二：基于表征操控的图像编辑
既然“泛化”会产生“均衡且语义化”的表征，那么这个表征空间就应该像一个调色盘，可以通过简单的线性运算来操控。
研究者验证了这一点。他们首先计算出代表某种风格（如“油画风”）或概念（如“老人”）的平均表征向量，然后将其加到一张原始泛化图像的表征上。结果显示，图像内容会随着“操控强度”的增加而平滑、连续地发生变化。
有趣的是，这种编辑方法对“记忆样本”几乎无效。因为记忆样本的“尖峰”表征是刚性的，缺乏可供编辑的语义维度，稍微一“推”，结果就可能“崩坏”。这进一步佐证了论文的理论。
写在最后
这是一篇非常具有启发意义的论文，为我们理解AIGC模型行为的“黑箱”提供了一把优雅的钥匙。它告诉我们，一个好的生成模型，不仅仅要学会“画什么”，更要学会如何“理解世界”。模型内部是否构建起一个“均衡、语义化”的表征空间，直接决定了它是创作者还是复读机。
相关代码目前尚未开源，但计划在未来发布。
....
#Pixio
Meta FAIR推出Pixio: 追求视觉预训练中的像素空间监督
Meta 推出 Pixio：坚持纯像素监督，用更深解码器、更大的掩码粒度和多 class token 把 MAE 推向 5B，在单目深度、3D 重建、语义分割与机器人学习全面超越 DINOv3，代码已开源。
在这里介绍&讨论一下我们在视觉预训练/自监督/表征学习上的工作Pixio:
https://github.com/facebookresearch/pixio
我们release了5个不同尺寸的模型，包括Pixio-5B和4个蒸馏得到的Pixio-1B/H/L/B。
01 介绍
正如标题，我们希望只依赖像素空间监督来实现很强的视觉表征模型。
从方法和结果上来说：在MAE (Masked Autoencoder)的基础上，Pixio做了几点简单修改，即得到了在dense prediction（depth estimation, feed-forward 3D reconstruction, semantic segmentation）以及robot learning等任务上比DINOv3更好的模型。
个人认为，pre-training应该在足够informative, scalable的信号上以足够简单的framework (minimal human prior, minimal benchmark bias)去做。因此在介绍具体方法以及方法的motivation前，我们先阐明一下：1）为什么要用pixel supervision，2) 为什么要用MAE的masking机制。
02 为什么用pixel supervision
在visual pre-training中，pixel supervision相较于latent-space supervision（e.g., DINO, JEPA）有几点优势：
- 更丰富的信息量，因此有更多的东西可以push模型去学：从low-level的视觉属性（e.g., 颜色、纹理、材料、geometry），到middle-level的空间关系（e.g., 遮挡、深度、motion），再到high-level的概念（e.g., 类别、实体、事件）。
- pixel value是off-the-shelf的（是由人类以较低的代价大规模收集好的，和文本一样广泛存在于互联网上），以此作为supervision不容易遇到SSL里常见的collapse问题，训练较为稳定（当然，图像上依然需要配合masking/noise等distortion）。
相比之下，latent-space supervision往往由模型自身on-the-fly地产生，非常容易collapse，为了解决这种问题，需要设计了一些额外的机制，如EMA teacher, negative sample, sharpening and centering, stop gradient等。这些机制也往往带有非常多的超参需要调（如temperature、EMA ratio等），更重要的是，这些机制大多是人根据自己的经验、甚至为了hack某个数据集设计的，很容易成为一种human bias限制模型的upper bound。一个例子是广泛使用的local-global consistency，也就是一个local crop和global crop的feature需要足够接近，这种human prior很适合ImageNet这样的image-level classification任务，但却会限制模型在spatial维度上去学足够discriminative的feature（个人认为DINOv3的dense feature随着训练会变差也是因为强加了这个约束）。
03 为什么用masking
在pixel supervision下，一个最简单直接的方式是用autoencoding去学representation，然而这样很难学好，因为pre-training task太简单。因此我们选择了MAE中的masking方案，对于input patches，先随机丢掉一些，然后再让模型recover回来。时至今日，我依然觉得MAE里关于masking的设计和它对pixel supervision的追求一样精妙，具体来说：
- 不同于ViT, BEiT里的masking，MAE没有在encoder的输入上使用[MASK] token替代正常的patch token，而是直接移除了这些token。除了经常说的这有助于提升训练efficiency外，这也极大的缓解了train-test的distribution gap（测试图像是没有特殊的[MASK] token的）。
- 类似的逻辑，直观上看：直接移除token也比加noise (如DAE)的做法更好地保持了真实图像的distribution。
通过对输入图像masking，然后要求模型predict被mask的区域，可以让模型学得很多视觉能力，如下图所示：
通过masking以及让模型predict masked pixels，模型必须理解很多视觉&物理属性，也需要学得很多correlation
（当然，masking也有它的问题，最后limitation & future work会聊到）
04 Pixio对MAE的小改进
聊完为什么坚持pixel supervision和为什么用masking后，再介绍一下我们对MAE的几点改进，都是很简单的modification，甚至有些都在以往工作里出现过。个人觉得这些不是很重要，重要的是pixel supervision以及方法的motivation，以及我们发现这样一些很简单的做法能够得到与很复杂的DINOv3 comparable甚至更好的结果。
总的来说，Pixio对MAE的pre-training framework做了三点改进，并更换了pre-training data，对比如下：
Pixio用了比MAE更深的decoder、更大的masking粒度、更多的class tokens，以及在web-scale data上训练
4.1 更深的decoder
Motivation: 我们在probe MAE block-wise feature时，发现对诸多任务它最好的feature都不在最后一个encoder block，如下图所示。以MAE-H/14的32-block encoder为例，对于depth estimation, semantic segmentation, classification这些任务，最好的feature差不多在第20个block。因此我们猜想，是MAE用的8-block decoder (512-dim)的capacity不够。由于decoder的capacity不够，模型又被enforce去学pixel reconstruction这么难的objective，因此encoder的最后一些blocks不得已被用作了decoding，损失了其本身被期待的作为encoding的功能。
MAE-H/14和MAE-L/16不同block的feature的performance
Solution: 既然decoder capacity不够，那就增加decoder blocks。在保持dimension仍为512的情况下，我们从8 blocks增加到了16或32 blocks后，encoder的frozen probing performance有了明显提升（对5B的encoder来说，32-block decoder的参数量仍只占总参数量的2%）：
不同decoder depth和width下probing frozen encoder的结果
4.2 更大的marking粒度
Motivation: MAE是以1x1 patch的粒度来做masking（如下图所示），在这个粒度下由于图像的冗余性，会存在很严重的ground truth leakage问题，被mask的patch哪怕从最相近的visible patch照抄像素值，也能实现还不错的reconstruction，而模型就丢失了modeling long-range dependancy的能力；此外，太细碎的visible patches也不利于模型学习一个比较完整的local context。
MAE 1x1 patch的masking粒度
Solution: 增大masking粒度，以2x2 patches或4x4 patches为粒度来做masking（如下图所示），缓解ground truth leakage，以及提供模型一个更大的local context去充分学习。
Pixio 4x4 patches的masking粒度
结果上，无论是2x2还是4x4 patches，均明显优于1x1 patch的masking粒度：
不同masking粒度下的encoder性能
4.3 更多的class tokens
Motivation: MAE append了一个dummy token在patch token sequence上，这个dummy token没有被任何loss直接监督，但可以作为class token用在image-level classification任务上并得到不错的结果（明显好于pooled patch tokens）。因此，我们认为这个token在implicitly model global information，沿着这个思路，单个token可能不够捕捉各种各样的全局信息（如场景类别、图片风格、相机姿态）。
Solution: 我们append多个class tokens供模型maintain多种global information。在下游场景中如果需要一个global representation，我们可以平均或concatenate这些class tokens。我们发现这个改进可以显著提升模型在global任务上的性能（如ImageNet classification），而对于dense任务则没有显著影响：
不同数量的class tokens下的encoder性能
4.4 Web-scale的预训练数据 & 尽可能少benchmark bias的data curation
MAE是在ImageNet-1K上训练的，这个数据集的狭窄分布显然不能让模型学得足够transferable representation。因此，我们用了MetaCLIP的20亿张web-crawled图像，这个数据规模接近于DINOv3的预训练数据。
然而，DINOv2/v3用了非常“精细”的data curation策略，这些策略平衡了原始数据的分布，但同时也在hack一些benchmarks，比如：1）DINOv3在采样的training batch中，保证ImageNet-1K的图像占10%（远大于IN-1K数据的实际比例），2）DINOv2/v3将100多万张Mapillary images直接加入训练中以缓解web-crawled data中驾驶数据的缺乏，3）DINOv2以benchmark images作为query来构建相似的pre-training set，等。
我们希望以尽可能不hack benchmark的方式得到足够general的vision model，以应对未来不确定的场景需求。所以我们在原始web-crawled数据的基础上，加了一个足够简单的采样策略，每个图像的采样概率由它的reconstruction loss来决定，loss越大，说明这张图像越难，则会有更大的概率被采样到。这种方式可以有效平衡互联网图像中商品图像（大片的白背景、单个object在中心）的主导分布。但同时，原始pool也有很多text-heavy图像（如文档的截图），这些图像的loss往往也比较大，但我们不希望模型花费太多的capacity去学这样的分布。因此，我们额外加了一个约束，我们计算每张图像的色彩直方图的entropy，我们设定一个阈值，只有entropy超过这个阈值，该图像才会被采样。直观上，文档的色彩比较单调（比如黑白图），因此色彩直方图的entropy比较小，很容易被过滤掉。
05 最终结果
我们主要在monocular depth estimation, feed-forward 3D reconstruction, semantic segmentation, robot learning等下游任务上验证了Pixio的性能。
5.1 Monocular depth estimation
Monocular depth estimation
5.2 Feed-forward 3D reconstruction
Feed-forward 3D reconstruction
5.3 Semantic segmentation
Semantic segmentation
5.4 Robot learning
Robot learning
06 Failure attempts
尽管上述的算法层面的三点改进很有效，但我们也有很多失败的探索，包括但不限于: hybrid masking ratios, hybrid masking granularity, Koleo loss on class tokens, multi-stage feature fusion for decoder等。
我们在paper的appendix中给了详细的介绍，希望能对未来的工作有一点作用，当然，时间、资源有限，一些我们发现没有很work的点也可能是我们探索的还不够深入。
07 Limitation & future work
这个工作主要想倡导的是pixel supervision，也就是MAE的“AE (autoencoding)”这部分。虽然不可避免地使用了"masking"的策略，但我认为"静态图像上的spatial masking"存在诸多limitations，很难是visual pre-training的最终归宿（尽管这是现在几乎所有的vision SSL的默认做法）。
一个最显著的limitation是，正如color augmentation (SimCLR, MoCo), gaussian noise, cropping等artificial distortion一样，masking也是一种人造的distortion，真实分布下并不存在。此外，我们很难找到一个对每个image最优的masked/visible划分来让模型学习，模型总是在一个不真实的分布上进行学习，学得的知识也是不完整的。
相比之下，temporal上的pixel supervision可能会是更自然的solution。本质上来看，静态图像并不是视觉信息在物理世界存在的形式，人类也并不是从一个个的snapshot中去学习的。相反，人类从连续的、时间的变化中观察这个世界怎么演变的。个人认为，有了时间维度后，spatial masking才可能会被拿掉。然而，现有的video pre-training工作大多集中在很短的视频上，与文本的sequence相比，图像、短视频上包含的causality要少很多很多（不够难、事件/关系不够丰富），很难激发vision model的intelligence。因此我们可能需要更多关注web-scale的long video作为pre-training data的优势。
关于更多的讨论，请参考我们的paper appendix。
....
#FREE-Merging
哈工大重磅提出 FREE-Merging：傅里叶变换破解模型融合难题，CVNLP 多模态全场景 SOTA
哈工大提出FREE-Merging：用傅里叶高通滤波剔除任务向量低频冲突，再以轻量级 1% 专家模块补回关键信息，零额外训练在视觉、语言、多模态八任务全面领先，代码已开源。
你是否遇到过这样的困境：训练了多个优秀的单任务模型，却因为存储和推理成本太高，无法同时把它们的能力整合起来？今天要给大家介绍的ICCV 2025最新研究——FREE-Merging，可能会彻底改变你对模型融合的认知！
论文信息
- 题目：FREE-Merging: Fourier Transform for Efficient Model Merging 基于傅里叶变换实现高效模型融合的FREE-Merging方法
- 作者：Shenghe Zheng、Hongzhi Wang
- 源码：https://github.com/Zhengsh123/FREE-Merging
01 模型融合的老大难：任务干扰
在深度学习领域，我们早已习惯了"预训练-微调"的工作流。但实际应用中，单一模型很难满足多样化需求。比如一个视觉模型可能擅长分类，另一个擅长分割，要是能把它们合二为一该多好！
可惜事情没那么简单。当我们尝试融合多个模型时，总会遇到"任务干扰"的问题——不同任务的参数打架，导致融合后的模型性能还不如单个模型。 existing方法要么效果差，要么需要额外的大量计算和存储，简直是两难！
02 颠覆性发现：干扰藏在频域里
这篇论文的作者发现了一个关键现象：任务干扰在模型参数的频域中表现得特别明显！就像我们看图片时，低频信息是轮廓，高频信息是细节，模型参数也能做类似的傅里叶变换。
频域干扰可视化
左边的图清晰展示了不同任务的模型参数在频域的分布——中心的低频区域差异特别大，这就是干扰的重灾区！右边的实验更证明了：频域差异越大，融合性能越差，两者呈显著负相关。
更重要的是，现有方法都在"空间域"折腾，根本解决不了频域的干扰问题。这就是为什么模型融合一直进展缓慢！
03 FREE-Merging框架：傅里叶+专家模块双剑合璧
针对这个痛点，作者提出了FREE-Merging框架，整体结构如下：
FREE-Merging框架图
这个框架分两步走，既解决了频域干扰，又弥补了信息损失，堪称完美！
第一步：FR-Merging去除低频干扰
既然低频区域是干扰重灾区，那不如直接用高通滤波把它们滤掉！这就是FR-Merging的核心思路：
- 把每个模型的参数（其实是微调前后的差异，叫"任务向量"）做傅里叶变换，转到频域
- 用高通滤波器过滤掉低频部分（保留高频细节，去掉冲突的全局信息）
- 再转回到空间域，合并得到一个干净的主干网络
高通滤波效果
实验证明这招太灵了！过滤低频后，虽然单个任务性能略有下降（对角线上的点），但模型间的兼容性大大提升（非对角线点上升更多），融合起来效果自然更好。
第二步：轻量级专家模块补全信息
当然，完全丢掉低频信息也不行，里面毕竟有一些任务特有的关键知识。作者设计了一个巧妙的解决方案：只保留1%的关键参数作为"专家模块"。
这些专家参数怎么来的？就是从被过滤掉的低频信息里挑出来的最关键部分，再经过特殊的缩放处理。推理的时候，用一个简单的路由器判断当前任务需要哪个专家，动态加载上去就行。这种设计太贴心了：
- 只占1%的额外存储（比同类方法的2-3%好太多）
- 推理时几乎不增加计算量
- 专家模块针对性补全信息，性能不降反升
04 效果炸裂：跨领域全面领先
说了这么多，效果到底怎么样？作者在视觉、语言、多模态三大领域做了全面测试，结果惊艳！
在8个视觉任务的融合实验中：
- FR-Merging比现有无成本方法平均高2.5%
- FREE-Merging加了专家模块后，比需要额外训练的方法还高2%
视觉任务融合结果
在语言模型上更厉害，融合LLaMa2-13B这样的大模型时，FR-Merging甚至超过了需要额外数据训练的方法！
大语言模型融合结果
多模态任务（图像+文本）的融合结果同样领先，证明这种方法的通用性超强。
05 为什么这么牛？从损失景观看原理
作者还从优化角度解释了为什么这招管用。通过可视化损失函数的"地形"发现：
损失景观对比
经过FR-Merging处理后，损失函数的"山谷"变得更宽了。这意味着融合后的模型更容易找到一个对所有任务都合适的参数点，泛化能力自然更强！
06 消融实验：每个组件都不可或缺
为了证明方法的有效性，作者做了详细的消融实验：
消融实验结果
- 去掉FR-Merging，性能直接掉3%
- 不用作者的专家提取方法，就算用同样参数量，效果也差很多
- 低通滤波会让性能暴跌（再次证明低频是干扰源）
甚至把FR-Merging和其他方法结合，都能让那些方法的性能提升，足见其普适性！
07 总结：融合技术的新标杆
FREE-Merging的优势简直太突出了：
- 首次揭示频域干扰问题，直击模型融合痛点
- 傅里叶滤波+轻量专家的组合，在性能和成本间找到完美平衡
- 跨领域通用，视觉、语言、多模态都能用
- 存储成本低（仅增加1%参数），推理速度几乎不受影响
如果你经常需要处理多个模型的融合，或者想在有限资源下部署多任务模型，那一定要关注这个方法。作者已经开源了代码，快去试试吧！
不得不说，把信号处理里的傅里叶变换用到深度学习模型融合上，这个思路太巧妙了。也许未来会有更多信号处理的经典方法，在AI领域焕发新的生机呢？
....
#MAGIC
南大等提出MAGIC：模型合并新视角，校准特征幅度，CV任务提升4.3%，Llama性能飙升8.0%！
在今天这个大模型百花齐放的时代，我们拥有了越来越多在特定任务上表现卓越的“专家模型”。一个自然而然的想法是：能否将这些“专家”的能力融合成一个“通才”模型，而又无需高昂的重新训练成本？这就是“模型合并”（Model Merging）技术要解决的问题。
最近，来自南京大学、上海交通大学、东南大学的研究者们，共同为我们带来了一项名为 MAGIC (MAGnItude Calibration) 的新技术。它像一个即插即用的魔法棒，通过校准模型特征的“幅度”，显著提升了模型合并后的性能，而且几乎不增加任何训练负担。
这项工作非常直观地指出了现有模型合并技术的一个盲区：大家都在努力对齐特征的“方向”，却忽略了“幅度”同样关键。MAGIC 通过简单有效的校准，在多个CV数据集上带来了平均 4.3% 的性能提升，在Llama-2-7B模型上更是实现了 8.0% 的惊人增长。
- 论文标题: MAGIC: Achieving Superior Model Merging via Magnitude Calibration
- 研究机构: 南京大学，上海交通大学，东南大学
- 论文地址: https://arxiv.org/abs/2512.19320
- 代码仓库: https://github.com/lyymuwu/MAGIC
模型合并的“小问题”：被忽略的特征幅度
模型合并，顾名思义，就是将多个已经训练好的模型参数整合到一个新模型中。一个经典的方法是“任务算术”（Task Arithmetic），它通过计算“任务向量”（微调后模型与预训练模型的参数差异）并将其相加，来实现模型能力的融合。
然而，研究者们发现，这个看似简单的合并过程，却隐藏着一个不易察觉的问题。模型特征包含两个关键要素：方向（direction）和幅度（magnitude）。以往的工作，如TIES-Merging、AdaMerging等，都聚焦于如何更好地对齐特征“方向”，以减少不同模型间的“能力冲突”。但它们普遍忽略了，合并操作（如参数融合、稀疏化）会对特征“幅度”产生显著的扰动。
如下图所示，无论是参数剪枝（TRIM）、算术平均（Arithmetic）还是不相交合并（Disjoint），这些操作都会改变权重和特征的幅度。这种幅度的偏离，使得合并后的模型无法完美复现原始专家模型的行为，最终导致性能下降。
论文进一步从理论上分析了导致幅度偏差的两个核心原因：
- 幅度改变操作：参数的融合或稀疏化会直接改变任务向量的范数，根据三角不等式 ，简单的向量平均几乎必然会导致幅度的减小。
- 权重解耦特性：论文发现，一个任务向量能否在推理时发挥作用，不仅取决于其自身的大小，还取决于它和输入数据的“对齐”程度。合并模型时引入的其他任务向量，会干扰当前任务的对齐，从而削弱有效特征的幅度。
MAGIC：简单而强大的“幅度校准”魔法
既然找到了问题的根源，解决方案也就清晰了：把偏离的幅度“校准”回来！这就是MAGIC框架的核心思想。
论文首先通过实验发现了一个重要特性：不同层对幅度缩放的敏感度是不同的。如下图所示，某些层（被称为“幅度敏感层”）对幅度的变化特别敏感，随意放大这些层的幅度可能会导致性能急剧下降。因此，一个全局统一的缩放系数是行不通的，必须进行逐层校准。
基于此，MAGIC提出了一个统一的校准公式 ，其中 是为第 层计算出的校准系数。并根据应用空间的不同，设计了三种变体：
1. 特征空间校准 (Feature Space Calibration, FSC)
FSC是最直观的方法。它的目标是让合并后模型的“任务特征”幅度，与原始专家模型的“任务特征”平均幅度相匹配。校准系数的计算非常简单：
其中 是专家模型的任务特征， 是合并模型的任务特征。值得一提的是，这个过程仅仅需要每个任务一个无标签样本来估计特征幅度，成本极低。
2. 权重空间校准 (Weight Space Calibration, WSC)
WSC的核心思想非常巧妙。它将不同任务的任务向量视为一个高维空间中的坐标轴，这些轴共同定义了一个“超椭球”。WSC的目标就是通过缩放，将合并后的任务向量“拉回”到这个超椭球表面上，从而在权重层面完成幅度的约束。这个过程完全基于模型的参数进行计算，实现了零数据依赖的校准。
3. 对偶空间校准 (Dual Space Calibration, DSC)
DSC则是将WSC和FSC的优势结合起来。它先在权重空间进行初步的WSC校准，然后利用少量无标签数据，在特征空间进行更精细的FSC校准。这种“双重校准”通常能达到最佳效果。
实验效果：全面超越SOTA
MAGIC作为一个即插即用的后处理模块，可以轻松地与现有的各种模型合并方法（如TA, TIES, Iso-C等）结合，并带来一致的性能提升。
CV任务表现
在8个图像分类数据集上，研究者们将MAGIC与多种SOTA合并方法结合。如下表所示，结合了DSC的Iso-CTS方法，在ViT-B/32骨干网络上实现了 85.6% 的平均准确率，相比原始方法提升了 4.3%，全面超越了所有基线。
同时，无论是单独使用WSC还是FSC，都能带来显著的性能增益，这也证明了两种校准策略的有效性。
NLP任务表现
在NLP任务上，MAGIC同样表现出色。特别是在大型语言模型Llama-2-7B上，TA（任务算术）方法在合并后平均性能只有43.2%，而结合了WSC的TA方法，性能直接飙升到 51.2%，实现了 +8.0% 的巨大飞跃！
此外，在BERT和T0等模型的合并任务上，MAGIC也稳定地提升了各项基线方法的性能。
扩散模型也能用！
MAGIC的适用性不止于分类任务。研究者还展示了它在Stable Diffusion模型上的应用。通过合并不同主题（如“西方龙”）和不同风格（如“像素风”）的LoRA模型，MAGIC (WSC)能够生成风格更稳定、融合效果更好的图像，解决了普通权重平均可能导致的“风格漂移”问题。
一点思考
MAGIC的提出，为模型合并领域提供了一个全新的、简单却极为有效的视角。它告诉我们，在追求复杂的对齐算法时，有时回归到最基本的物理量——“方向”与“幅度”，可能会发现被忽略的金矿。
值得一提的是，作者已经开源了代码，对于所有正在探索模型合并、多任务学习或者试图融合不同LoRA能力的开发者来说，MAGIC无疑是一个值得立刻尝试的利器。
....
#iREPA
iREPA颠覆REPA“常识”：不到4行代码提速30%，空间结构才是生成关键
iREPA用不到4行代码把REPA的MLP换成卷积并加空间归一化，强化空间结构传递，SiT-B/2收敛提速30%，多编码器一致降FID，首次证明空间自相似度而非 ImageNet 精度决定生成质量。
本文是 REPA 的改进工作，称为 iREPA。
本文是对著名的生成模型 Representation Alignment (REPA) 方法的继续探索与改进。REPA 的主要思想是：在训练生成式扩散模型 (比如 DiT) 时，外接一个视觉 Foundation Model (比如 DINO)，用 DINO 的特征来蒸馏 DiT 的特征。这样来达到辅助 DiT 训练的效果。
本文研究了 REPA 的一个基础问题：什么样的表征适合生成？全局语义信息 (ImageNet-1K 精度)？还是空间结构信息 (patch tokens 直接的成对余弦相似度)？之前的结论是全局语义信息作为 REPA 的目标表征，对于生成更重要。
作者在本文中进行了大规模实验验证。结论：空间结构信息作为 REPA 的目标表征，对性能帮助更大。
本文通过大量详实的实验，涉及了多个视觉 Encoder (WebSSL，DINOv3，perceptual encoders，C-RADIO)，得到了 3 个结论：
- ImageNet-1K Linear Probing 精度高，不意味着这个表征利好生成。
- 决定生成性能的，是空间结构信息，而非全局语义信息。
- 刻意增强空间特征的传递，有助于提升模型的收敛速度。
本文引入两点改进 (仅需不到 4 行代码实现)，来帮助迁移空间结构信息：
- 把 REPA 的 MLP 投影层改为卷积层。
- 为外接的表征引入空间归一化层。
iREPA 在一众方法，比如 REPA, REPA-E, Meanflow, JiT 等等上得到验证。同时，iREPA 也在不同视觉编码器，不同尺寸模型上做了验证。
下面是对本文的详细介绍。
iREPA：REPA 中究竟什么更重要？全局信息，还是空间结构？
- 论文名称：What matters for Representation Alignment: Global Information or Spatial Structure?
- 论文地址：https://arxiv.org/pdf/2512.10794
- 项目主页：https://end2end-diffusion.github.io/irepa/
01 iREPA 论文解读：
1.1 决定 REPA 的因素是什么：全局语义信息，还是空间结构？
Representation Alignment (REPA) 是辅助训练生成模型的一种方法，其核心思想是把扩散模型中间表征，与外接自监督训练的视觉编码器对齐。REPA 可以加速收敛，提升最终的生成性能。
REPA 所引入的自监督学习的模型的 Representation，究竟是如何帮助 Diffusion Model 训练的？
这个问题的答案，其实是模糊的。
原因是不知道 REPA 对于性能的提升是来自：
- 更好的全局语义信息：linear probing 性能。
- 更好的空间结构信息：即 patch token 表征的关系。
知道这个有什么好处？
答：方便我们选择要对齐的目标 representation，使得 REPA 带来的帮助最大化。
有一个传统观点认为：REPA 中，视觉 Encoder 的 ImageNet-1K 精度很重要，ImageNet-1K 精度代表对全局语义的理解能力。那么 ImageNet-1K 精度越高，REPA 训练得到的生成模型的性能应该越好吧。因此，REPA 的作者在训练 Diffusion Model 的时候，会去测 Diffusion Model 的 feature 的 Linear Probing 精度（比如REPA论文：https://arxiv.org/pdf/2410.06940），并作为 REPA 有作用的依据。
这些做法其实都在暗示和强调一个观点，那就是全局语义信息，才是生成模型性能提升的关键。
REPA 的论文里面有一句话表达了下面的观点：
当我们训练 Diffusion Model，给它外接一个语义丰富 (更好的 Linear Probing 精度) 的视觉 Encoder 的时候，Diffusion Model 可以收获：
- 更好的语义能力 (更好的 Linear Probing 精度)
- 更好的生成能力 (更好的 FID 指标)
在本文中，作者挑战了之前关于 REPA 的观点，即：决定 REPA 的因素是什么：全局语义信息，还是空间结构？
1.2 全局信息没那么重要
发现 1：表征具有更好的全局信息 (比如 ImageNet-1K 精度)，并不意味着更有利于生成。
关于这里，作者给出了几个例子：
例1：最近的视觉编码器。
PE-Spatial-B (80M) 是由 PE-Core-G (1.88B) 微调得到的模型。尽管 PE-Core-G 有更高的 ImageNet-1K 精度 (82.8% vs 53.1%)，但是作为 REPA 的 target 表征却表现更差 (FID 32.3 vs 21.0)。
WebSSL-1B (1.2B) 有更高的 ImageNet-1K 精度 (76.0% vs 53.1%)，但是作为 REPA 的 target 表征却表现更差 (FID 26.1 vs 21.0)。
图1：空间结构对于 REPA 更重要。作者发现相比于全局语义 (以 ImageNet-1K 精度反映)，空间结构可以更好地反映生成能力。实验设置：SiT-XL/2 + REPA，训练 100K
例2：SAM2 超过了很多 ImageNet-1K 精度很高的视觉编码器。
SAM2-S vision encoder (46M) 是个很小的模型，ImageNet-1K 精度仅有 24.1%，但是却比 ImageNet-1K 精度 82.8% 的 PE-Core-G，用于 REPA 后取得了更好的 FID 指标。
图2：ImageNet-1K 精度仅有 24.1% 的 SAM2-S，相比其他精度高得多的模型，用在 REPA 里面带来了更好的生成性能
例3：同一个模型家族，更大尺寸的模型有时生成性能相当甚至更差。
一个常见观点是：同一个模型家族，更大尺寸的模型往往有更高的 ImageNet-1K 精度。但是作者观察到更大的模型的生成性能相当 (DINOv2) 甚至更差 (PE, Cradio)，如下图 3 所示。
图3：同一个模型家族，更大尺寸的模型可以带来更高的 ImageNet-1K 精度，但是生成性能更差
例4：添加更多全局信息反倒损害生成。
在这个例子中，作者手动注入了一些全局语义信息，来测试其是否真正利好 REPA 生成。那么注入的方法是把 CLS token 注入到 patch token：
式中， 代表 patch token， 代表 CLS token， 代表混合强度。
视觉 Encoder 使用 DINO v2。
结果如下图 4 所示，随着注入 CLS token 含量的增多，ImageNet－ 1 K 精度从 增加到 。但是生成质量下降极其严重，FID 指标从 的 19.2 下降到 的 25．4。
图4：通过 CLS token 为 patch tokens 添加全局信息，可以提升全局性能，但是会损害生成
上述 4 个例子表明，全局语义信息并不能够很好地指示 REPA 的性能。
1.3 空间结构才重要
作者假设说空间结构，而非全局信息，才是决定你这个 target representation 适不适合 REPA 的根本性因素。
作者考虑了下面几种评价空间结构相似性的指标：
定义 Self-similarity：
假设视觉 Encoder 提取的 patch 表征为 ，其中 patch 数量为 。定义 cosine kernel： 。
定义这样一个指标 spatial self－similarity metric （空间自相似性指标）。作者将其称为 spatial self－similarity score（LDS）。反映：距离相近的 patch 的余弦相似度－距离较远的 patch 的余弦相似度。
式中， 。
发现 2：空间结构与生成性能的相关性远高于 Linear Probing。
例5：空间结构与生成性能的相关性远高于 Linear Probing。
如下图 5 所示，Linear Probing 与生成性能（gFID）的相关性很弱（ ）。但是，所有的空间结构指标与生成性能（gFID）的相关性很强（ ）。
图5：空间结构与生成质量的相关性高于 Linear Probing
例6：模型缩放泛化能力很好。
如下图 6 所示，作者在不同模型尺寸 (SiT-B, SiT-L, SiT-XL) 验证了相关性。Linear Probing 与生成性能 (gFID) 的相关性很弱。空间结构指标与生成性能 (gFID) 的相关性很强。
图6：不同模型尺寸的相关性分析结果
然后，针对例1-例4，作者继续使用空间结构来解释实验现象。
例1：最近的视觉编码器。
如图 1 所示，PE-Core-G 相比 PE-Spatial-B，尽管有更好的 ImageNet-1K 精度，但是作为 REPA 的 target representation 的性能更差。
PE-Spatial-B 尽管在 global validation 精度上不如 PE-Core-G，但是空间结构更好，那么观察到的生成性能也更好。
例2：SAM2 超过了很多 ImageNet-1K 精度很高的视觉编码器。
例2中提到，SAM2 的 ImageNet-1K 精度很低，但是却比 ImageNet-1K 精度 82.8% 的 PE-Core-G，用于 REPA 后取得了更好的 FID 指标。如下图 7 所示，这个提升可以用 SAM2 的空间结构更好来解释。
图7：SAM2 有更好的 LDS，空间结构更好，解释了其用于 REPA 生成的性能更好
例3：同一个模型家族，更大尺寸的模型有时生成性能相当甚至更差。
从图 3 中我们能够看到，同一个模型家族，更大尺寸的模型有更高的 ImageNet-1K 精度。
但是，如下图 8 所示，同一个模型家族，更大尺寸的模型的 LDS 更差，用于 REPA 方法带来的生成性能也更差。
图8：同一个模型家族，更大的模型，LDS 越来越大，用于 REPA 生成的性能越来越好
例4：添加更多全局信息反倒损害生成。
从图 4 中，我们观察到，通过 CLS token 为 patch tokens 添加全局信息，可以提升全局性能。
但是，如图 9 所示，混合 CLS token 之后会降低 patch token 相互之间的空间差异。这会使得 patch tokens 与不相关的 token 之间具有很高的相似性 (比如前景和背景 tokens)。空间结构会降低，因此损害生成性能。
图9：添加全局信息越来越多，LDS 越来越低，用于 REPA 的生成性能越来越差
1.4 其他有趣的结论
1) 如果空间结构更重要，我们能不能在 REPA 中使用 SIFT 或者 HOG 特征？
答案是可以的。如下图 10 所示，作者发现尽管性能并非最佳，但是 REPA 方法使用经典的空间特征比如 SIFT，HOG 和中间 VGG 特征，都会带来性能提升。
这现象证明：REPA 可以受益于空间特征而无需额外的全局信息。
图10：REPA 使用不同特征的结果
2) 可以用空间结构的指标来解释 REPA 带来的性能提升吗？
答案是可以的。如下图 11 所示，使用 REPA 和 iREPA 之后，引入的空间结构指标 LDS 都有所提升。
图11：空间结构指标的结果
1.5 iREPA：重视 REPA 里面真正重要的东西
iREPA 给 REPA 做了两点改进，来增强从教师 (Visual Encoder) 向学生 (Diffusion Transformer) 的空间特征的传递。
改进一：投影层从 MLP 换成卷积的。
REPA 原来使用 3-layer MLP 作为投影层。现在改成一个轻量级卷积层 (kernel size 3, padding 1)。卷积结构通过其归纳偏置自然地保留了局部空间关系。
改进二：加一个空间归一化。
作者发现 patch tokens 是有包含很多全局语义信息的。那么这些全局信息会削弱 patch tokens 之间的空间差异，这会导致那些本不应该有联系 (比如前景和背景) 的 tokens 也呈现出很高的相似性。
有了之前的经验，现在我们知道可以把这部分全局信息给去掉，来提升 patch tokens 之间的空间差异。空间差异 (patch tokens 之间的成对的相似度) 增加了，按照之前的经验，就应该能获得更好的 REPA 性能。
做法是：对 target representation (也就是 Encoder 特征) 的 patch tokens，加一个归一化操作：
式中， 代表 patch tokens。归一化是在 spatial 维度（ 这个维度）进行的。
iREPA 两处改进的伪代码：
# 1. Conv projection instead of MLP
proj_layer = nn.Conv2d(D_in, D_out, kernel_size=3, padding=1)
# 2. Spatial normalization on encoder features [B, T, D]
x = x - gamma * x.mean(dim=1, keepdim=True)
x = x / (x.std(dim=1, keepdim=True) + 1e-6)1.6 实验结果
收敛速度
iREPA 相比于 REPA，对于不同的 target representation 以及模型尺寸，都提升了收敛速度。
图12：强调空间结构可以提升收敛速度
REPA 的 target representation
如下图 13 所示，对于所有的视觉 Encoder，iREPA 都可以帮助提升 REPA 的生成质量。
图13：不同 target representation 的实验结果
Encoder 尺寸
如图 14 所示，对于不同的 Encoder 尺寸，PE-B (90M), PE-L (320M), PE-G (1.88B)，iREPA 都帮助提升了生成性能。而且，随着 Encoder 尺寸的增加，提升的百分比也增加。
图14：Encoder 尺寸消融实验
扩散模型缩放性
如图 15 所示，iREPA 一般而言，在不同的扩散模型尺寸，都帮助提升性能。有个别数据例外，但不影响总体结论。
!图15：扩散模型缩放性消融实验
Encoder 对齐深度
如图 16 所示是不同 Encoder 对齐深度的实验结果。target representation 是来自 DINOv3-B，然后扩散模型是 SiT-B/2，训练长度是 100K iteration。可以看到对于不同的对齐深度，iREPA 都可以观察到一致的性能提升。
图16：针对 Encoder 对齐深度的消融实验
iREPA 的两点改进的消融实验
如图 17 所示，空间归一化，卷积层，都可以提升生成性能，两个都用上效果最好。
图17：iREPA 的两点改进的消融实验
不同方法 (REPA-E, MeanFlow w/ REPA) 的实验
如图 18 所示是 REPA-E 和 MeanFlow+REPA 的实验结果。iREPA 所带来的空间结构，在这两种方法上都会带来性能提升。
图18：REPA-E 以及 MeanFlow+REPA 实验结果
Classifier-free guidance
如图 19 所示，对于不同 Encoder，使用或者不使用 CFG 的情况下，iREPA 都带来更快的收敛。
图19：不同 Encoder 以及使用或者不使用 CFG 的实验结果
JiT 实验结果
JiT 是一种在 pixel space 进行 diffusion 的方法。如下图 20 所示是 pixel-space diffusion (JiT) 的实验结果。可以看到，对于不同的视觉 Encoder，比如 DINOv2, DINOv3, PE，iREPA 对比 REPA Baseline 实现了更快速的收敛。
图20：pixel-space diffusion (JiT) 的实验结果
....
#tuning_playbook
谷歌大脑深度学习调参（炼丹）指南出炉，Hinton点赞，一天收获1500星
论文地址：https://arxiv.org/pdf/2201.04620v1.pdf
大量的实践经验已被提炼成这份强大的深度学习模型调参指南。」——Geoffrey Hinton。
众所周知，AI 的超参数决定着模型学习效果和速度。相比普通机器学习任务，深度学习需要的训练时间较长，因此调参技巧就显得尤为重要。
但鉴于深度学习「炼丹」的特性，不同的模型需要不同的超参数，而每个超参的意义又不同，在不同实验中，参数和调整的方向又都不一样。调参这件事一直以来没有固定的套路，每个人都有自己的经验，因此经常会出现一些似是而非的理论，比如：
- Random seed = 0 得到坏的结果
- Random seed = 42 得到好的结果
为了破除「迷信」，高举科学旗帜，近日来自谷歌大脑、哈佛大学的研究人员发布了《Deep Learning Tuning Playbook》，旨在帮助大家解决这一 AI 领域的老大难问题。
项目 GitHub 上线仅一天就已收获了上千 Star 量：
项目地址：https://github.com/google-research/tuning_playbook
该项目也得到了图灵奖获得者，谷歌 AI 科学家 Geoffrey Hinton 等人的转推支持。Geoffrey Hinton 表示「大量的实践经验已被提炼成这份强大的深度学习模型调参指南。」
这份调参指南适用于对改进深度学习模型性能感兴趣的工程师和研究人员。阅读这份指南需要掌握机器学习和深度学习的基本知识。
这份指南的主要内容是调整超参数，也涉及深度学习训练的其他方面，例如 pipeline 实现和优化。指南假设机器学习问题是一个监督学习问题或自监督学习问题，但其中的一些规定也适用于其他类型的问题。
当前，深度神经网络就像一个黑箱，要想在实践中获得良好的性能，需要付出大量的努力和猜测。更糟糕的是，很少有人记录各种研究获得良好结果的实际方法。人们似乎在回避详解实践中的调参问题，也极少分享经验。这让深度学习专家获得的实验结果，与普通从业者复现相似方法获得的结果差距悬殊。
随着深度学习方法的成熟并对世界产生重要影响，深度学习社区需要更多涵盖有用方法的资源，包括对于获得良好结果至关重要的所有实用细节。
本项目是一个由五名研究人员和工程师组成的团队，他们在深度学习领域工作多年，其中一些人早在 2006 年就开始了。
该团队已经将深度学习应用于从语音识别到天文学的各个领域的问题，并在此过程中学到了很多东西。本文档源于工程师们训练神经网络、教授新机器学习工程师以及为同事提供深度学习实践建议的经验。虽然深度学习早已从实验室实践的机器学习方法发展为数十亿人使用的技术驱动产品，但它作为一门工程学科仍处于起步阶段。
该指南是谷歌研究人员在构建自有深度学习方法时产生的，它代表了作者在撰写本文时的观点，而不是任何客观规律。为此，作者鼓励发现其中存在问题的读者提出替代建议和令人信服的证据，以便不断更新完善这份指南。
需要说明的是，这不是 TensorFlow 等谷歌产品的官方支持文档。
指南内容
该指南包含哪些内容？可以分为四大部分：
- 指导开始新项目
- 改善模型性能的科学方法
- 如何决定每次训练运行步数
- 训练过程中的其他经验
例如第一部分，你开始新项目时如何选择模型架构、优化器、batch 大小等，都有详细的经验指导。
该指南中关于选择模型架构的经验。
而后关于「炼丹」的模型性能改进、训练运行的步数等也有经验分享。
可以说，这份指南可以教你提升模型性能的大量细节。看完下面目录，大家可以去Github细致学习下。
....
#Resampling Forcing
港中文&字节联手：Resampling Forcing 终结长视频“崩坏”，自回归模型迎来端到端新纪元
今天想和大家聊一篇视频生成领域很有意思的新工作。你有没有想过，为什么AI生成的视频一变长，就容易出现画面崩坏、前后不搭的情况？这背后其实藏着一个叫“曝光偏差”的难题。
最近，来自香港中文大学（CUHK）、字节跳动机构的研究者们，共同提出了一种名为Resampling Forcing的全新训练框架，巧妙地解决了这个问题。它提出了一种无需教师模型（Teacher-free） 的全新思路，让自回归视频扩散模型在解决长视频生成难题时，真正实现了从零开始的端到端训练，不仅简化了流程，还显著提升了长视频的生成质量和时序一致性。
- 论文标题：End-to-End Training for Autoregressive Video Diffusion via Self-Resampling
- 研究机构：香港中文大学、字节跳动
- 论文地址：https://arxiv.org/abs/2512.15702
- 项目主页：https://guoyww.github.io/projects/resampling-forcing/
“曝光偏差”：视频生成路上的绊脚石
让我们先用一个简单的比喻来理解“曝光偏差”（Exposure Bias）。
想象一下，你正在教一个孩子画连环画。在训练时（Teacher Forcing），你总是让他看着完美范本的上一页来画下一页。他学得很快，因为参照物总是完美的。但到了考试时（Inference），他必须根据自己画的上一页来创作下一页。如果第一页就画歪了，那第二页、第三页……很可能会越来越离谱，最后整个故事都“崩”了。
自回归视频模型就面临同样的困境。它在训练时看到的历史帧都是来自真实、高清的视频（Ground Truth），但在生成时，它依赖的是自己前一秒生成的、可能存在瑕疵的帧。这种训练与测试之间的不匹配，导致错误不断累积，视频越长，画面质量和一致性就越差。
动态显示：
为了解决这个问题，以前的工作大多采用“蒸馏”方案，即先训练一个强大的双向模型（能同时看到过去和未来）作为“教师”，再让自回归的“学生”模型去模仿它。但这不仅流程繁琐，而且“教师”模型通常在短视频上训练，导致“学生”在面对长视频任务时，依然会“水土不服”。
Resampling Forcing：让模型在“犯错”中学会成长
那么，有没有一种方法能让模型从一开始就学会应对自己的不完美呢？这正是 Resampling Forcing 的核心思想：在训练中模拟推理时的错误。
这套框架非常巧妙，它不需要任何外部的“教师”模型，实现了完全的“自力更生”。
具体来说，它的训练过程分为几个步骤：
- 制造“不完美”历史：首先，从一个干净的视频序列中取出历史帧，对其施加一定程度的噪声，模拟扩散过程的中间状态。
- 模拟推理路径：然后，利用当前正在训练的模型（online model weights），对这些带噪声的历史帧完成剩余的去噪步骤。这一步并不是简单的“去噪不干净”，而是刻意让模型重走一遍生成过程，从而创造出包含模型当前推理误差的伪历史帧。这让训练时的输入分布与真实推理时高度一致。
- 在“模拟考”中学习：最后，模型将基于这些“不完美”的历史帧来学习生成当前帧。同时，通过一个稀疏的因果注意力掩码（Sparse Causal Mask），确保模型在高效的并行训练时（即一次性计算所有帧的损失），每一帧严格遵守物理规律，只关注其对应的过去信息，维持了时间的单向流动性。
通过这种“在错误中学习”的方式，模型天生就具备了对误差的鲁棒性，即使在长视频生成中，也能有效抑制误差累积，保持画面稳定。
History Routing：给历史帧“划重点”，高效生成长视频
生成长视频的另一个挑战是计算量。如果每一帧都要回顾之前所有的历史帧，那成本实在太高了。为此，论文还提出了一个非常实用的无参数机制——历史路由（History Routing）。
它的想法很简单：在生成新的一帧时，并不是所有历史帧都同等重要。比如，一个平稳运动的物体，可能只需要参考紧邻的前几帧；而一个场景切换，则可能需要回顾更早的关键帧。
History Routing 机制无需任何额外参数，它直接利用注意力机制中的相似度分数（Attention Scores），自动计算当前帧与所有历史帧的关联度，然后动态地选择最相关的 Top-k 帧作为参考。这就像是我们记笔记时，会给关键信息划重点一样，大大减轻了模型的“记忆负担”，提升了长视频生成的效率和效果。
上图就展示了在生成第21帧时，哪些历史帧被“选中”的频率最高。可以看到，模型倾向于关注视频的起始帧和一些变化较大的关键时刻，这非常符合直觉。
实验效果：稳定压倒一切
口说无凭，我们来看看实际效果。
在定量比较中，研究者将生成的15秒视频分为三个5秒的片段进行评估。
结果显示，Resampling Forcing 生成的视频在后半段（5-10秒，10-15秒）的质量和时序一致性上，明显优于依赖蒸馏的基线模型。这证明了它在抑制误差累积方面的强大能力。
消融实验也证实了论文提出的自回归重采样策略是模拟误差的最佳方式。
从定性结果来看，无论是“石头人在森林中行走”、“红气球飘过废弃街道”，还是“热带鱼在珊瑚礁中游泳”，该方法生成的视频都展现出了很高的视觉质量和流畅的动态效果（请参看文末视频展示）。
Prompt: A full-body shot of a man crafted entirely from rocks, walking through a dense forest.
Prompt: A red balloon floating in an abandoned street.
Prompt: A tropical fish swimming among colorful coral reefs.
一点思考
总而言之，Resampling Forcing 框架为自回归视频生成模型提供了一条更简洁、更高效的训练路径。它通过“自我纠错”的创新思路，从根本上解决了长视频生成中的误差累积问题，是通往更稳定、更长时序的世界模型（World Models）道路上一次坚实的探索。
这种让模型直面自身不确定性并在训练中学会适应它的哲学，或许对其他生成模型领域的研究也能带来一些启发。
最后看一下官方放出来的生成效果：
....
#SoFlow
一步成图新SOTA！普林斯顿开源SoFlow：训练提速23%
今天想和大家聊一篇来自普林斯顿大学的最新研究“SoFlow”。在生成模型的领域，扩散（Diffusion）模型和流匹配（Flow Matching）模型无疑是当下的主流技术，它们能够生成质量惊人的图像。但它们普遍存在一个问题：生成过程需要多步迭代，非常耗时。为了解决这个效率问题，研究者们开始探索“一步式”或“少步式”生成。
这篇论文提出的SoFlow（Solution Flow Models，可理解为“解流模型”）就是这个方向上一个非常有意思的探索。它旨在从零开始训练一个能“一步到位”完成高质量图像生成的模型。更棒的是，它在实现这一目标的同时，还解决了现有方法的一些痛点，比如训练不稳定和计算开销大等问题。
从上面这些由 SoFlow XL/2 模型一步生成的 ImageNet 样本可以看出，其效果相当惊人，无论是细节纹理还是整体结构，都保持了很高的水准。
- 论文标题：SoFlow: Solution Flow Models for One-Step Generative Modeling
- 机构：普林斯顿大学
- 论文地址：https://arxiv.org/abs/2512.15657
- 代码仓库：https://github.com/zlab-princeton/SoFlow
结果怎么样？在标准的ImageNet 256x256数据集上，使用相同的训练配置和模型架构（DiT），SoFlow在单步生成（1-NFE）任务上的FID分数全面优于近期的热门模型MeanFlow。
研究背景与动机
生成模型的效率一直是研究的热点。传统的扩散模型和流匹配模型，好比一位画家反复修改画稿，通过上百甚至上千步的“去噪”或“传输”过程，才能最终得到一幅精美的作品。这个过程虽然效果好，但速度慢，限制了其在实时应用中的潜力。
为了加速，学术界提出了“一致性模型”（Consistency Models）等技术，它们试图学习一个直接的映射，从任意一个中间状态一步跳到最终的清晰图像。这就像让画家拥有“一挥而就”的能力。然而，这种“抄近道”的方法也带来了新的挑战：
- 训练不稳定：直接学习最终结果，优化目标会不断变化，导致训练过程像是在追逐一个移动的目标，难以收敛。
- 无法有效利用CFG：分类器无关引导（Classifier-Free Guidance, CFG）是提升生成质量的“法宝”，但在从零开始训练的一致性模型中很难应用。
- 计算瓶颈：一些改进方法（如MeanFlow）为了稳定训练，引入了流匹配损失，但这又依赖于计算开销巨大的“雅可比向量积”（Jacobian-vector product, JVP）。在PyTorch这样的主流深度学习框架中，JVP的优化程度远不如标准的前向和反向传播，成为了新的效率瓶颈。
SoFlow的动机，正是为了设计一个既能实现高质量一步生成，又能天然地支持CFG，同时还绕开JVP计算瓶颈的全新框架。
SoFlow的核心方法
SoFlow的核心思想非常巧妙：不再学习如何一步步“去噪”或“流动”，而是直接学习控制整个生成过程的常微分方程（ODE）的“解函数”（Solution Function）。
我们知道，流匹配模型定义了一个速度场，它描述了数据点在时间的运动方向和速率。整个生成过程就是求解这个速度场ODE的初值问题：
其中是初始的噪声。传统方法需要用数值求解器（如欧拉法）一步步从积分到。
SoFlow则定义了一个解函数，它的作用是直接预测出：给定时刻的状态，在另一个时刻的状态应该是什么。理想情况下，如果模型学得足够好，我们只需要输入的噪声，就能一步算出时的清晰图像。
为了让神经网络学会这个解函数，作者提出了两个关键的损失函数：
1. 流匹配损失 (Flow Matching Loss)
这个损失函数让模型具备了预测速度场的能力。通过对解函数在的特殊点上进行分析，可以推导出一个与速度场直接关联的表达式。通过最小化模型预测速度与真实速度（由数据和噪声对定义）之间的差距，模型就学到了流动的基本规律。
这个损失的存在至关重要，因为它为在训练中引入CFG提供了可能。模型既然能估计速度，就可以在条件和非条件速度之间进行插值，从而应用CFG来提升生成质量。
2. 解一致性损失 (Solution Consistency Loss)
这是SoFlow的精髓所在。这个损失的核心思想是，一个正确的解函数，其预测结果应当在时间上是“自洽”的。如下图所示，从时刻的状态出发，先通过真实速度场微小地走到一个中间时刻，再从时刻用模型预测时刻的结果，这个结果应该与直接从时刻用模型预测时刻的结果保持一致。
具体来说，损失函数被定义为：
其中，表示目标网络（参数被冻结，即stop-gradient），是时刻的真实速度。这个公式的巧妙之处在于，它通过一个微小的“扰动”来构建一个一致性目标，而这个过程完全不需要计算雅可比矩阵，从而完美避开了JVP的计算瓶颈。这使得SoFlow的训练速度更快，显存占用也更低。
最终，SoFlow的总损失是这两个损失的加权和。模型架构基于流行的DiT（Diffusion Transformer），并根据参数量分为B/4, B/2, M/2, L/2, XL/2等不同规模。
实验结果与分析
SoFlow的实验部分非常扎实，尤其是在ImageNet 256x256上的类条件生成任务上。
消融研究
作者首先通过一系列消融实验验证了各个设计的重要性。例如，实验证明了同时使用流匹配损失和解一致性损失（即）比只用其中一个效果更好。同时，损失函数中的加权系数、CFG强度等超参数也对最终性能有显著影响。
主要性能对比
下图清晰地展示了SoFlow模型随着参数量的增加，其单步生成的FID-50K分数稳步下降，证明了模型良好的可扩展性。
在与SOTA模型的对比中，SoFlow展示了强大的竞争力。下表是详细的性能数据。为了公平比较，SoFlow与MeanFlow都从零开始训练了相同的epochs。
可以看到，在从B/2到XL/2的各种模型规模下，SoFlow的1-NFE FID分数都显著低于MeanFlow。例如，在最大的XL/2规模上，SoFlow达到了2.96的FID，而MeanFlow为3.43。这证明了SoFlow框架的优越性。值得一提的是，这些结果都是在真正的单次前向传播（1-NFE）下实现的，因为CFG已经在训练阶段融入模型，推理时没有额外开销。
训练效率优势
由于避免了JVP计算，SoFlow在训练效率上优势明显。如下表所示，在使用相同的代码库和硬件（H100 GPU）进行对比时，SoFlow不仅峰值显存占用降低了约31% ，而且训练速度提升了约23% 。这对需要进行大量实验的研究者来说，无疑是个巨大的福音。
生成样本展示
当然，除了冷冰冰的数字，我们更关心生成的图像质量。下面是SoFlow (XL/2) 模型在ImageNet上一步生成的样本，可以看出其质量非常高，细节和多样性都相当不错。
在CIFAR-10数据集上的无条件生成任务中，SoFlow同样取得了具有竞争力的结果。
一点思考
SoFlow的提出，为高效生成模型的研究开辟了一条新的道路。它优雅地将流匹配的速度场学习和一致性模型的直接映射思想结合起来，并通过巧妙的损失函数设计，绕开了前人方法中的计算障碍。
值得一提的是，代码已经开源了，感兴趣的同学不妨一试。
....
#Qwen-Image-Layered
打开图像编辑的“正确“方式！阿里提出Qwen-Image-Layered：像玩转PS一样，自由编辑图片
- 论文标题：Qwen-Image-Layered: Towards Inherent Editability via Layer Decomposition
- 机构：香港科技大学（广州）、阿里巴巴、香港科技大学
- 论文地址：https://arxiv.org/abs/2512.15603
- 代码仓库：https://github.com/QwenLM/Qwen-Image-Layered
最近，生成模型在图像编辑领域可以说是遍地开花，但不知道你有没有发现，想要做到“指哪打哪”的精准、无痕编辑，其实还挺难的。问题出在哪？根源在于我们日常接触的绝大多数图片（比如JPG、PNG）都是“扁平”的，所有的视觉元素——人、景、物——都融合在一个画布上，牵一发而动全身。
改动一个地方，很容易就影响到其他不想改变的区域，出现所谓的“语义漂移”（比如人脸变了）或“几何错位”（比如物体位置跑偏了），一致性很难保证。
不知道你是否想过，如果AI能像专业设计师使用Photoshop（PS）那样，把一张图片天然地看作是多个图层的堆叠，那编辑起来不就轻松多了吗？每个图层（比如人、背景、文字）都是独立的，可以单独修改、移动、缩放，而不会干扰到其他部分。
今天，来自阿里巴巴和香港科技大学（广州）的研究者们，就朝着这个“原生可编辑性”的目标迈出了一大步。他们推出了一个全新的扩散模型——Qwen-Image-Layered。它的核心能力，就是将一张普通的RGB图片，端到端地分解成多个包含透明度信息（RGBA）的、语义上分离的图层。
这就像是赋予了AI一双“透视眼”，能自动将扁平的图像“还原”成类似PS工程文件的结构。从此，图像编辑不再是小心翼翼地“重绘”，而是变成了对独立图层的自由操控，实现了真正意义上的原生可编辑性（Inherent Editability）。
核心方法：三位一体的架构设计
为了让模型学会这种强大的分解能力，研究团队设计了一个精妙的“三位一体”架构。
统一潜空间：RGBA-VAE
首先，模型需要一个能同时理解输入（RGB图）和输出（多个RGBA图层）的“通用语言”。传统的VAE（变分自编码器）要么处理RGB，要么处理RGBA，分开处理会导致信息鸿沟。
因此，团队提出了一个RGBA-VAE，它是一个四通道的VAE，通过巧妙的设计，可以统一处理RGB和RGBA图像，将它们编码到一个共享的潜空间中。这极大地缩小了输入和输出之间的分布差距，为后续的精确分解奠定了基础。
可变长图层分解：VLD-MMDiT
接着是负责“分解”的核心引擎——VLD-MMDiT（可变长图层分解多模态扩散Transformer）。之前的方法大多只能分解固定数量的图层（比如前景和背景），而VLD-MMDiT则可以灵活地将图像分解成任意数量的图层。
这里的关键创新是Layer3D RoPE（三维图层旋转位置编码），它在传统的位置编码中增加了一个“图层”维度。这使得模型能够清晰地区分不同图层以及作为输入的原始图像，从而自如地处理可变、动态的图层结构。
循序渐进：多阶段训练策略
直接让模型学会如此复杂的分解任务是很困难的。因此，研究者设计了一套多阶段训练策略。模型从一个相对简单的任务（文生RGB图像）开始，然后逐步过渡到更复杂的任务（文生RGBA图像，最终到图生多层RGBA图像）。这种“课程学习”的方式，让模型可以稳定、高效地掌握最终的分解能力。
数据难题：从PSD文件到高质量数据集
这个任务的一大挑战是缺乏高质量的、带图层信息的训练数据。为了解决这个问题，团队建立了一条数据处理流水线，从大量的Photoshop源文件（PSD）中提取和标注数据。
他们不仅提取图层，还进行了严格的筛选和合并。例如，一些PSD文件可能包含数百个图层，团队会智能地合并那些在空间上不重叠的图层，大大降低了数据复杂度。最终，他们构建了一个包含丰富类别的大规模、高质量多层图像数据集，为模型的强大性能提供了坚实的基础。
实验结果：刷新SOTA
Qwen-Image-Layered在定性和定量上都展现了其优越性。
定性效果
模型在各种类型的图像上都表现出色，无论是普通物体、人像还是复杂的文字，都能被干净利落地分解到不同的图层中。
(开放域图像的分解效果)
(包含文字的图像的分解效果)
与之前的SOTA方法LayerD相比，效果差异非常明显。LayerD的分解结果中经常出现伪影和不准确的分割，而Qwen-Image-Layered的图层则干净、语义清晰。
量化分析
在Crello数据集上的量化比较中，Qwen-Image-Layered同样展现了卓越的性能。与之前的SOTA方法LayerD相比，它在Alpha soft IoU指标上相对提升了15.8%，在RGB L1误差上也有显著降低。这标志着它在生成高精度透明蒙版方面的能力要强大得多，分解出的图层边缘更清晰、更准确。
消融实验也证明，前面提到的RGBA-VAE、VLD-MMDiT和多阶段训练这三大组件，对于模型最终的优异性能缺一不可。
解锁编辑新可能
Qwen-Image-Layered的真正威力体现在编辑上。由于对象存在于独立的图层中，像缩放、移动、调整前后顺序这些操作，就变得轻而易举，而且完全不会影响图像的其他部分。
例如，将“Skate boarding”字样移动到女孩前面，或者让女孩变得更大，这些对于传统的图生图模型来说是老大难的问题，现在因为有了图层而“原生支持”。
写在最后
Qwen-Image-Layered为视觉生成模型开创了一个全新且极具前景的范式。通过从扁平、纠缠的图像表示转向解耦、分层的表示，它从根本上解决了图像编辑中的一致性难题。
这项工作不仅提供了一个强大的工具（已开源！），也为未来基于图层的图像合成和处理研究开辟了激动人心的道路。
....
#直观理解Flow Matching生成式算法
目前不少讲Flow Matching的文章都上来一大堆概念，一大堆公式，搞得人头皮发麻，但实际上这个算法没那么复杂，代码也很容易理解。
本文不推导公式、无高深数学概念即可理解flow matching算法，并完成一个简单的代码实战。
算法原理
Related Works
Flow Matching是一种生成式模型。
最简单的生成式模型，目标就是没输入的情况下，就能生成与给定目标集中的样本相近的样本。
举个例子，可以直接无提示的用diffusion模型来生成图片。
带提示的生成式任务是可以基于无提示的生成式任务简单实现的，这里我们先只考虑无提示的生成式任务。
由于我们一般学的是一个映射，拿一个空输入映射成不同的样本不太符合映射的定义，因此，我们一般实际上会生成一堆随机值作为输入，要学的就是如何从随机值生成目标集中的一个随机样本。
如图片生成模型，经常就会用先生成一个随机图片，然后学的就是如何把这个图修改成一个目标集中的样本。
我们如果直接拿一个MLP，学随机数据到目标数据的映射，经常得到的结果并不是很好，因为随机数据中几乎不包含有用信息，相近的两个随机数据，很有可能映射到的是两个完全不同的样本。这就导致模型学到的很有可能是目标集许多图的各个像素的均值，并不是一个有意义的图片。
考虑另一个任务，如果我们把目标集遮挡少量像素，让模型来推测原始目标集，则是一个极其简单的任务，一方面是因为遮挡的像素与周边的像素间有很强的相关性，另一方面，因为输入信息中存在很多信息，这些信息使得模型可以确定这张目标图的可能性从原本的全部图片坍缩到少量特定的状态，这样的话剩余的少量特定状态的平均值也经常是一个有效的生成结果。
那么一个常见的生成图片的办法就是先用模型生成一个像素，再用第一个像素作为输入预测第二个像素，再拿前两个像素作为输入预测第三个...直到整张图预测出来。这种方法，每个像素确定后，它附近的像素就坍缩到了几种特定的状态，越来越多像素确定后，整张图就坍缩到了基本固定的状态中。使得整张图片不会呈现出多种状态的均值叠加态。
这个NLP任务也展示了为什么有时自回归可以比直接整批预测得到更好的结果：『老师』和『演员』两个模态都不错时，有时容易预测出『老员』这种四不像。而自回归，确定了『老』字之后把它作为输入，再让它预测就只能回答『师』了。
前边讲这种自回归的方案生成图片效果很好，但要为每个像素调用一次模型，效率极低。
想改进效率最简单的想法就是一次生成一个区域的图片，但区域的图片越大，就越容易出现整个区域均值叠加的问题。
于是有一种改进办法是一次生成的一批像素尽可能远一些，这样他们之间的关联较小，前边的问题就影响相对较小。
而diffusion算法，则是学一种降噪算法，它会自动判断图片中的噪声是啥，并尝试恢复原图。
但如果直接一步用一张全是噪声的随机图来生成原图，则依然存在前述可能性过多而导致结果是多种可能均值的问题，因此，diffusion会进行初步的降噪，然后再尝试根据降噪的输出结果作为输入，再次尝试降噪，这次降噪时，因为已经有了前次的输出作为输入，更多的输入把结果坍缩成了少量的状态。这样经过多次迭代降噪，结果越来越坍缩，就规避掉了前边的结果为均值的问题。diffusion具体算法原理不是本文重点，就不多讲细节了。
Flow Matching
diffusion算法效果不错，但效率依然不够高，是否有一些更直接高效的方法？
当然有，本文flow matching方法就是一种现在应用广泛的方案，在Stable Diffusion 3、Meta MovieGen中都使用flow matching替代了扩散模型（flow matching也可以看做是一种特殊的扩散模型）。
我们现在把问题简化，考虑一个比较简单的生成式任务，我们要做一个模型，这个模型用来生成一些二维空间的坐标点。
这些目标坐标点可能拥有某些特征，例如，他们可能都在某个特定的形状内，如下图中Pdata(x)中的这些点。
我们要学习的就是一个Generator G，它输入一个随机二维坐标，生成与Pdata(x)中的点尽可能像的一个点。
特别的，假设我们要生成的Pdata都是在[0, 4pi)区间内的y = sin(x)曲线上的点，那么，我们想训练一个模型，希望能让这个模型学习到这些点的特征，并能够生成一个满足这些特征的任意的点。
Flow Matching算法，要学的是一个行驶（修正）的方向，即，如果我有一个点，可以移动，我该怎么走，才能走到目标点上。
它学习的时候，会在source->target路线上采样出一堆点，然后简单直接的认为source到target这条直线上所有的点，都应该直接朝着target方向走。
训练时：
- 对于每一个target样本，生成一个随机的输入(source)，在这个例子里即一个随机坐标（shape与target相同）
- 然后连线source->target，并采样N步，对中间的采样点，调用一个网络，预测其斜率是多少，然后拿source->target的斜率作为监督值。（实际上预测的不仅仅是斜率，而是速度场，也就是移动的方向和单位时间内移动的距离，在粗理解时，在二维空间上可以先简单理解成斜率。）
我们可以发现，同一个中间点可能会受到多组source->target连线的影响，因此最终学到每个点的斜率可能是多条连线斜率的均值。
在推理时，可以从source出发，一步步往target走，一开始会沿着多条线的均值行动，但行走的过程中，越接近某个特定的target时，它就越坍缩到某个固定的状态，最终走到某个与目标集相近的样本上。
代码
代码十分简单：
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import numpy as np
# 超参数
dim = 2 # 数据维度（2D点）
num_samples = 1000
num_steps = 50 # ODE求解步数
lr = 1e-3
epochs = 5000
# 目标分布：正弦曲线上的点（x1坐标）
x1_samples = torch.rand(num_samples, 1) * 4 * torch.pi # 0到4π
y1_samples = torch.sin(x1_samples) # y=sin(x)
target_data = torch.cat([x1_samples, y1_samples], dim=1)
# 噪声分布：高斯噪声（x0坐标）
noise_data = torch.randn(num_samples, dim) * 2
class VectorField(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(dim + 1, 64), # 输入维度: x (2) + t (1) = 3
nn.ReLU(),
nn.Linear(64, dim)
)
def forward(self, x, t):
# 直接拼接x和t（t的形状需为(batch_size, 1)）
return self.net(torch.cat([x, t], dim=1))
model = VectorField()
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
for epoch in range(epochs):
# 随机采样噪声点和目标点
idx = torch.randperm(num_samples)
x0 = noise_data[idx] # 起点：噪声
x1 = target_data[idx] # 终点：正弦曲线
# 时间t的形状为 (batch_size, 1)
t = torch.rand(x0.size(0), 1) # 例如：shape (1000, 1)
# 线性插值生成中间点
xt = (1 - t) * x0 + t * x1
# 模型预测向量场（直接传入t，无需squeeze）
vt_pred = model(xt, t) # t的维度保持不变
# 目标向量场：x1 - x0
vt_target = x1 - x0
# 损失函数
loss = torch.mean((vt_pred - vt_target)**2)
# 反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()
x = noise_data[0:1] # 初始噪声点
trajectory = [x.detach().numpy()]
tag = torch.from_numpy(np.array([1]))
# 数值求解ODE（欧拉法）
t = 0
delta_t = 1 / num_steps
with torch.no_grad():
for i in range(num_steps):
vt = model(x, torch.tensor([[t]], dtype=torch.float32))
t += delta_t
x = x + vt * delta_t # x(t+Δt) = x(t) + v(t)Δt
trajectory.append(x.detach().numpy())
trajectory = torch.tensor(trajectory).squeeze()
print(trajectory[-1] / (torch.pi / 10 * 4))
# 绘制向量场和生成轨迹
plt.figure(figsize=(10, 5))
plt.scatter(target_data[:,0], target_data[:,1], c='blue', label='Target (sin(x))')
plt.scatter(noise_data[:,0], noise_data[:,1], c='red', alpha=0.3, label='Noise')
plt.plot(trajectory[:,0], trajectory[:,1], 'g-', linewidth=2, label='Generated Path')
plt.legend()
plt.title("Flow Matching: From Noise to Target Distribution")
plt.show()
带提示词的生成式模型
从无提示词的生成式模型变成带提示词的生成式模型还是比较简单的，提示词不限于文本、语音、数字等任意输入。
一般就是在训练过程中，预测斜率的网络添加一个prompt的输入，其他都不变即可。而对于复杂prompt可能需要一些前置的网络把提示词转成一个比较好的latent表达。
对前述代码简单修改，即可完成把target线分成10段，tag为0时，生成最左边一段上的点，即[0, 4*pi/10)，tag为1时生成左二段上的点，以此类推。
代码如下（仅少量行与前边代码有少许区别）：
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import numpy as np
# 超参数
dim = 2 # 数据维度（2D点）
num_samples = 1000
num_steps = 50 # ODE求解步数
lr = 1e-3
epochs = 5000
# 目标分布：正弦曲线上的点（x1坐标）
x1_samples = torch.rand(num_samples, 1) * 4 * torch.pi # 0到4π
y1_samples = torch.sin(x1_samples) # y=sin(x)
target_data = torch.cat([x1_samples, y1_samples], dim=1)
tags = torch.from_numpy(np.array([[int(x1_samples[i] / (4 * torch.pi / 10.0)),] for i in range(num_samples)]))
# 噪声分布：高斯噪声（x0坐标）
noise_data = torch.randn(num_samples, dim) * 2
class VectorField(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(dim + 2, 64), # 输入维度: x (2) + t (1) + tag(1) = 4
nn.ReLU(),
nn.Linear(64, dim)
)
def forward(self, x, t, tag):
# 直接拼接x和t（t的形状需为(batch_size, 1)）
return self.net(torch.cat([x, t, tag], dim=1))
#return self.net(torch.cat([x, t], dim=1))
model = VectorField()
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
for epoch in range(epochs):
# 随机采样噪声点和目标点
idx = torch.randperm(num_samples)
x0 = noise_data[idx] # 起点：噪声
x1 = target_data[idx] # 终点：正弦曲线
# 时间t的形状为 (batch_size, 1)
t = torch.rand(x0.size(0), 1) # 例如：shape (1000, 1)
# 线性插值生成中间点
xt = (1 - t) * x0 + t * x1
# 模型预测向量场（直接传入t，无需squeeze）
vt_pred = model(xt, t, tags[idx]) # t的维度保持不变
# 目标向量场：x1 - x0
vt_target = x1 - x0
# 损失函数
loss = torch.mean((vt_pred - vt_target)**2)
# 反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 从噪声出发，解ODE生成数据
x = noise_data[0:1] # 初始噪声点
trajectory = [x.detach().numpy()]
tag_num = 1
tag = torch.from_numpy(np.array([tag_num]))
# 数值求解ODE（欧拉法）
t = 0
delta_t = 1 / num_steps
with torch.no_grad():
for i in range(num_steps):
vt = model(x, torch.tensor([[t]], dtype=torch.float32), tag.reshape([1,1]))
t += delta_t
x = x + vt * delta_t # x(t+Δt) = x(t) + v(t)Δt
trajectory.append(x.detach().numpy())
trajectory = torch.tensor(trajectory).squeeze()
print(trajectory[-1] / (torch.pi / 10 * 4))
# 绘制向量场和生成轨迹
plt.figure(figsize=(10, 5))
plt.scatter(target_data[:,0], target_data[:,1], c='blue', label='Target (sin(x))')
plt.scatter(noise_data[:,0], noise_data[:,1], c='red', alpha=0.3, label='Noise')
plt.plot(trajectory[:,0], trajectory[:,1], 'g-', linewidth=2, label='Generated Path')
plt.legend()
plt.title("Flow Matching: From Noise to Target Distribution")
plt.show()第80行输出了：tensor([1.4376, 0.6455])，落在了区间1里，和tag_num=1匹配，说明模型根据提示词生成了正确区间内的数据。
更真实的例子——手写数字生成
在mnist数据集上flow matching做手写数字生成，输入数字，生成手写体数字图片。
以下代码有几个关键点：
- 选用UNet作为预测速度场的backbone网络，主要是因为它有多尺度特征融合能力，在主流生成式模型中体现了很强的性能。
- 在推理时把线性按delta_t往目标走，改成了自适应变步长的走法，可以用在相同步数时，得到更精细的结果（毕竟一开始不用走那么精准，t越接近1，越需要精调）。这个只改了推理，并未影响训练逻辑。
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torchvision import transforms
from torch.utils.data import DataLoader
from torchdiffeq import odeint
import matplotlib.pyplot as plt
# ================== 配置参数 ==================
device = torch.device("cuda"if torch.cuda.is_available() else"cpu")
image_size = 28
channels = 1
batch_size = 256
lr = 1e-4
epochs = 100
num_classes = 10
# ================== 数据加载 ==================
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: 2 * x - 1) # [-1, 1] 归一化
])
train_dataset = torchvision.datasets.MNIST(
root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2)
# ================== 模型架构 ==================
class ConditionedDoubleConv(nn.Module):
"""带条件注入的双卷积模块"""
def __init__(self, in_channels, out_channels, cond_dim):
super().__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)
self.norm1 = nn.GroupNorm(8, out_channels)
self.conv2 = nn.Conv2d(out_channels + cond_dim, out_channels, kernel_size=3, padding=1)
self.norm2 = nn.GroupNorm(8, out_channels)
def forward(self, x, cond):
x = F.silu(self.norm1(self.conv1(x)))
cond = cond.expand(-1, -1, x.size(2), x.size(3)) # 动态广播条件
x = torch.cat([x, cond], dim=1)
return F.silu(self.norm2(self.conv2(x)))
class Down(nn.Module):
"""下采样模块"""
def __init__(self, in_channels, out_channels, cond_dim):
super().__init__()
self.maxpool = nn.MaxPool2d(2)
self.conv = ConditionedDoubleConv(in_channels, out_channels, cond_dim)
def forward(self, x, cond):
x = self.maxpool(x)
return self.conv(x, cond)
class Up(nn.Module):
"""上采样模块"""
def __init__(self, in_channels, out_channels, cond_dim):
super().__init__()
self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
self.conv = ConditionedDoubleConv(in_channels, out_channels, cond_dim)
def forward(self, x1, x2, cond):
x1 = self.up(x1)
# 尺寸对齐
diffY = x2.size()[2] - x1.size()[2]
diffX = x2.size()[3] - x1.size()[3]
x1 = F.pad(x1, [diffX//2, diffX - diffX//2,
diffY//2, diffY - diffY//2])
x = torch.cat([x2, x1], dim=1)
return self.conv(x, cond)
class ConditionalUNet(nn.Module):
"""维度安全的条件生成UNet"""
def __init__(self):
super().__init__()
# 统一条件编码维度
self.t_dim = 16
self.label_dim = 16
self.cond_dim = self.t_dim + self.label_dim # 32
# 时间嵌入
self.time_embed = nn.Sequential(
nn.Linear(1, 32),
nn.SiLU(),
nn.Linear(32, self.t_dim)
)
# 标签嵌入
self.label_embed = nn.Embedding(num_classes, self.label_dim)
# 编码路径
self.inc = ConditionedDoubleConv(1, 64, self.cond_dim)
self.down1 = Down(64, 128, self.cond_dim)
self.down2 = Down(128, 256, self.cond_dim)
# 解码路径
self.up1 = Up(256 + 128, 128, self.cond_dim) # 输入通道修正
self.up2 = Up(128 + 64, 64, self.cond_dim)
self.outc = nn.Conv2d(64, 1, kernel_size=1)
def forward(self, x, t, labels):
# 条件编码 (统一维度)
t_emb = self.time_embed(t.view(-1, 1)) # [B, 16]
lbl_emb = self.label_embed(labels) # [B, 16]
cond = torch.cat([t_emb, lbl_emb], dim=1) # [B, 32]
cond = cond.unsqueeze(-1).unsqueeze(-1) # [B, 32, 1, 1]
# 编码器
x1 = self.inc(x, cond)
x2 = self.down1(x1, cond)
x3 = self.down2(x2, cond)
# 解码器
x = self.up1(x3, x2, cond)
x = self.up2(x, x1, cond)
return self.outc(x)
# ================== 训练与生成 ==================
model = ConditionalUNet().to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
@torch.no_grad()
def generate_with_label(label, num_samples=16, device="cuda"):
"""生成指定标签的样本（修复条件维度问题）"""
model.eval（)
# 初始噪声和标签
x0 = torch.randn(num_samples, 1, 28, 28, device=device)
labels = torch.full((num_samples,), label, device=device, dtype=torch.long)
# 定义ODE函数
def ode_func(t: torch.Tensor, x: torch.Tensor):
t_expanded = t.expand(x.size(0)) # [1] -> [num_samples]
vt = model(x, t_expanded, labels)
return vt
# 时间点（从0到1）
t_eval = torch.tensor([0.0, 1.0], device=device)
# 解ODE（自适应步长）
generated = odeint(
ode_func,
x0,
t_eval,
rtol=1e-5,
atol=1e-5,
method='dopri5'
)
# 后处理
images = (generated[-1].clamp(-1, 1) + 1) / 2 # [0,1]
return images.cpu().squeeze(1) # 移除通道维度
def visualize_samples(samples, title="Generated Samples"):
"""可视化生成结果"""
plt.figure(figsize=(10, 10))
for i in range(16):
plt.subplot(4, 4, i+1)
plt.imshow(samples[i].squeeze().cpu().numpy(), cmap='gray', vmin=0, vmax=1)
plt.axis('off')
plt.suptitle(title)
plt.show()
def plot_100_digits(image_size=28, device="cuda"):
"""
生成0-9各10张数字并绘制在10x10网格中
Args:
model: 训练好的生成模型
image_size: 图像尺寸（默认MNIST为28）
device: 计算设备
"""
plt.figure(figsize=(8, 8))
# 为每个数字0-9生成10张图
for label in range(10):
# 生成当前数字的10个样本
generated = generate_with_label(
label=label,
num_samples=10
).numpy() # 形状 (10, 28, 28)
# 在当前行绘制
for i in range(10):
ax = plt.subplot(10, 10, i * 10 + 1 + label)
plt.imshow(generated[i], cmap='gray')
ax.axis('off')
# 在每列第一行添加标签
if i == 0:
ax.text(14, -10, str(label), fnotallow=20, ha='center')
plt.tight_layout()
plt.show()
def train():
"""训练循环"""
for epoch in range(epochs):
model.train()
total_loss = 0
for images, labels in train_loader:
images = images.to(device)
labels = labels.to(device)
# 动态噪声生成
noise = torch.randn_like(images)
t = torch.rand(images.size(0), device=device)
xt = (1 - t.view(-1,1,1,1)) * noise + t.view(-1,1,1,1) * images
# 前向计算
vt_pred = model(xt, t, labels)
loss = F.mse_loss(vt_pred, images - noise)
# 反向传播
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
total_loss += loss.item()
# 每10个epoch生成示例
if epoch % 10 == 0:
plot_100_digits()
print(f"Epoch {epoch} Loss: {total_loss/len(train_loader):.4f}")
if __name__ == "__main__":
train()
注：文中讲的是Flow Matching中的一种常见特殊实现Condition Flow Matching。
本文只有直观理解，但缺少了严格数学证明。建议读者们之后还是要回过去理解原理，因为这样才能更灵活的运用。
参考资料
- 通俗易懂理解Flow Matching
- 解密为什么 Diffusion 模型比自回归模型 Auto-Regression 更好？
- 李宏毅扩散模型教程
....
#关于 Agentic RL 训推框架的一点看法和思考
前段时间调研了一些 RL 训练框架，目前开源社区的 RL 训练框架可以说百花齐放，老牌的有 openlhf、trl、unsloth、verl。还有今年新开源的 slime、AReaL、Rlinf、RL2、ROLL 等等，肯定还有很多没列出来的，就不一一列举，也看不过来。
由于工作的场景需求是对于 VL 多模态模型进行实际环境的 RL 训练，这个过程需要 multi turn，因此很多框架可能目前并能很好的适配。
重点对 verl、slime、AReaL、RL2 做了代码阅读分析，与实际 RL 环境进行适配。这里先说一下我调研框架过程中纠结的一些点。（个人看法，轻喷）
点 1：各训练框架尺有所短、寸有所长，都有各自的架构很好的地方，也有相对待完善的方面。
目前没有一款可以很好适配多模态模型去做我的需求业务的 agentic rl 训练的框架，当然这也不是框架的原因，主要在于 agentic 环境与具体业务相关，没有办法从框架层面抽象出来一个函数或者类来适配所有的 agentic 环境，这也是我从一个框架调研到另一个再到另一个的原因。
我一直想找一个社区活跃度比较高，对于环境适配代码相对修改较少的框架，这里直接说，最后选择了 AReaL。（我的具体业务环境不展开说了，简单来说是需要每个训练样本都有不同的环境状态，除了模型的输出内容去环境里执行动作以外，还需要框架会话与环境多次交互，这一点就卡死了大部分 RL 框架的 agent loop 控制流，当然除非做侵入式代码修改，但框架更新后 rebase 又很麻烦）
点 2：我比较纠结的是 RL 训练过程中 GPU 的编排问题
在 rlhf 和 rlvr 时代（听上去很遥远，实际上也就是 25 年前半年以及之前）训练过程中长尾效应没有 agentic rl 那么明显，所以异步 RL 训练的想法并没有在早起成熟的 RL 训练框架中体现出来。
之前开源的 RL 框架基本上都是训练和推理同步的架构方案，典型代表像 verl，verl 实现了这几个模型的简单命令编排，但没有改变同步运行的本质，也就是整个训练流程都要遵循下图中 1,2,3 来进行，先推理后训练。
同步的 RL 训练玩的也比较花，比如是在相同的 GPU 集群上，推理时训练的模型卸载，训练时推理的模型卸载，这种可以在容器内部署，也可以物理上执行。也可以在不同的 GPU 集群上流水线的方案，就像 verl，但这样就会造成训练效率的低下以及 GPU 空转。
因此我对于以同步 RL 训练为主的框架都是浅尝辄止，没有深入研究，verl 是因为今年 10 月份增加了全异步训练的 monkey patch 才对其源码进行来阅读，不过代码中写死了 agentic 的执行流程，修改起来代码量不小，后面会稍微详细的说一下。
点 3：数据流向与数据结构
其实这也是同步和异步训练带来的一个影响。在 verl 中将传统的 rlhf 训练的流程看成一个数据流图，数据在 actor、critic、reference、reward 中进行流转，最后来计算 PPO 公式得到损失，再对 actor 进行反向传播，参照下图：
为此 verl 专门设计了一种数据格式：DataProto [1]
从这个数据结构组成上来看并不复杂，它是以 batch 为粒度进行数据传输的，这在长尾效应不明显的 RL 训练中是高效的，但是在 agentic rl 中反而成了一种负担。
原因很简单，训练的 DataProto 和推理的 DataProto 是否要是同一批数据呢，如果是同一批那就要考虑长尾样本的延迟，如果不是同一批那这个设计反而代理额外的时延（推理的样本异步执行，结果再去组成一个 DataProto）。verl 源码中是前者的实现[2]，但在补丁代码中是使用的后者[3]。
点 4：异步 RL 训练框架肯定优先级比较高
今年开源的几个框架都支持异步 RL 训练，但异步会带来效率上的提升，但也会存在一些问题，首当其冲的就是数据偏移问题，换句话说就不是真正的 on policy 训练，因为训练的数据可能是更早几轮的策略模型生成的，在强化学习训练中大家的共识就是 on policy 效果优于 off policy。
另一个问题就是异步 RL 训练占用的 GPU 资源较高，相对于同步训练中训练和推理共用 GPU 集群来说，异步 RL 训练必须将训练和推理部署在不同的 GPU 上，且二者需要去实验来获得一个比例，来保证异步 RL 训练和推理尽量的减少 bubble。
除了以上内容外，从各 RL 训练框架代码中获得了一些关于 RL 的启发认识，有的是之前知道但不清楚代码如何去实现，也有的是从代码上新认识到的。
1、当前几乎所有的 RL 训练框架都是训推分离的
也就是训练引擎使用 FSDP、Megatron，推理引擎采用 sglang 或者 vllm。训练和推理之间采用 ray 来充当胶水，作用就是分配资源，分布式远程调度等。
RL 训练框架真正实现的是对于数据的管理、训练引擎和推理引擎的调度、模型权重的迁移（训练后的模型权重更新到推理引擎，训练与推理不同切分方式的适配）以及环境的适配。
每个框架在这四个方面有不同的侧重，比如 verl 侧重在训练引擎和推理引擎的调度，包括其为了践行 SPMD 思想（类似于 torchrun 和 CUDA 的运行，每个设备 rank 上都会有相同的代码，而各设备会根据自己的约束来执行各自的那部分代码）编写了 single_controller[4]，通过封装底层的 ray 代码让用户只需要简单的命令来实现复杂的模型编排部署，如下图所示，这种模式天然简约。
但这种模式在异步 RL 训练反而成了瓶颈，异步需要额外的代码去更新权重、处理生产者与消费者的关系，保持 SPMD 风格会使得代码量骤增。其他的框架基本上是直接调用 ray，通过 placement_group 来分配 GPU 资源，remote 来调度。
2、RL 训推分离的训练流程中的控制流还是在训练侧
也就是训练的控制流代码中，其实这非常好理解，强化学习训练与正常的 llm 做 sft 和 pre-train 训练区别不大，因为都是基于梯度回传的思想来实现的，区别就在于损失函数不再是交叉熵，且数据的来源需要 rollout 推理生成，如下图实现的简单 GRPO 训练代码。
因此强化学习训练无需考虑的很神奇，如果不考虑效率直接用 pytorch 手动撸或 ai 生成一个小模型的 rl 训练代码也就半天时间。
def train_step():
# 1. Model and optimizer model = transformers.AutoModelForCausalLM.from_pretrained(「Qwen/Qwen2.5-7B」) optimizer = optim.Adam(model.parameters(), lr=1e-5) # 2. Data prompts, answers = prepare_data() options = {"n": 8} # 3. Generation and advantage generations = model.generate(prompts, **options) grpo_scores = calculate_varifiable_rewards(prompts, answers) # 4. Train loss = calculate_gradient_policy(generations, grpo_scores) loss.backward() optimizer.step()
optimizer.zero_grad()3、关于训练侧更新了 actor 模型的权重后如何将新的模型权重从训练引擎传递给推理引擎
这一部分涉及的问题在于训练侧的模型切分方案与推理侧的模型切分方案不一致，而模型如果比较大的话权重的传输也是不小的时延。当前比较简单的方案是直接调用 sglang 或者 vllm 的 fast full 接口，例如 slime 中代码
HTTPS://GitHub.com/THUDM/slime/blob/main/slime/backends/fsdp_utils/update_weight_utils.py#L223AReaL 中代码
HTTPS://GitHub.com/inclusionAI/AReaL/blob/main/areal/core/remote_inf_engine.py#L1025从实现的角度来说也比较好理解。感兴趣可以看下面说明：
比如训练引擎使用 FSDPv2，推理引擎使用 sglang，则在初始化时会对于训练和推理进行 GPU 资源分配，以及传入切分规则（dp、tp、sp 等），FSDPv2 通过 device mesh 完成模型的切分。sglang 则将切分后的模型权重加载到各 rank，每个 rank 会记录自己负责的模型权重的元数据。
当 FSDPv2 训练引擎完成一轮训练产生新的模型权重后，会从 FSDP 的 torch.DTensor 转成 torch.Tensor，每个训练 rank 会将数据广播到推理的 rank，推理的 rank 会根据 sglang 初始化时记录的元数据判断这部分权重是否保留，如果保留直接将模型权重存入到原模型权重指针地址处，覆盖掉旧的模型权重。如果不保留直接丢掉，最终完成全部推理 rank 的权重更新。
当然这部分会有很多 trick，如果直接由训练的 rank 广播给每个推理的 rank，则通信的开销会很大，一般的常用的 trick 是训练侧会先进行 all-gather，将权重分桶（按层或按容量）在每个 node 的 rank0 上去广播给推理引擎（slime 的实现）。
而上面的 AReaL 代码是使用了分桶传输，这样可以降低通信消耗。verl 中当前的方案比较一般，既没有 all-gather，也没有分桶。另外sglang和verl都实现了router功能，直接发给router，由router转发给各rank的方案也是一个主流方案。
HTTPS://GitHub.com/volcengine/verl/blob/main/verl/workers/rollout/sglang_rollout/http_server_engine.py#L3504、训练引擎与推理引擎存在 gap 的问题
这里的 gap 有两种，介绍之前需要先说一下 RL 流程，RL 训练需要先将指令发送给推理引擎进行 rollout，rollout 得出每个序列轨迹。
如果是 on policy 的 RL 训练本应该直接使用 rollout 的轨迹来计算优势，进而计算目标函数来进行梯度回传。但当前的训推引擎是分离的，sglang 和 vllm 这种推理引擎自己实现的 CUDA 算子以及存在的各种优化，包括不限于（KV 量化、算子融合、模型编译等）。
另外也可能训推异构导致硬件计算精度等原因会使得推理引擎得出的序列轨迹里每个 token 的 logits 与训练引擎相同序列轨迹的 logits 存在差异，这种差异会使得原本是 on policy 的训练退化成 off policy 的 RL 训练。关于这个 gap 问题多篇论文和博客都有讨论The AI workspace that works for you[5]。
解决的方法其实也比较传统，既然推理引擎和训练引擎的分布存在差异，那直接使用重要性采样来在推理数据分布中拟合训练引擎数据的分布。也有的优化在这个重要性采样上加上 clip，防止二者差异过大。也有的 trick 是提前通过数据分布计算出来这个比值，在真实训练时加上，这样不必重新将轨迹内容放入训练引擎 prefill 重算了。
如果是 off policy 的 RL 训练则本来就应该计算重要性采样，也就是 rollout 需要记录轨迹的 logits，在训练模型上进行 prefill 获得该轨迹在当前策略模型上的 logits 再去做重要性采样，这样做出的重要性采样既包含不同版本间策略模型训推分布的差异，也包含训推框架之间的差异。
基于上面的这个思想，推理引擎其实就可以使用量化推理，反正无论如何都要计算训推差异重要性采样，那使用 fp8 或者 4bit 量化更快推理岂不美哉。
实际上我们知道 PPO 中的重要性采样是需要被裁剪的，如果重要性采样过大，也就是数据差异太大会容易造成训练的不稳定，而一旦该数据被 clip 掉则就不在有梯度回传（不清楚的看 PPO 的求导公式）。
所以推理引擎不能一味的追求推理速度而造成输出分布的失真。fp8 或许还可以使用，4bit 量化推理目前还没有广泛使用，关键就在于 4bit 量化推理带来的分布差异会有些高，很容易被裁剪。所以没有任何精度损耗且推理提效的推测解码成了推理引擎的新宠，目前各 RL 训练框架都已经适配或正在适配推理引擎的推测解码。
上面只提到了 RL 训推的第一个 gap，从第一个 gap 可以知道 rollout 出的数据需要在推理引擎重新 prefill 来计算重要性采样，这样就引发了第二个 gap，即 rollout 出的序列对应的 token 分布与重新 prefill 进行 tokenizer 编码后对应的 token 分布不一致。
举个例子，如果推理引擎 rollout 得到的序列为:我喜欢吃西红柿。输出的 token 分布为：[我，喜欢，吃，西红柿]，但是这个训练在训练引擎 prefill 编码时就很可能编码吃：[我喜欢，吃西，红柿]。
token 分布都不一致了还怎么去计算重要性采样。所以可以看到所有的 RL 训练框架在 rollout 返回时会同步返回输出的 token ids，直接将 token ids 输入给训练引擎，避免二次编码的问题。
5、环境的适配以及奖励的管理
我在调研这几款 RL 框架时尤其注意其 agentic RL 训练的支持，对于外部环境的接入模式，以及奖励的计算方式，毕竟有的奖励是动作粒度从环境中得到的，也有的奖励是对于整个轨迹的。
在 verl 中的 agent 多轮训练代码逻辑[6]在这里的设计是判断 agent 的状态来选择不同的函数句柄，比如 agent 多轮执行过程中可能需要人去输入新的内容，也有的是只与环境进行交互，代码逻辑如下图：
这种交互方式实际上涵盖了一般的 agent 多轮的状态，比如执行完 self._handle_generating_state 后，也就是推理引擎输出了内容，会根据输出内容是否解析出 action 执行 function call，是否达到最大交互次数来更新 state 的状态进入下一个循环。
而在 self._handle_processing_tools_state 中，也就是动作给环境执行的函数中是通过 self._call_tool[7]来对这个动作输出 observation。
也就是说 verl 当前版本其实还是以工具的视角来进行 agent 多轮训练，并且处理流程很多都写死了，只能在模型输出的结果里去与工具交互，而真实复杂的环境交互可能需要多次交互，且每个 rollout 中的环境未必一致，verl 当前的 agent loop 相对有些僵化。
而在 AReaL 和 slime 中设计就相对巧妙一些，在 slime 中可以通过--rollout-function-path 参数可以传递自定义的函数给 rollout[8] self.generate_rollout 就是外部传入的自定义的 rollout 工作流。
在 AReaL 中则需要自定义 workflow[9] 基类中设定了子类必须实现的函数。
在 example 中可以看见很多自定义 workflow 示例，例如
HTTPS://GitHub.com/inclusionAI/AReaL/blob/main/examples/tir/tir_workflow.py中内容，虽然在代码实际调用的是使用 workflow 中的 arun_episode 方法，但是这个类实例化时构造函数里是可以做很多工作的，比如初始化环境等，arun_episode 方法也可以实现自定义复杂的环境交互逻辑。
综合来说所有 RL 框架中环境交互的部分都是异步实现的，这一点毫无争议，不可能每一个样本都阻塞线程。
6、异步训练的处理方案
这部分就直接拿 AReaL 来说吧 ，我个人感觉 AReaL 的异步方案是当前主流 RL 训练框架里比较成熟的，包括 verl 也专门 pr 了 recipe[10] 来实现异步训练。实现上与 AReaL 大差不差，还有一些其他方案（可以看 verl 的 recipe 上 readme），代码实现上也是大同小异。核心思想就是我们熟悉的不能再熟悉的生产者和消费者关系。推理引擎做 rollout 相当于生产者，训练引擎需要数据相当于消费者。
同步 RL 与异步 RL 的示意图直接截了 AReaL 论文中的图，其实没什么好说的，从图中就可以看到同步方案会存在很多 bubble，且推理时存在训练资源浪费，训练时存在推理资源浪费。异步 RL 会交替异步进行，每完成一轮就进行一次模型权重更新。
对于生产者和消费者的关系模式借用 verl 中图：
rollout 出的数据会放在一个消息队列中，这个管理队列相当于 replay buffer，当数据达到一定 batch size 后训练引擎会从这个消息队列中获取数据来进行训练，相反如果消息队列中数据不足则训练引擎等待数据生成。需要注意一个参数：staleness。
这个参数控制着数据是否需要丢弃，考虑现实情况，有一个任务需要 rollout 非常久，当这个任务 rollout 完成时训练引擎已经完成了多次模型权重更新，那这个任务的轨迹是之前模型推理出的，如果使用这个轨迹进行训练哪怕有重要性采样也容易被裁剪，从而导致最后没有梯度。
也就是说 staleness 控制着 rollout 数据不能偏离最新模型分布太久，一般设为 1-2，很早的数据就丢弃掉，因为对训练意义不大。staleness 是如何实现数据控制的，也很简单，每一个 rollout 轨迹都有一个版本号，如果版本号与当前最新模型的版本号差距大于 staleness，则从消息队列中丢弃。
AReaL 中的实现要更复杂很多，
AReaL 中这部分代码
HTTPS://GitHub.com/inclusionAI/AReaL/blob/main/areal/core/workflow_executor.py
HTTPS://GitHub.com/inclusionAI/AReaL/blob/main/areal/core/async_task_runner.py
staleness 管理代码：HTTPS://GitHub.com/inclusionAI/AReaL/blob/main/areal/core/staleness_manager.py在 AReaL 中共涉及到 4 个队列，2 个无界队列_pending_inputs 和_pending_results，2 个有界队列 input_queue 和 output_queue。共 4 个线程参与，分别是主线程、事件循环线程、生产者线程和消费者线程。
数据流向是先流入到_pending_inputs 队列，这一步由主线程完成，在流入 input_queue 队列，这一步由生产者线程完成，rollout 管理器从 input_queue 中取数据并执行后将结果存入 output_queue，这一步由事件循环线程完成，最后从 output_queue 放入_pending_results，这一步由消费者线程完成。再从_pending_results 中取结果给训练引擎，这一步由主线程完成。
之所以这么复杂一部分是便于 staleness 进行管理，也考虑到实际执行的 rollout 同时处理数据的能力（input_queue 容量代表同时 rollout 的数量），防止大批量数据同时传递给 rollout 后。另外这种方案也便于下面讨论的 partial rollout 管理。
7、只依靠异步训练并不能很好的解决长尾问题带来的资源浪费和效率低下
还需要一个技术方案：partial rollout，这个方案和异步 RL 训练基本上同时出现，也是 AReaL 论文中核心创新方案之一，目前也是基本上支持异步 RL 训练的框架都已经实现，示意图如下。
在上图中可以看到，当 rollout 产生 1 个 batch 数据（这里是 4）后训练引擎异步开始训练，当训练引擎完成训练时需要将新的模型权重传递给推理引擎，但这时推理引擎还在进行推理任务，partial rollout 的含义就是对正在 rollout 过程中的任务进行截断，保留已经 rollout 完成的那部分数据，暂停推理引擎的使用，开始从训练 rank 广播新的模型权重给推理 rank 进行模型参数更新，这个过程中训练引擎不受影响继续异步训练。
当推理引擎完成参数更新后继续对之前截断的任务进行 rollout，也就是说这部分任务 rollout 轨迹前部分是旧策略模型生成的，后部分是新策略模型生成的。AReaL 中 input_queue 是进行 rollout 的任务，当被截断时连带已经生成的轨迹放入_pending_inputs 队列的队头位置。
以上是阅读修改RL训练框架代码后获得的一些启发，下面是一些关于RL训练的思考
1、老生常谈的RL算法问题
当前的LLM的RL算法习惯分为两类，序列级奖励算法和token级奖励算法，前者有GRPO、DAPO、REINFORCE等算法，后者有Decoupled PPO、REINFORCE++等。
这里不一一介绍，根本上都是PPO算法的变体。区别就是对整个轨迹每个token相同的奖励值还是不同的奖励值。LLM是以token为动作粒度进行优化的，如果将奖励放在序列维度肯定无法做到精细训练，而放到token粒度又很难，原因在于很难有一个客观合理的奖励方案去对序列里每个token做奖励（反向KL散度的模型蒸馏是一个不错的方案，但教师模型很难获取），token粒度太小了。
实际上我们llm实际执行的动作粒度是多个token组成，具体是由业务环境决定的，所以如果想做到领域RL最优是否也需要在业务场景的动作粒度上进行奖励才好？这一点存疑，等待验证。
另外RL训练是否也需要分阶段训练比较好，比如一开始进行序列级RL训练，先不管中间过程是否摆烂，保证最后结果的正确性。再进行细粒度的RL训练，无论业务动作粒度还是token粒度去调优推理的中间过程？还是直接同时关注序列和每个token奖励更好？同样等待验证。
2、RL奖励和环境
就像karpathy说的，现在RL成功与否的关键在于环境和奖励，环境不说了，就是纯工程优化的问题，奖励的设置是行业研究的热门，主流方案还是llm as judge或者agent as judge，只不过用了很多提示词trick。
比如在提示词中划分出严格的打分维度，让多个闭源模型组成评审团，不让llm或者agent打分而是排序等（又感觉回到了rlhf时代）。但根本上仍无法避免reward hacking的问题，为每个任务设置校验规则又无法scaling。只能靠时间去慢慢磨，慢慢的把数据收集好训练单独奖励模型或者一点点的做校验规则。
最后总结一下这几个RL框架，说实话verl和AReaL代码写的很工程化，但读起来是真费劲，封装太多，上手难度比较高。
相比slime代码很简洁，流程明确，我一开始奔着朱子霖大佬去看到slime，奈何当时slime刚开始适配FSDP，megatron又不支持vl模型，我是vl模型多轮训练的场景，更倾向于异步RL训练，需要尽快实现一个demo，只是粗读了slime代码感觉异步训练这块写的还不是很成熟才跳到verl。
但verl的rollout流程太僵化，不适用于我的环境，因为在环境工具调用前我需要从数据中获取一些状态内容发送给环境来让环境初始化，侵入式修改verl又带来额外工作量，因此又转向AReaL。
AReaL代码是真的难读，一个函数高达5-6次的调用，但不得不佩服代码质量是真的高。
想简单入门的推荐看RL2
https://github.com/ChenmienTan/RL2代码逻辑简单，很容易理清基本逻辑，值得阅读。
引用链接
[1] DataProto : HTTPS://GitHub.com/volcengine/verl/blob/main/verl/protocol.py#L329
[2] 前者的实现: https://GitHub.com/volcengine/verl/blob/main/verl/experimental/agent_loop/agent_loop.py[3] 使用的后者: https://GitHub.com/volcengine/verl/recipe/fully_async_policy[4] single_controller: HTTPS://GitHub.com/volcengine/verl/blob/main/verl/single_controller/ray/base.py#L328
[5] The AI workspace that works for you: https://fengyao.notion.site/off-policy-rl[6] agent 多轮训练代码逻辑: HTTPS://GitHub.com/volcengine/verl/blob/main/verl/experimental/agent_loop/tool_agent_loop.py#L120
[7] self._call_tool: HTTPS://GitHub.com/volcengine/verl/blob/main/verl/experimental/agent_loop/tool_agent_loop.py#L433
[8] rollout: HTTPS://GitHub.com/THUDM/slime/blob/main/slime/ray/rollout.py#L154
[9] 自定义 workflow: HTTPS://GitHub.com/inclusionAI/AReaL/blob/main/areal/api/workflow_api.py#L12
[10] recipe: HTTPS://GitHub.com/szrlee/verl/tree/yingru/rollout_correction/recipe/fully_async_policy
....
#理解 RL学习的本质！
最近看了几篇关于RL学习的论文，发现这几篇研究存在着一些内在联系，综合起来看，也许有助于我们理解RL学习方法的本质。
破除迷信 Does RLVR enable LLMs to self-improve？
第一篇文章是最近备受关注的一篇论文，来自清华的LEAP实验室，在今年的NeurIPS拿下了全满分，获得最佳论文奖：
https://arxiv.org/abs/2504.13837这篇论文开宗明义提出了一个问题：RL学习真的能让LLM获得超越基础模型的推理能力吗？
研究结论很确切，不能。论文用实验证明，RLVR后模型的能力完全在基础模型的能力范围内，只是搜索效率提高了，能更高效地找到问题的解。而基础模型不能解决的问题，RLVR的模型一样不能解决。
证明的方式就是用pass@K（生成 K次结果，只要有一次通过就算通过）的评估方式来比较RL模型和基模的表现。论文发现，在 @1的时候，RL模型的表现都会好于基模，但是随着K的增大，和基模的表现越来越接近，直到在K较大时RL被基模超越。
而且这个结论对于各种RL方法（PPO/GRPO等），在各种评估测试集（数学、代码、视觉推理），各种模型大小上面都适用。
，时长00:14
Base VS RL on pass@k
之所以用pass@K的评估方式，是因为这个研究并不是为了测量模型的实际性能，而是为了衡量模型内在能力的边界（boundary）。事实证明，RLVR并没有真正拓展这个边界，而只是在边界内高效寻找到了解决问题的路径而已。RL同时收窄了推理路径的范围（coverage），所以在K较大时，反而没有基础模型的表现更好。
更进一步分析模型的精确度分布，我们发现RL的模型呈现两极分化的特征：在高精确度上特别集中，而在低精确度上的表现不如基模，精确度为零的概率反而较高。
RL训练后的模型就像是一个严重偏科的学生，会做的题目都能打满分，但是对于不会做的题目，猜对的概率还不如普通的学生。
对于两种模型表现的比对可以进一步证明上面的结论：有很多题目RL没有解决，但是基模能解决；但是反过来，基模不能解决，RL能解决的题目几乎不存在（下表中第三行，百分比接近于零）。
与RL学习不同，Distillation学习（SFT）方式可以拓展模型的能力，让模型学会解决原来不能解决的问题：
RL学习这种限制的主要原因被认为是在语言广阔的探索空间中，预训练先验（prior）存在“双刃剑”效应。虽然先验使强化学习训练变得可行，但它也限制了探索，因为任何偏离都可能导致低奖励输出。因此，强化学习算法会强化先验内的解决方案，而不是发现其外的创新路径。
这篇文章只是验证了一个假设，并没有否定RL学习方法本身的价值。基础模型和RL模型的对比，就像是通才（generalist）和专才（specialist）的对比，在解决具体领域问题的时候，往往还是专才能堪大用，我们也会容忍专才的偏执和狭窄的视野。
当然，文章最后也提出，也许我们能找到一种训练方法，平衡模型的exploration和exploitation，让模型在提高效果的同时，不收窄探索的范围。
更新：经评论区小伙伴提醒，有其他论文提出了貌似完全相反的结论：
https://arxiv.org/pdf/2509.25123看来这个课题还远远没有定论。用一个capability来概括LLM能学习的能力也许过于泛化，可能我们需要一个细化的capability taxonomy，做更加科学的Ablation研究和分类实验。
探究原因 - The Path Not Taken
为什么RL训练会有这样的效果呢？另一篇来自Meta的论文也许给出了解释：
https://arxiv.org/abs/2511.08567z z研究者认为，RL训练有一个特征，参数更新高度局部化。文章把它称为model-conditioned optimization bias:
For a fixed pretrained model, updates consistently localize to model-preferred parameter regions, remain highly consistent across runs, and are largely invariant to datasets and RL recipes.
文章用两个很形象的图来表示了这个特征：SFT训练的过程就像是越野，走的路径百无禁忌，可以爬山下谷；而RL训练的过程像是带着一个指南针，按照这个指南针的指引，在相对平坦的地面上谨小慎微地前行。
这个指南针，或者说这个optimization bias是从哪里来的呢？作者提出了一个“三重门”的理论：
Gate I: On-Policy RL Imposes a One-Step KL Leash
RL学习会限制每一步更新的KL分布，让它接近模型的原有分布。就像给探索戴了一个狗链（leash），每一步都不会走太远，向着更高奖励的方向小步前进。
Gate II: Model Geometry Determines Where a KL-Bounded Step Goes
一个经过预训练的模型，它的参数空间会有一些结构化的几何特征，会有一些高曲度的方向。可以直观地把它理解为探索空间的主山脉、深峡谷的走向。
而RL训练的更新，会尽量避开这些高曲度方向的更新，采用尽量沿principal angle的方向更新。从参数矩阵的角度说，矩阵的主向量和特征值都会大体保持原样。
Gate III: Precision Acts as a Lens Revealing the Compass
这重门的意思是，在偏离主向量的方向上并不是没有更新，但是更新的幅度很小。这就导致低精度的参数表示，比如bfloat16，就会起到一个过滤器的作用，把这些幅度很小的更新直接归零。
作者也在这里澄清了一个广为流传的误解：RL产生的更新非常稀疏（sparse）。实际上RL更新的参数并不少，只是一些小更新被参数的表示精度抹平了：
RLVR exhibits a persistent, model-conditioned optimization bias in where updates land—highly consistent across runs and largely invariant to datasets and RL recipes. The observed sparsity is a superficial readout of this bias, amplified by bf16 precision.
关于这三重门的数学解释，请参见论文，这里不展开了。
通过观察训练后参数空间的变化，作者得出了以下结论：
- • RLVR Preserves Spectral Geometry, While SFT Distorts It
- • RLVR Avoids Principal Weights, While SFT Targets Them
- • RLVR Relies on Model Geometry, Disrupting Geometry Destroys the Bias
- • RLVR signatures persist in agentic tasks and RLHF
作者认为，现有的一些RL训练方法，比如PiSSA，没有考虑到RL存在这种参数更新的特征，所以效果不好。我们应该可以设计一些适用于RL的参数更新方法，比如冻结主要权重，而更新“非主要、低幅度的权重。”我们可能需要研究一些"RL-native, geometry-aware" 的算法，来适配RL学习的这种特征。
这项研究使我们从‘黑箱’视角转向对RL如何学习的‘白箱’理解。RL这种“循规蹈矩”的特点，就大体上解释了第一篇论文中“RL为什么没有真正提高模型能力”的问题。
灾难性遗忘 - 没有免费的午餐？
读到这你可能会问，既然RL不能真正提高模型的能力，而SFT可以，那我们为什么不用SFT方式来做所有的训练呢？这就不得不提到灾难性遗忘的问题。
RL's razor这篇论文指出，SFT训练会导致严重的灾难性遗忘，而RL训练却不会。
https://arxiv.org/abs/2509.04259关于这一篇论文，我在另一篇文章中已经有解读，在此不再赘述：持续学习和灾难性遗忘[1]
把这几篇论文的研究结论联系起来看，我脑中想到了一个问题：学习新技能和避免灾难性遗忘会不会是鱼与熊掌，不可兼得？我们看这个表格：
也许学习新能力和避免遗忘之间，存在表中所展现的互斥性。如果是这样，只能说天下没有免费的午餐，只能在两者之间做权衡（tradeoff），看具体场景选择训练方案了。
但也许原理上并不存在这样的互斥性，也许我们可以二者兼得。最近Thinking Machines的一篇文章就是这个方向的一个探索。
他们的方法叫做On-policy Distillation，可理解为RL方法和SFT的一种“杂交”，原理上是一种RL训练，但过程又类似于SFT的蒸馏训练：Thinking Machines新文章：On-Policy Distillation[2]
真希望第一篇论文的研究者能用他们的实验方法来测试一下TML的On-policy Distillation，看看结果如何。如果OPD方法能：
- • 通过蒸馏扩展模型的能力边界
- • 高效寻找推理路径
- • 避免灾难性遗忘
那恐怕我们就找到了LLM模型训练的一个灵丹妙药，能治百病，又没有副作用。说不定，就此开启了模型进化的新纪元呢。
引用链接
[1] 持续学习和灾难性遗忘: https://zhuanlan.zhihu.com/p/1969174968651736270[2]
Thinking Machines新文章：On-Policy Distillation: https://www.zhihu.com/pin/1968462515513062544
....
#HTTM
比FastVGGT更快更强！博世新作HTTM：7倍加速VGGT，三维重建精度无损，无需训练！
HTTM 针对 VGGT 全局注意力冗余，提出「头级时空块合并 + 自适应离群值过滤」免训练策略，把 Q/K/V 序列长度压到 1/7，A100 上实测 7× 加速且重建精度不降，可一次完成 500+ 帧 4D 重建。
论文信息
标题：HTTM: Head-wise Temporal Token Merging for Faster VGGT
作者：Weitian Wang, Lukas Meiner, Rai Shubham, Cecilia De La Parra, Akash Kumar
机构：Robert Bosch GmbH , Ruhr University Bochum
原文链接：https://arxiv.org/abs/2511.21317
导读
基于视觉几何的Transformer模型（VGGT）在3D场景重建领域取得了重大突破，它是首个能够一次性直接推断出所有关键3D参数的模型——包括相机姿态、物体深度以及密集的几何结构。然而，这种联合推理机制需要使用全局注意力层，这些层会对来自所有视角的数据元素进行全连接式的注意力计算。对于那些需要处理长序列数据的大型场景而言，这种机制会带来显著的延迟瓶颈。
在本文中，我们提出了一种无需额外训练的3D数据元素合并方法——头部级时间合并技术（HTTM），旨在加速VGGT的运行速度。现有的数据合并方法会均匀地将数据元素分配到各个注意力头中，导致各层输出中的数据元素完全相同，从而削弱了模型的表征能力。HTTM通过以多头为单位进行数据合并，有效保持了特征数据的唯一性；同时，该方法还能利用头部层面所体现的空间关联性与时间对应关系，从而在保持较高合并效率的同时降低计算成本。实验结果表明，在基于GPU的推理环境中，HTTM的运行速度可提升至原来的7倍，且性能损失几乎可以忽略不计。
01 效果展示
HTTM 形成时空融合块，能够同时考虑连续帧中相邻词项。这一设计通过利用时间连贯性和空间冗余性来实现高效词项融合。在保持相同融合比例的情况下，HTTM 将融合成本降低了 4.58倍。
不同时间帧数下 FastVGGT、VGGT、未使用首帧锚定的 HTTM 以及使用首帧锚定的 HTTM*(标记为 HTTM*) 在相机姿态估计性能方面的对比。颜色表示与真实相机轨迹的偏差情况。
02 引言
视觉几何基础变换器（Visual Geometry Grounded Transformer，VGGT）是最近提出的一种前馈变换器模型，该模型可直接从可变数量的视图推断场景的所有关键3D属性。通过这种直接推断方式，VGGT能够超越当前最先进的方法，同时避免了成本高昂的视觉几何后处理方法，这标志着3D计算机视觉领域的一项重要突破。
VGGT的关键设计之一是其交替的帧级注意力与全局注意力机制。在全局注意力层中，来自不同视图的所有标记（token）都参与多头注意力计算。实际上，即使对于小场景，这种方法也会导致标记序列极长（超过20k个标记）。因此，全局注意力层成为VGGT的主要延迟瓶颈，限制了其在中大型场景重建中的效率。
受长上下文大语言模型（Large Language Models，LLMs）和视觉语言模型（Vision Language Models，VLMs）发展的启发，许多方法被提出，以降低长序列注意力层的计算成本。这些方法主要是基于稀疏性的方法，旨在利用LLMs和VLMs中注意力分数往往集中在少量标记上的特点。
然而，如图2所示，与LLM中的注意力层相比，VGGT的全局注意力层的稀疏度较低，这限制了这些方法应用于VGGT时在延迟改善方面的效果。
另一方面，VGGT中出现的窄注意力分布模式有利于基于相似度的方法，因为注意力权重分布在不同标记间变化不大。ToMe提出了一系列基于特征相似度合并冗余标记以加速变换器的方法。在此基础上，许多扩展方法被提出，证明了基于相似度的标记缩减方法无需重新训练即可有效提高效率。
尽管有几种方法是为VGGT设计的，或者可以适配VGGT，但它们未能识别VGGT特有的头部级相似度模式，并且在长输入序列上表现出较高的合并开销。
为此，我们提出了HTTM（Head-wise Temporal Token Merging，头部级时间标记合并），这是一种专为VGGT全局注意力层设计的无需训练的标记合并方法。HTTM通过以下三项关键创新解决了现有方法的局限性：
- 头部级合并，允许每个注意力头独立合并标记，保留头部特定信息，避免拼接后特征坍缩；
- 块级标记合并，与全局匹配策略相比，降低了标记匹配成本；
- 时间重排序，将标记重新组织为时空块，以利用空间冗余和时间一致性，在固定合并块大小下提高合并质量；
- 头部级自适应异常值过滤，在全球预算下跨所有头部过滤异常值。这些设计使HTTM在保持高重建质量的同时实现了显著的加速。
03 主要贡献
我们的主要贡献总结如下：
- 我们对VGGT中的标记合并进行了系统探索，揭示了其在空间和时间维度上独特的相似度模式。通过广泛分析，我们发现时间相关性表现出更高的冗余度，这激发了对时间感知合并策略的需求。
- 针对现有标记合并方法的主要计算开销，我们分析了合并成本与合并质量之间的权衡，并提出了一种结合时间重排序的块级合并策略，该策略通过对齐空间和时间相关标记，在保持合并质量的同时大幅降低了合并成本。
- 我们引入了一种自适应异常值过滤机制，该机制在全球预算下跨所有注意力头过滤异常值，为异常值密度较高的头部分配更多预算，以最小开销提高整体质量。
04 方法
空间与时间标记相似度 图3展示了来自NRGBD数据集的一个场景中前4帧所有查询标记之间的余弦相似度模式。可以观察到，高相似度分数集中在主对角线和副对角线附近。主对角线附近的高相似度分数表明，每个标记主要关注其局部邻域内的相似标记。另一方面，副对角线附近的高相似度分数具有帧长的偏移量，这意味着不同帧的相同区域也表现出高相似度。我们将在接下来的段落中探讨这些模式背后的原因。
旋转位置嵌入（Rotary Position Embedding，RoPE）效应 图3中明显的周期性模式源于VGGT的每个注意力层应用旋转位置嵌入（RoPE）的方式。与BERT或Stable Diffusion等模型不同，这些模型仅在输入时添加一次固定的位置嵌入，而VGGT在每一层都重新应用RoPE，这增强了整个网络中的位置编码效果。在全局注意力层中，来自所有视图的标记相互交互，RoPE能够区分单个帧，增强空间独特性并减少远处位置之间的相似度。
在帧注意力层中，RoPE对每一帧的应用方式相同，因此跨帧的对应区域共享相似的位置编码，这诱导了相邻帧相同空间区域之间的时间一致性。更多相关讨论见附录。
输入相似度效应 尽管RoPE诱导了周期性相似度模式，但帧内和帧间相似度也对此现象有所贡献。如图4所示，我们对两张具有不同像素块视觉冗余度的图像进行单帧重建。在深层全局注意力层（第14层）中，来自高冗余输入帧（一面墙）的查询标记比来自具有杂乱物体的低冗余输入帧的查询标记表现出更强的空间相似度。
在图5中，我们可视化了来自三个30帧重建的8个连续帧的深层（第14层）查询标记的相似度，这些重建具有不同程度的视觉连续性。当输入帧在时间上连续且高度相似时，会出现强烈的副对角线响应，这表明相邻帧中对应于相同空间区域的标记表现出高相似度。随着重叠度降低，这些副对角线结构变得更弱且更分散，反映了标记之间时间对应关系的减弱。
这些发现表明，观察到的相似度模式源于两个相互交织的因素：RoPE的架构效应，它在全局注意力层中强制空间独特性，在帧注意力层中强制时间对应性；以及输入级相似度，它在网络中传播并增强了空间对应区域之间的相关性。它们共同塑造了VGGT中标记独特的时空相似度结构。因此，我们设计了一种合并策略，能够同时考虑空间局部性和时间对应性。
05 实验结果
本报告的重建结果使用了VGGT的深度和相机头，因为正如原始VGGT论文所述，它们能产生更好的结果。对于基线方法，我们使用了在FastVGGT中实现的显存高效的VGGT，记为VGGT*，该方法在推理过程中丢弃未使用的中间输出，且不影响重建质量。所有推理均在配备FlashAttention的Nvidia A100上使用Bfloat16进行。
如表1所示，我们在7Scenes和NRGBD数据集上对每10帧采样关键帧的3D重建性能进行了评估。与基线VGGT相比，HTTM在保持相当性能的同时，Q/K/V序列长度大幅缩短。与FastVGGT相比，HTTM在NRGBD上超越了FastVGGT，并在7Scenes上使用更短的序列长度（更高的合并比例）取得了相当的结果。如图9所示，HTTM保留了原始VGGT重建结果的更多高保真细节。
06 总结 & 未来工作
在本研究中，我们提出了HTTM，这是一种无需训练的标记合并方法，可加速VGGT的推理。我们对VGGT中的相似度模式进行了系统探索，并分析了现有方法在合并效率和表示能力方面的主要局限性。为了利用VGGT在头部嵌入层面的标记的空间局部性和时间对应性，我们引入了一种时间重排序和头部级自适应异常值过滤技术，该技术帮助HTTM高效合并标记，同时保留其独特性，从而在长输入序列上实现高达7倍的显著加速，且性能无下降。对更多实验结果和文章细节感兴趣的读者，可以阅读一下论文原文~
....
#HiMo-CLIP
中国联通提出HiMo-CLIP：长文本图像检索新SOTA！让大模型读懂“语义层级”
HiMo-CLIP 在表征层用 Batch-PCA 动态抽「唯一记忆点」构建语义层级，并用单调性对比损失强制图文对齐随描述增详而单调上升，1M 训练数据即在长/短文本检索双双 SOTA，刷新组合语义理解纪录。
描述得越详细，图文匹配的分数就应该越高——这听起来是常识，但现有的CLIP模型却做不到。
近日，中国联通数据科学与人工智能研究院团队在AAAI 2026 (Oral)上发表最新成果HiMo-CLIP。该工作通过巧妙的建模“语义层级”与“语义单调性”，在不改变编码器结构的前提下，让模型自动捕捉当前语境下的“语义差异点”，大幅刷新了长文本检索任务的SOTA记录。
论文题目：HiMo-CLIP: Modeling Semantic Hierarchy and Monotonicity in Vision-Language Alignment. AAAI 2026 Oral.
文章：https://arxiv.org/abs/2511.06653
开源地址：github.com/UnicomAI/HiMo-CLIP
01 痛点：当描述变长，CLIP却“懵”了
在多模态检索任务中，我们通常期望：文字描述越详细、越完整，其与对应图像的匹配度（对齐分数）应该越高。这被称为“语义单调性”。
然而，现实很骨感。现有的模型（包括专门针对长文本优化的Long-CLIP等）往往将文本视为扁平的序列，忽略了语言内在的层级结构。
如下图所示，对于同一张“白色福特F250皮卡”的图片，当文本从简短的“正面视图...”扩展到包含“超大轮胎”、“车轴可见”、“有色车窗”等详细描述的长文本时，许多SOTA模型的对齐分数反而下降了！
这种现象表明，模型未能有效处理长文本中的“语义层级”，导致细节信息淹没了核心语义，或者无法在复杂的上下文中捕捉到最具区分度的特征。
图1. 随着描述变长，现有模型分数下降，而HiMo-CLIP（绿勾）稳步提升
#02 方法：HiMo-CLIP框架
为了解决上述问题，研究团队提出了一种即插即用的表征级框架HiMo-CLIP。它包含两个核心组件：层级分解模块（Hierarchical Decomposition，HiDe）和单调性感知对比损失（Monotonicity-aware Contrastive Loss，MoLo）。
图2. HiMo-CLIP框架概览。（1）HiDe模块利用Batch内的PCA动态提取语义成分；（2）MoLo损失函数强制模型同时对齐“全量文本”和“语义成分”，实现单调性约束
2.1 HiDe：谁是重点？由“邻居”决定
在真实场景中，数据样本往往是高度复杂的。如图2所示，我们面对的不是简单的＂红苹果＂和＂绿苹果＂，而是像＂一只金毛猎犬在公园草坪上追赶红盘＂、＂盘子里放着鲜红的草莓、黄香蕉和深紫色的葡萄＂这样高度复杂的场景。传统的固定分词法在这种复杂度下根本抓不住重点。HiMo－CLIP换了个思路，它像一个玩＂大家来找茬＂的高手：通过观察Batch内的＂邻居＂，动态提取最具区分度的特征。
长文本特征 ：代表＂整句话＂的意思。 动态子语义 ：代表＂这句话里最独特的记忆点＂。 举个栗子：假设长文本是：＂一只戴着墨镜的柯基在沙滩上奔跑＂。 场景A（混在风景照里）：如果这一批次（Batch）的其他图片都是＂沙滩排球＂、＂海边游艇＂。PCA一分析，发现＂沙滩＂大家都有，不稀奇。唯独＂柯基＂是独一份。
此时， 自动代表＂柯基（物体）＂。 场景B（混在狗群里）：如果这一批次的其他图片都是＂草地上的柯基＂、＂沙发上的柯基＂。PCA一分析，发现＂柯基＂遍地都是，也没法区分。唯独＂戴墨镜＂和＂在沙滩＂是特例。
此时， 自动代表＂戴墨镜／沙滩（属性／环境）＂。 这就是HiDe最聪明的地方：它不需要人教它什么是重点，而是利用统计学原理，自适应地提取出那个最具辨识度的＂特征指纹＂，自动构建语义层级。
2.2 MoLo：既要顾全大局，又要抓住细节
找到了重点 ，怎么用呢？作者设计了MoLo，强制模型＂两手抓＂：
MoLo ，feat ，feat
第一手：InfoNCE（ ，feat）是传统的图文匹配，保证图片和＂整句话＂（ ）对齐。
第二手：InfoNCE（ ，feat）强制图片特征还要特别像那个提取出来的＂独特记忆点＂（ ）。
这个操作看似简单，实则一石三乌：
- 自动摘要： 就是特征空间里的＂高维短文本＂，省去了人工构造短文本的偏差。
- 更懂机器的逻辑：人类定义的关键词（如名词）未必是模型分类的最佳依据（可能是纹理或形状）。PCA完全在特征空间操作，提取的是机器认为的差异点，消除了人类语言和机器理解之间的隔阂（Gap）。
- 数据效率高：你只需要喂给模型长文本，它在训练中顺便学会了如何拆解长句、提取关键词。训练的是长文本，却白捡了短文本的匹配能力。
03 实验：长短通吃，全面SOTA
研究团队在多个经典的长文本、短文本检索基准，以及自行构造的深度层级数据集HiMo-Docci上进行了广泛实验。
表1
表2
在长文本（表1）和短文本（表2）检索任务上，HiMo-CLIP展现出了显著的优势。值得注意的是，HiMo-CLIP仅使用了1M（一百万）的训练数据，就击败了使用100M甚至10B数据的方法（如LoTLIP，SigLIP等）。
为了充分评估长文本的对齐效果，研究团队构建了HiMo-Docci数据集，同时还提出了HiMo@K指标，以量化模型是否真的“读懂”了层级。结果显示，HiMo-CLIP保持了极高的单调性相关系数（0.88），远超对比方法。
图3. HiMo-Docci上的单调性可视化
随着文本描述逐渐完整（1→5），HiMo-CLIP的分数（红线）呈现出完美的上升趋势，而其他模型的分数则波动剧烈，甚至下降。
进一步的，为了探究各个组件对性能的具体贡献，研究团队进行了详尽的消融实验，揭示了HiDe与MoLo协同工作的内在机理。感兴趣的朋友可到原文了解更多细节～
04 总结
HiMo-CLIP通过显式建模语义层级和单调性，成功解决了视觉-语言对齐中长期被忽视的结构化问题。
- 创新点：首次提出利用In-batch PCA进行动态语义分解（HiDe）和单调性损失（MoLo）。
- 效果：在长文本、组合性文本检索上取得SOTA，同时兼顾短文本性能。
- 意义：这一工作不仅提升了检索精度，更让多模态模型的对齐机制更加符合人类的认知逻辑，为未来更复杂的多模态理解任务指明了方向。
....
魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。
更多推荐
22
0- 0
已为社区贡献77条内容
所有评论(0)