我自己的原文哦~                    https://blog.51cto.com/whaosoft/12464014

#finetune后的模型参数，还可以继续怎么玩？

通过对不同下游任务的task vectors进行简单的计算，组合得到的新参数（构成一个线性子空间），可以扩展出更多的使用场景。

看到了一篇很有意思的paper，文章对预训练和finetune之后的模型参数之差（task vector = 两个weight按位相减）做了分析，发现了一些奇妙的用法：通过对不同下游任务的task vectors进行简单的计算，组合得到的新参数（构成一个线性子空间），可以扩展出更多的使用场景，如：功能抑制（遗忘），多任务学习，迁移学习。

Editing Models with Task Arithmetic：https://arxiv.org/abs/2212.04089

以下, 我们记task vector 为

我们可以构造一系列新的参数

1. 反向即遗忘

也就是

显然，这可以让模型的效果变差，有多差呢？

作者用CLIP分别在八个下游任务上finetune，然后反向，并观察在ImageNet上zero-shot效果的变化。

同时，还对比了另外两种做法，一是把梯度下降改成梯度上升，也就是loss最大化，另一种是改变 τ\tau\tau 的方向，每一层随机一个方向（长度不变）。

结果非常amazing啊，取反后在目标任务上的平均效果有了明显的下降，但在ImageNet上只相对下降了不到5%，也就是实现了部分的遗忘（精准控制）。

上面是一个负面的用例，那这种方法有什么好的使用场景呢？文中也给了一个在text generation中降低文本恶意的例子，就好比先让模型学会骂人，再跟它说，刚才学的都是不对的。

2. 相加即多任务

把多个任务的task vector求加权和（，文中只做了简单相加）之后，可以得到能用于更多场景的组合vector。当然，和直接多任务最优化的效果还是有差异的（接近8个点），但好处是方便。

这些任务本身相关性不高。

而当任务之间有一定的相关性时，可能会够起到1+1>2的效果。

可以算是以finetune为抓手，沉淀多套模型，以参数赋能打出的组合拳。

3. Task Analogy

最有意思的部分来了。众所周知，以word2vec为代表的（静态）词向量当年能够大火的原因之一是word analogy，也就是那个著名的例子：king - man + woman = queen。同理，如果两个任务有一定的共性，那么，是否可以通过构造特色特色来实现任务的迁移呢？

文中给了两个例子

1.

其中yelp和amazon是两个域，sent指的是情感分类任务，lm是在各自语料上finetune的语言模型。

2.

其中lion indoors（室内的狮子）的样本很少甚至没有，但是可以通过组合outdoor lion和indoor dog得到。

4. 分析

文中没有给出理论上的分析，这里仅做一些猜测。

文中使用的预训练模型基本都是transformer-based，可以粗略地理解为模式匹配+kv记忆。finetune强化了下游任务的模式敏感度（QK相似度提升），补充/加强了任务相关的特有记忆（FFN的近似查找敏感度提升)。这一部分增量是有一定的可加性的（激活函数会salient）。所以可以认为，task vector相当于特定任务神经元连接的加强，反之，也就是减弱，甚至抑制。而对于多任务场景，任务之间只要没有明显的冲突（夹角大于90度），相加不会有明显问题。

因为，所以，新的参数可以看成是原模型和finetune之后参数的插值。finetune时learning rate的选择对task vector的效果有一定影响。如果太大，新参数可能会跳到另一个局部最优点附近，而此时，并不能保证和pretrain model之间没有barrier（也就是不一定有mode connectivity），插值的参数可能不再是最优的。

文中只考虑了来自于同一个预训练模型的task vector之间的组合，那是否可以结合weight alignment一类的方法组合来自不同上游的vector呢？

task vector的可插拔性是它最大的优点，也就是说达到了一定程度上的模块化，可以组合出不同类型的下游任务，比如：结合1,3，如果只有英文toxic data，是否可以快速组合出低恶意的中文model呢。

同样是模型参数，为什么word embedding和entity embedding不能直接相加？因为task vector不是直接的参数，只是差分。

最后，再从实用的角度来说，虽然相比于直接finetune还是有一定差距，但是作为迁移任务的初始化参数可能是一个不错的选择。

....

#xxx

....

#xxx

....

#WMDD&GUARD

当数据蒸馏遇上几何与鲁棒性：两个视角下的突破

WMDD用Wasserstein重心保几何结构，GUARD用曲率正则降锐度，双双刷新ImageNet蒸馏上限：10 IPC准确率破60%，鲁棒精度涨近4倍，代码已开源。

在深度学习迈向超大规模的今天，数据集蒸馏（Dataset Distillation）提供了一个令人着迷的可能：能否用极少的合成样本，浓缩出一个庞大数据集的精华？这个问题的价值不言而喻——训练成本的指数级下降、隐私保护的天然优势、以及对数据本质的更深刻理解。然而，真正让蒸馏数据"好用"的标准是什么？我们认为至少包括两个维度：一是合成数据能否忠实地捕捉原始数据的内在结构，二是基于它训练的模型能否在真实环境的各种扰动下保持稳定。围绕这两个问题， ICCV 2025 论文 WMDD 和 AAAI 2025 论文 GUARD 分别给出了答案。

WMDD: ​​https://github.com/Liu-Hy/WMDD  ​​​GUARD: ​​https://github.com/yumozi/GUARD​​

01 几何的视角：WMDD 如何让合成数据"看起来对"

论文：Dataset Distillation via the Wasserstein Metric（ICCV 2025）｜arXiv：https://arxiv.org/abs/2311.18531

传统的分布匹配方法常常依赖 Maximum Mean Discrepancy（MMD）来衡量真实数据与合成数据的差异。这个选择看似自然，但 MMD 有一个微妙的局限：它对核函数的选择极为敏感，而且在实际应用中，为了计算效率，很多方法只能退化到对齐特征的均值——这相当于用线性核的 MMD。问题在于，仅仅对齐均值远远不够：两个均值相同的分布可能在形状、方差、甚至拓扑结构上天差地别。

WMDD 的核心洞察来自最优传输理论。Wasserstein 距离不仅仅是一个度量，它背后承载着"如何以最小代价把一堆沙子搬运成另一堆"的几何直觉。这种"搬运"的视角天然地保留了分布的空间结构：它关心每一份质量如何被映射，而不是简单地比较全局统计量。基于 Wasserstein 距离定义的重心（barycenter），也因此具备了一种独特的"保形"能力——它能在多个分布之间找到一个既接近所有输入、又保持各自几何特征的中心表示。

在二维玩具实验中，这种差异一目了然：当我们试图找到圆环和交叉两类分布的"中心"时，KL 散度和 MMD 给出的重心更像是两者的机械混合，而 Wasserstein 重心则通过最优传输在几何上做了自然的插值，依然能看出原始形状的影子。这正是数据蒸馏需要的——我们希望合成数据不是原始数据的"模糊平均"，而是能够体现其内在结构的精炼代表。

图 1  在二维空间中，不同度量下的重心呈现出迥异的特性。Wasserstein 重心通过最优传输实现几何插值，更好地保留了原始分布的结构信息

WMDD 的实现策略兼顾了理论优雅与工程可行性。我们将合成过程置于预训练分类器的特征空间：对每个类别，先提取所有真实样本在倒数第二层的特征表示，然后在这个空间中计算 Wasserstein 重心。这个重心不是单点，而是由少量带权"锚点"组成的离散分布，每个锚点及其权重共同刻画了类内的多样性。接下来，我们通过梯度下降优化原始图像空间中的合成样本，使其在特征空间中的表示逼近这些锚点。

一个关键的技术细节是 Per-Class BatchNorm（PCBN）正则化。以往的方法倾向于在全局层面对齐 BN 统计量，但这会让不同类别的样本在优化时相互干扰——毕竟各类别的分布特性本就不同。PCBN 改为在每个类别内部独立对齐均值和方差，这样既利用了预训练模型的先验知识，又避免了类间的"拉扯"，让每个类的合成数据能更纯粹地接近其真实分布。

图 2  WMDD 的核心流程：在特征空间计算各类的 Wasserstein 重心，然后通过特征匹配损失和 PCBN 正则共同优化原始图像，使合成数据在保持类内结构的同时贴近真实分布

计算效率方面，WMDD 采用了一种交替优化策略：固定锚点位置时优化权重，固定权重时优化位置。这种交替迭代在理论上收敛到局部最优，而在实践中，仅需 10 次左右的迭代就能产生高质量的重心表示。更重要的是，与 MMD 的 O(n²) 复杂度不同，我们的 Wasserstein 重心计算对原始数据量呈线性复杂度，这使得 WMDD 能够扩展到 ImageNet-1K 这样的大规模数据集。

实验结果印证了我们的理论直觉。在 ImageNette、Tiny-ImageNet 和 ImageNet-1K 上，WMDD 在几乎所有 IPC（images per class）设置下都达到了当前最佳水平。以 ImageNet-1K 的 100 IPC 为例，我们达到了 60.7% 的 top-1 准确率，已经非常接近在全量数据上训练的 ResNet-18（63.1%）。更令人惊喜的是跨架构泛化能力：用 ResNet-18 蒸馏的数据，在 ResNet-50/101 和 ViT-Tiny/Small 上都能取得稳定的性能，这说明 WMDD 捕捉的是数据的本质几何特性，而非特定架构的偏好。

图 3  WMDD 在 ImageNet-1K 上蒸馏的合成图像（10 IPC）。尽管每类只有 10 张图像，但它们都呈现出该类别的典型视觉特征，可解释性强

消融实验进一步验证了设计选择的合理性。将特征匹配目标从交叉熵改为 Wasserstein 重心匹配，带来了一致的性能提升；引入 PCBN 后，类内特征分布的多样性得到了更好的保持，避免了"模式坍塌"。我们还尝试了 Sliced Wasserstein 作为加速方案，结果显示精度几乎无损，证明收益确实来自 Wasserstein 的几何本质。

从方法论的角度看，WMDD 将数据蒸馏问题重新定位为"在几何意义上寻找分布的最优表示"。这种视角不仅在技术上行之有效，也为未来的研究打开了新的空间：能否在联合空间 P(X,Y) 上直接蒸馏，从而同时学习类间关系？能否将重心表示与生成模型结合，进一步提升合成数据的多样性？这些都是值得探索的方向。

02 鲁棒性的视角：GUARD 如何让模型"站得稳"

论文：Towards Adversarially Robust Dataset Distillation by Curvature Regularization（AAAI 2025）｜arXiv：https://arxiv.org/abs/2403.10045

数据蒸馏的另一个重要挑战是鲁棒性。在真实应用中，模型常常面临各种输入扰动——无论是恶意构造的对抗样本，还是自然环境中的噪声。如果蒸馏数据只能训练出"脆弱"的模型，那么它的实用价值将大打折扣。

直觉上，最简单的做法是在蒸馏过程中引入对抗训练：用对抗样本来训练教师模型，然后基于这个"强化过"的教师来蒸馏数据。然而，我们的初步实验显示，这种做法往往事与愿违：干净样本上的准确率大幅下降，而鲁棒性的提升却不稳定。问题的根源在于，对抗训练会显著改变样本的语义，而在蒸馏数据量极其有限的情况下，这种扰动会被放大，导致合成数据偏离原始分布。

GUARD 采取了一个更本质的策略：与其在外层堆叠对抗训练的循环，不如直接优化模型的损失景观，使其在真实数据附近更加平滑。这个想法建立在一个理论观察之上：对抗损失的上界主要由损失函数关于输入的最大曲率（即 Hessian 矩阵的最大特征值）决定。换句话说，如果损失景观在某个方向上"陡峭"，那么沿这个方向的小扰动就容易造成损失的剧烈变化——这正是对抗脆弱性的根源。

理论分析表明，当蒸馏数据与真实数据在特征空间足够接近时，两者的对抗损失上界仅相差一个与分布偏差成正比的常数项。这意味着，只要我们在真实数据上平滑损失景观，这种鲁棒性就能自然地转移到蒸馏数据上。这个结论为我们的方法提供了理论保障：我们不需要在蒸馏数据上显式地进行对抗训练，只需在真实数据上降低曲率，就能获得可迁移的鲁棒性。

实现上，我们利用了一个经验观察：神经网络损失函数的梯度方向，往往与 Hessian 最大特征值对应的特征向量高度一致。基于这个观察，我们构造了一个高效的曲率正则项：在归一化梯度方向上做小步扰动，然后最小化扰动前后梯度的差异。这个正则项只需要两次前向传播和梯度计算，几乎不增加额外开销，却能有效降低损失景观的"尖锐性"。

我们将 GUARD 集成到 SRe2L 方法的"squeeze"阶段：在该阶段，原本是在真实数据上训练一个标准分类器；现在我们将训练损失替换为"标准损失 + 曲率正则"，从而得到一个损失景观更平滑的模型。随后的"recover"阶段不变，从这个平滑模型中恢复出合成数据。整个过程相比标准蒸馏仅增加了约 0.3% 的计算时间，而对抗训练则需要数倍的开销。

实验结果令人鼓舞。在 ImageNette、Tiny-ImageNet 和 ImageNet-1K 上，GUARD 在各种攻击下都显著提升了鲁棒性。以 ImageNette 10 IPC 为例，面对 AutoAttack 这种强攻击，准确率从 4.99% 跃升到 19.69%，干净准确率也从 42.42% 提升到 57.93%。这种"鲁棒性与准确性双赢"的现象，恰恰印证了我们的理论：平滑的损失景观不仅有助于抵抗对抗扰动，也让模型在蒸馏数据上学到了更稳定、更泛化的特征。

图 4  GUARD 在 ImageNet-1K 上蒸馏的样本（1 IPC）。这些图像混合了类内多个物体的视觉元素，体现了蒸馏过程对鲁棒特征的提取

一个有趣的发现是，曲率正则的作用与 IPC 的大小有关。在极低的 IPC（如 1 或 10）下，曲率正则往往能同时大幅提升干净精度和鲁棒性；而当 IPC 增大时，过强的正则可能抑制模型学习细粒度的判别特征，此时需要适当降低正则强度。这似乎暗示着一个更深层的权衡：合成数据越少，模型的"可学复杂度"就应该越低，而曲率正则恰好提供了一种控制这种复杂度的手段。

GUARD 的另一个优势是普适性。作为一种损失景观正则化方法，它可以无缝集成到几乎任何基于教师模型的蒸馏方法中。我们在 DC、CDA 等不同范式上的实验都显示，加入 GUARD 后，干净精度和鲁棒性均得到提升。这种"即插即用"的特性，使得 GUARD 不仅是一个独立的方法，更是一个可以广泛应用的技术模块。

需要强调的是，GUARD 并不声称提供形式化的全局鲁棒性保证——我们的理论假设（如损失函数的局部凸性）在实践中只是近似成立。但从实用角度看，GUARD 以极小的代价，在大规模数据集和强攻击场景下都取得了可观的鲁棒性提升，这本身就说明了方法的有效性和价值。

03 两个视角的交汇

WMDD 和 GUARD 分别从几何和鲁棒性两个维度推进了数据蒸馏的前沿，但它们的底层逻辑是相通的：都试图让合成数据学到的不是表面的统计规律，而是更深层、更稳定的结构特征。WMDD 通过 Wasserstein 几何捕捉分布的形状，GUARD 通过曲率正则塑造平滑的决策边界，两者殊途同归，都在追求"少而精"的数据表示。

展望未来，这两个方向还有很多值得探索的空间。对 WMDD 而言，能否将 Wasserstein 框架扩展到更复杂的联合分布 P(X,Y)，从而同时学习特征和标签的关系？能否将重心表示与生成模型（如扩散模型）结合，进一步提升合成数据的多样性和真实感？对 GUARD 而言，能否设计自适应的曲率调节机制，根据 IPC 和任务自动调整正则强度？能否将曲率正则推广到分布外泛化和多模态学习的场景？

更宏观地看，数据蒸馏本身正在成为理解深度学习的一个重要窗口。通过极致地压缩数据，我们被迫思考：哪些信息是真正必要的？如何用最少的样本"编码"一个数据集的本质？这些问题不仅关乎工程效率，也触及了学习理论的核心。我们希望 WMDD 和 GUARD 能为这个领域贡献一些新的视角，也期待更多研究者加入到这场"少而强"的探索中来。

....

#SAOD~

目标检测创新：一种基于区域的半监督方法，部分标签即可 ,研究表明，当训练数据缺少注释（即注释稀疏的数据）时，目标检测器的性能会显着下降。

论文地址：https://arxiv.org/pdf/2201.04620v1.pdf

研究表明，当训练数据缺少注释（即注释稀疏的数据）时，目标检测器的性能会显着下降。现在的方法侧重于以伪标签的形式或通过在训练期间重新加权未标记框的梯度来解决缺失真实标注的问题。

在这项工作中，研究者重新审视了稀疏注释目标检测的公式。研究者观察到稀疏注释的目标检测可以被认为是区域级别的半监督目标检测问题。基于这一见解，研究者们提出了一种基于区域的半监督算法，该算法可以自动识别包含未标记前景对象的区域。然后，提出的算法以不同方式处理标记和未标记的前景区域，这是半监督方法中的常见做法。为了评估所提出方法的有效性，对PASCAL-VOC和COCO数据集上稀疏注释方法常用的五个分割进行了详尽的实验，并实现了最先进的性能。除此之外，还表明新提出的方法在标准半监督设置上实现了竞争性能，证明了新方法的强度和广泛适用性。

传统的目标检测方法假设训练数据集被详尽地标记。这种检测器的性能对标记数据的质量很敏感。用于训练目标检测器的数据中的噪声可能是由于噪声类标签或不正确/丢失的边界框而产生的。在这项工作中，研究者处理了缺少类标签和边界框注释的更难的问题，即稀疏注释的存在。稀疏注释目标检测（SAOD）是在训练数据中存在缺失注释的情况下提高目标检测鲁棒性的问题。这个问题在当前至关重要，因为获取众多数据集可能既昂贵又费力。另一种方法是使用计算机辅助协议来收集注释。然而，这些方法受到嘈杂/缺失标签的影响。因此，必须调整当前的目标检测器来解决稀疏注释的问题。

问题的症结在于训练期间分配标签的方式。稀疏注释减少了真正的正样本并将假负样本引入训练，从而降低了网络性能。虽然这过于简单化了，但它可以更好地了解正在处理的问题。研究者建立在一个简单的观察之上，即SAOD是区域级别的半监督目标检测(SSOD)。然而，未标记的数据，在我们的例子中是包含前景对象的区域，是先验未知的，必须被识别。因此，SSOD方法不能直接应用于SAOD，因为当前的方法假设一个已知的未标记集以及一个详尽标记的训练集。同样，最近提出的SAOD方法在训练期间丢弃所有没有单个注释的图像，并且不能像SSOD方法那样真正利用未标记数据的力量。分别在上图的第1行和第2行中说明了SSOD和SAOD。

假设稀疏注释的目标检测方法应该是一个很好的半监督学习器，因为SSOD中的未标记图像可以被视为SAOD的缺失注释。我们在上图的第3行展示了这个公式。

所提出的方法如下图所示，由一个标准的骨干网络组成，该网络从图像的原始视图和增强视图中提取特征。

一个通用的RPN将骨干网络提取的特征连接起来，生成一组通用的候选区域。候选区域b可以属于三个组之一，即：

• 标记区域b∈ Bl
• 未标记区域b∈Bul
• 背景区域b∈ Bbg

对于给定的一组真实标注，可以自动识别第一组，即标记区域。然后问题就变成了从背景区域中识别和分离第二组，即未标记区域。给定所有候选区域，pseudo-positive mining(PPM)步骤识别未标记区域并将它们与背景区域分离。受半监督方法的启发，标记和未标记区域分别受到监督和非监督损失的监督。我们在下面详细描述每个阶段。

Feature Extraction

给定图像I，计算表示为A(I)的I的增强版本。在这项工作中，我们使用随机对比度、亮度、饱和度、光照和边界框以级联方式擦除以生成A(I)。 一个检测器骨干网络用于分别从I和A(I)中提取两个特征fo和fa。

Common RPN (C-RPN)

传统的两阶段目标检测器使用区域提议网络（RPN）来生成感兴趣区域（ROI）。fo和fa这两个特征使用RPN生成两组不同的ROI。对两组ROI进行操作增加了识别标记区域、未标记区域和背景区域的难度，同时增加了处理时间。此外，对于关联，必须执行匹配算法，如基于IoU)分数的Kuhn-Munkres算法，以获得输入图像的一组通用标记、未标记和背景框。由于不完美的匹配，此过程可能会很嘈杂。为了避免这种情况，提出了一种连接fo和fa以获得ROI的C-RPN。

Pseudo Positive Mining

给定来自C-RPN的ROI，下一步是从标记区域和背景区域中识别未标记区域。基于我们的观察，即使在使用稀疏注释进行训练时，RPN也可以可靠地区分前景和背景区域，我们广泛依赖RPN的分数来识别未标记区域。

首先，根据可用的Ground Truth，所有分配为正的ROI都从C-RPN的输出中删除。接下来，所有具有大于阈值（本工作中为0.5和IoU小于阈值（本工作中为0.2）且具有任何GT的ROI都被视为未标记区域。剩余的ROI分配给负样本。我们稍后会证明这个简单的步骤可以提高RPN的召回率。请注意，由于阈值不同，一些未标记的区域可能会被错误地分配给负样本。这些地区将在后续阶段得到照顾。

Losses

在pseudo positive mining步骤之后，来自C-RPN的ROI被分为标记、未标记和背景区域。首先，ROI池化层从特征fo中提取标记区域和背景区域的区域特征，然后将其馈送到检测头。检测头预测每个区域的类别概率和边界框。稀疏GT用于监督这些预测，方法是将交叉熵损失应用于标记和背景区域的分类，以及平滑L1用于标记区域的边界框回归：

最后，对未标记区域执行与类别无关的NMS，以删除导致Nu唯一区域的重复项。Nu未标记区域与fo和fa一起通过ROI池化层和检测头，分别获得fdo和fda。应用了如下所示的一致性正则化损失，它强制原始区域和增强区域的特征彼此一致。 

实验

Sparsely annotated object detection在COCO的结果

Sparsely annotated object detection在VOC结果

 将使用可用的GT（顶部）训练的“普通”模型的输出与使用新提出的方法训练的模型（底部）进行比较的定性结果。显示类别置信度分数大于0.9的预测。红色：人，青色：狗，紫色：马，黄色：时钟，绿色：停车标志，蓝色：停车计时器，紫色：长颈鹿，橙色：盆栽，黑色：冲浪板，深绿色：船。 

...

#HaBa~

带来一个蒸馏相关哦~~显著提升下游模型性能

将合成数据集分解为两个部分：数据幻觉器网络和基础数据。数据幻觉器网络将基础数据作为输入，输出幻觉图像（合成图像）。该方法得到的合成数据集在跨架构任务中比基准方法取得了精度10%的提升。

论文链接: https://openreview.net/pdf?id=luGXvawYWJ

代码链接: https://github.com/Huage001/DatasetFactorization

深度学习取得了巨大成功，训练一般需要大量的数据。存储、传输和数据集预处理成为大数据集使用的阻碍。另外发布原始数据可能会有隐私版权等问题。

数据集蒸馏（Dataset Distillation）是一种解决方案，通过蒸馏一个数据集形成一个只包含少量样本的合成数据集，同时训练成本显著降低。数据集蒸馏可以用于持续学习、神经网络架构搜索等领域。

最早提出的数据集蒸馏算法核心思想即优化合成数据集，在下游任务中最小化损失函数。DSA（ Dataset condensation with differentiable siamese augmentation）、GM（ Dataset condensation with gradient matching）、CS（Dataset condensation with contrastive signals）等方法提出匹配真实数据集和合成数据集的梯度信息的算法。MTT（Dataset distillation by matching training trajectories）指出由于跨多个步骤的误差累计，单次迭代的训练误差可能导致较差的性能，提出在真实数据集上匹配模型的长期动态训练过程。除了匹配梯度信息的方法，DM（Dataset condensation with distribution matching）提出了匹配数据集分布，具体方法是添加最大平均差异约束（ Maximum Mean Discrepancy，MMD）。

本文方法将合成数据集分解为两个部分：数据幻觉器网络（Data Hallucination Network）和基础数据（Bases）。数据幻觉器网络将基础数据作为输入，输出幻觉图像（合成图像）。在数据幻觉器网络训练过程中，本文考虑添加特殊设计的对比学习损失和一致性损失。本文方法得到的合成数据集在跨架构任务中比基准方法取得了精度10%的提升。

方法 

基与幻觉器 

先前数据集蒸馏方法中，为了在下游模型中输入和输出的形状保持一直，合成数据的形状需要与真实数据相同。由于幻觉器网络可以使用空间和通道变换，本文方法没有形状相同限制。 

对抗性对比约束

分解训练方法

与先前的数据集蒸馏方法训练范式类似，合成数据集按照迭代算法更新。每一个迭代周期，随机选取幻觉器和基，形成若干幻觉器-基组合。训练的损失函数包含知识蒸馏损失与一致性损失：

实验

与SOTA方法的比较结果。比较的方法包括核心集算法（Coreset）,数据集蒸馏方法（元学习方法DD、LD，训练匹配方法DC、DSA、DSA，分布匹配方法DM、CAFE）和本文方法Factorization。超参数，每一类合成样本数（IPC）[1，10，50]，本文的每一类基数量（BPC）[1，9，49]。

下图给出了实验结果。可以看出本文方法取得了最高的精度，在合成数据集样本数小于1%时性能差异最为显著。  

与不同合成数据集生成算法和不同卷积神经网络模型组合的比较实验。在AlexNet网络的实验中，本文的方法与MTT相比最高取得了17.57%的性能提升。 

不同类别是否共享幻觉器的Ablation实验。在相同的BPC条件下，较少的合成样本数情况下不共享幻觉器的方法（w/o share）可以获得更好的性能。较多的BPC情况下，不共享幻觉器方法不能获得更好的性能。主要原因：1）共享幻觉器方法可以获得数据集的全局信息。2）不共享幻觉器的方法给优化过程较大的负担 

 本文方法基和幻觉器生成图像的可视化如下：

 ....

#Single-Shot

不同特征尺度的不一致是基于特征金字塔的single-shot检测器的主要限制。这是自适应特征融合用于Single-Shot目标检测

链接: https://pan.baidu.com/s/1C_9AS3czjhpx_hffNAPRgg  密码: oow3

金字塔特征表示是解决目标检测中尺度变化挑战的常见做法。然而，不同特征尺度的不一致是基于特征金字塔的single-shot检测器的主要限制。在这项工作中，研究者提出了一种新颖的数据驱动的金字塔特征融合策略，称为自适应空间特征融合 (ASFF)。它学习了空间过滤冲突信息以抑制不一致性的方法，从而提高了特征的尺度不变性，并引入了free inference overhead。

借助ASFF策略和YOLOv3的可靠基线，在MS COCO数据集上实现了最佳速度-准确度权衡，60FPS时AP为38.1%，45FPS时AP为42.4%，29FPS时AP为 43.9%。

目标检测是各种下游视觉任务中最基本的组成部分之一。近年来，由于深度卷积神经网络(CNN)和注释良好的数据集的快速发展，目标检测器的性能得到了显着提高。然而，在大范围内处理多个对象仍然是一个具有挑战性的问题。为了实现尺度不变性，最近最先进的检测器构建了特征金字塔或多级特征塔。

尽管这些高级研究提供了更强大的特征金字塔，但它们仍然为尺度不变预测留下了空间。SNIP给出了一些证据，它采用尺度归一化方法，在多尺度图像金字塔的每个图像尺度上选择性地训练和推断适当大小的目标，具有多尺度测试的探测器，实现了基于金字塔特征的结果的进一步改进。然而，图像金字塔解决方案急剧增加了推理时间，这使得它们不适用于实际应用。

同时，与图像金字塔相比，特征金字塔的一个主要缺点是在不同尺度上的不一致，特别是对于single-shot检测器。具体来说，当检测具有特征金字塔的目标时，采用启发式引导特征选择：大实例通常与上层特征图相关联，小实例与下层特征图相关联。当一个对象在某一层的特征图中被分配并被视为正样本时，其他层的特征图中的相应区域被视为背景。因此，如果图像中同时包含小物体和大物体，则不同层次的特征之间的冲突往往会占据特征金字塔的主要部分。这种不一致会在训练期间干扰梯度计算，并降低特征金字塔的有效性。一些模型采用了几种尝试性的策略来处理这个问题。比如将相邻级别的特征图的相应区域设置为忽略区域（即零梯度），但这种缓解可能会增加相邻级别特征的较差预测。TridentNet创建了多个具有不同感受野的特定尺度分支，用于尺度感知训练和推理。它脱离了特征金字塔以避免不一致，但也错过了重用其更高分辨率的地图，从而限制了小实例的准确性。

新框架分析

新框架采用YOLOv3框架，因为它简单高效。在YOLOv3中，有两个主要组件：一个高效的骨干网（DarkNet-53）和一个三层的特征金字塔网络。

此外，许多研究表明，anchor-free pipeline通过更简单的设计有助于显着提高性能。为了更好地证明提出的ASFF方法的有效性，基于这些先进技术构建了一个比原点强得多的基线。

 Adaptively Spatial Feature Fusion

与以前使用元素总和或连接来集成多级特征的方法不同，关键思想是自适应地学习每个尺度的特征图融合的空间权重。该pipeline如上图所示，它由两个步骤组成：identically rescaling和adaptively fusing。

• Feature Resizing

由于YOLOv3中三个层次的特征具有不同的分辨率和不同的通道数，我们相应地修改了每个尺度的上采样和下采样策略。对于上采样，首先应用一个1×1的卷积层将特征的通道数压缩到第l级，然后分别通过插值来提升分辨率。对于1/2比率的下采样，我们只需使用步长为2的3×3卷积层来同时修改通道数和分辨率。对于1/4的比例，我们在2-stride卷积之前添加了一个2-stride最大池化层。

• Adaptive Fusion

令x表示从第n级调整到第l级的特征图上位置(i, j)处的特征向量。建议将相应级别l的特征融合如下：

实验对比及可视化

在COCO val-2017数据集上的比较

COCO val-2017上检测结果的可视化以及每个级别的学习权重标量图。在红色框中放大了第3级的热图，以便更好地可视化。

当一张图像具有多个不同大小的对象时，更多的定性示例。

...

#MRECG

解决量化误差振荡问题，让MobileNetv2的能力超过ResNet家族,这里说下PTQ中的振荡问题，为了解决振荡问题，作者提出了一种新的混合重构粒度（MRECG）方法，在具有2/4位的MobileNetV2中实现了58.49%的Top-1准确率，这大大超过了当前的SOTA方法。

训练后量化（PTQ）由于其数据隐私性和低计算成本，被广泛认为是实际中最有效的压缩方法之一。作者认为PTQ方法中存在一个被忽视的振荡问题。

在本文中主动探索并提出了一个理论证明，来解释为什么这样的问题在PTQ中是必不可少的。然后，试图通过引入一个原则性的、广义的理论框架来解决这个问题。特别是，首先公式化了PTQ中的振荡，并证明了问题是由模块容量的差异引起的。为此，作者定义了数据依赖和无数据情况下的模块容量（ModCap），其中相邻模块之间的差异用于测量振荡程度。然后通过选择Top-k差分来解决该问题，其中相应的模块被联合优化和量化。

大量实验表明，本文的方法成功地降低了性能下降，并推广到不同的神经网络和PTQ方法。例如，对于2/4位ResNet-50量化，本文的方法比以前最先进的方法高出1.9%。它在小模型量化上变得更重要，例如在MobileNetV2×0.5上比BRECQ方法高出6.61%。

深度神经网络（DNN）近年来迅速成为研究热点，在实践中被应用于各种场景。然而，随着DNN的发展，更好的模型性能通常与更深更宽网络的巨大资源消耗有关。与此同时，旨在在资源受限的场景中部署模型的神经网络压缩和加速研究领域正逐渐受到越来越多的关注，包括但不限于神经架构搜索、网络剪枝和量化。在这些方法中，量化提出了将浮点网络激活和权重转换为低bit整型，这能够加速推理或训练的速度，而性能几乎没有下降。

通常，网络量化方法分为量化感知训练（QAT）和训练后量化（PTQ）。前者通过量化微调来减少量化误差。尽管取得了显著的成果，但海量的数据需求和高昂的计算成本阻碍了DNN的普遍部署，尤其是在资源受限的设备上。因此，提出了PTQ来解决上述问题，该问题只需要少量或零校准数据来进行模型重建。由于没有量化训练的迭代过程，PTQ算法非常高效，通常在几分钟内获得和部署量化模型。然而，这种效率往往是以牺牲准确性为代价的。

PTQ通常在没有量化训练的情况下比全精度模型表现更差，尤其是在低位紧凑模型量化中。最近的一些算法试图解决这个问题。例如，Nagel等人通过量化前后损失函数的二阶泰勒展开构建新的优化函数，该函数引入了具有可学习参数的软量化，以实现自适应权重舍入。Li等人逐层改变逐块重建，并使用对角Fisher矩阵来近似Hessian矩阵，以保留更多信息。Wei等人发现，随机禁用激活量化的一些元素可以平滑量化权重的损失。

然而，作者观察到，在重建过程中，随着层或块的加深，上述所有方法都表现出不同程度的振荡，如图1的左侧子图1所示。作者认为，这个问题是至关重要的，并且在以前的PTQ方法中被忽视了。

在本文中，通过严格的数学定义和证明，回答了关于振荡问题的3个问题，如下所示：

1. 为什么PTQ会出现振荡？为了回答这个问题，作者首先定义了模拓扑同构，它在一定程度上放宽了模等价的限制。然后，给出了在模块拓扑同构条件下模块容量的定义。在这种情况下，作者可以证明，当后期模块的容量足够大时，重建损失将突破量化误差累积的影响并降低。相反，如果后面模块的容量小于前面模块的容量，则由于放大的量化误差累积效应，重建损失急剧增加。总体而言，作者证明了PTQ重建过程中损失的振荡是由模块容量的差异引起的；
2. 振荡将如何影响最终性能？通过随机采样大量混合重建粒度方案，观察到最终的重建误差与之前所有模块中最大的重建误差高度相关。换句话说，当振荡发生时，先前的模块显然具有较大的重建误差，从而导致PTQ的精度较差；
3. 如何解决PTQ中的振荡问题？由于振荡是由前后模块的不同容量引起的，作者提出了混合重构粒度（MRECG）方法，该方法可以联合优化发生振荡的模块。此外，本文的方法适用于无数据和依赖数据的场景，也兼容不同的PTQ方法。

总的来说，贡献如下：

1. 首次揭示了PTQ中的振荡问题，这在以前的算法中被忽略了。然而，作者发现，在PTQ的优化中，消除这种振荡是至关重要的。
2. 从理论上表明，这种振荡是由相邻模块的能力差异引起的。小的模块能力会加剧量化误差的累积效应，使损失迅速增加，而大的模块能力则会减少累积量化误差，使损失减少。
3. 为了解决振荡问题，作者提出了一种新的混合重构粒度（MRECG）方法，该方法利用损失度量和模块容量来优化数据依赖和无数据场景下的混合重构细粒度。前者以适度较高的开销找到全局最优，因此具有最佳性能。后者更有效，性能略有下降。
4. 在ImageNet中的各种压缩任务上验证了所提出的方法的有效性。特别是，在具有2/4位的MobileNetV2中实现了58.49%的Top-1准确率，这大大超过了当前的SOTA方法。此外，还证实了本文的算法确实消除了重建损失在不同模型上的振荡，使重建过程更加稳定。

量化

量化可以分为两类：量化感知训练（QAT）和训练后量化（PTQ）。QAT使用整个训练数据集进行量化训练，并通过网络的反向传播来更新梯度以消除量化误差。尽管QAT集成了各种训练方法以实现更高的准确性，但在某些数据隐私场景中，这一过程往往是资源密集型的，并且受到限制。本文的研究兴趣不在这个领域。

近年来，由于高效的模型部署和低数据依赖性的优势，PTQ越来越受到关注。由于不包括量化训练，PTQ算法通常使用小的校准数据集进行重建，通过优化任务损失的二阶泰勒展开项的近似值来获得更好的量化模型。

模块容量

一些常见参数会影响模块容量，例如滤波器的大小、权重参数的位宽和卷积组的数量。此外，一些研究表明，步长和剩余捷径也会影响模块容量。Kong等人表明，步长为2的卷积可以等效地被步长为1的卷积所取代。同时，替换卷积的滤波器大小大于原始卷积的滤波器尺寸，这意味着模块容量的增加。

提出的MobileNetV2包含深度卷积，它不包含通道之间的信息交换，因此它在某种程度上损害了模型性能。Liu等人认为，全精度残差结构的输入增加了量化模块的表示能力。

方法

在本节中，首先通过一个定理和推论证明了PTQ的振荡问题与模块容量高度相关。其次，构造了容量差异优化问题，并分别在依赖数据和无数据的情况下给出了两种解决方案。最后，分析了扩大校准数据的批量大小以减少期望近似误差，这表明边际效用有递减的趋势。

PTQ振荡问题

注意，忽略了AdaRound中的正则化项，这有助于收敛，因为它在每个模块优化后收敛到0。此外，为了简单起见，省略了BRECQ中的平方梯度尺度。如果2个模块具有相同数量的卷积层，并且所有相关联的卷积层具有相同的超参数，则它们被称为等效的。

量化中存在量化误差的累积效应，表现为网络中量化误差受前一层量化影响的增加趋势。由于PTQ不包含量化训练，这种累积效应在重建损失中更为明显。本文提出以下定理来证明PTQ中量化误差的累积效应会导致增量损失。

定理1

给定预先训练的模型和输入数据。如果2个相邻的模块是等效的，

补充材料中提供了详细的证明。定理1说明，在2个相邻模块相等的情况下，量化误差的累积会导致损耗的增加。

然而，由于一个或多个卷积超参数（额外的残差输入、kernel大小、通道、组、步长等）的差异，上述定理中的相邻模等价条件在实际场景中很难得到满足。

非等效模块将不可避免地导致模块容量的差异。众所周知，模块的参数数量和位宽会影响模块容量，其中这些超参数对模块容量的影响很容易量化。此外，在第2节中介绍了残差输入、卷积类型和卷积超参数都会影响模块容量，这些影响很难量化。因此，将模块拓扑同构的概念定义如下，这在一定程度上放宽了对模块等价的限制，同时使比较不同模块之间的容量成为可能。

定义1

（模块拓扑齐性）假设两个模块具有相同数量的卷积层。如果2个模块的相应卷积层的超参数除了kernel-size和通道之外是相同的，那么这两个模块在拓扑上是同构的。

然后，导出定理1的一个推论来解释为什么PTQ中会出现振荡。

推论1

假设两个相邻的模在拓扑上是同构的。如果后面模块的模块容量足够大，则损失将减小。相反，如果后一模块容量小于前一模块容量，则量化误差的累积效应会加剧。

补充材料中提供了详细的证明。根据推论1可以得出结论，PTQ在各种模型上的振荡问题是由相邻模块的容量差异过大引起的。

论文的逻辑/相关链：振荡性∝最大误差∝最终误差∝准确度

• 振荡∝最大误差：从图6和补充材料中的类似图来看，不同算法对应的损失分布振荡越严重，损失峰值就越大。也就是说，振荡的程度与最大误差呈正相关；
• 最大误差∝最终误差：此外，在图3中的观察结果表明，对于不同的模型，在不同的算法上，最大误差与最终误差呈正相关；
• 最终误差∝精度：理论上，通过根据BRECQ和Adaround对精度损失函数进行泰勒展开，可以得出与性能高度相关的最终重建误差；

从经验上讲，上述论文中进行的大量实验也证明了这一说法。总之，误差的振荡程度与精度呈正相关。论文中的图1也表明，降低振荡程度有利于精度。在下一节中将介绍如何通过优化模块容量差异来消除PTQ中的振荡。

混合重建粒度

第3.1节中分析的振荡问题表明，由于模块容量的差异导致的信息丢失最终会影响PTQ的性能。由于PTQ中没有量化训练过程，即使增加后续模块的模型容量，也无法恢复这种信息损失。因此，通过联合优化具有大容量差异的模块来平滑损失振荡，从而降低最终重建损失。

从定理1和推论1可以清楚地看出，后面模块的小容量将加剧量化误差的累积效应，从而急剧增加重建损失。相反，后面模块的大容量将减少损失，并增加后面模块中信息丢失的概率。因此，本文希望两个相邻模块的容量尽可能接近。基于容量度量（CM）为包含L个模块的模型构造容量差优化问题，如下所示，

具体如图2所示。根据ModCap度量获得的混合重建粒度方案在计算上是有效的，因为它不涉及重建。然而，一旦组合了一对相邻的模块，这个组合的模块就无法比较ModCap进行进一步的组合，因为它与相邻的模块在拓扑上不同构。因此，该优化方案只能获得混合重建粒度的局部最优解。

另一方面，根据推论1，ModCap差异与重建损失的差异呈正相关，可以将重建损失本身视为容量度量。该方案可以得到全局最优解，但需要进行PTQ重建才能获得重建损失，效率相对较低。

校准数据的Batch size

PTQ需要数据集的一小部分来进行量化参数的校准和模型重建。作者注意到，方程1包含平方Frobenius范数的期望。期望值表示随机变量的平均值，取采样批次的平均值来近似重建过程中的期望值。大数定律证明了当样本大小N趋于无穷大时。

实验表明，扩大校准数据的批量可以提高PTQ的准确性。这一趋势显示出边际效用的递减。具体而言，随着批量大小的增加，PTQ精度的提高速度减慢。详见第4.3节。

实验

ImageNet Classification

在各种模型上验证了本文的算法，包括不同规模的ResNet-18、ResNet-50和MobileNetV2。

如表1所示，本文算法在与不同比特配置相对应的广泛模型上以很大的优势优于其他方法。具体而言，在ResNet-18和2/4位的MobileNetV2上实现了66.18%和57.85%的Top-1准确率，分别比SOTA高1.52%和4.93%。

其次，本文的方法在低位显示出强大的优越性。例如，在MobileNetV2×0.75上，2/4位PTQ量化的精度增益显著高于4/4位（5.36%对1.61%）。振荡问题可能更为严重，因为低位会导致PTQ重建误差的大小增加。因此，在低位量化时平滑这种振荡对于PTQ优化过程至关重要。

此外，本文的方法在不同规模上对MobileNetV2进行了相当大的改进，这意味着模型大小不会限制算法的性能。作者还注意到本文的算法对MobileNetV2更有效。通过观察，MobileNetV2中的振荡问题比ResNet网络家族的振荡问题更严重。深度可分离卷积增加了模块容量的差异，从而使损失振荡的幅度更大。因此，本文的算法通过解决MobileNetV2中的振荡问题，实现了相当大的性能改进。

消融实验

1、帕累托最优

在不同规模的MobileNetV2上随机采样了大量混合重建粒度方案，并使用BRECQ算法使用4/4位PTQ对这些方案进行优化，以获得采样精度。在图4中绘制了这些方案的精度分布。

此外，还分别在MobileNetV2上标记了MRECG和BRECQ算法在不同尺度下的准确性。从图4中可以观察到MRECG在所有尺度上都比MobileNetV2有稳定的准确性提高。总体而言，MRECG在模型大小的限制下实现了Pareto最优状态。

2、Component Contribution

在这里分别研究了混合重建粒度和扩展批处理大小对准确性的贡献。将通过BRECQ量化为4/4位的0.5缩放的MobileNetV2作为基线。如表2所示，混合重建粒度和扩展批量大小的准确度分别提高了1.08%和0.74%。同时，这两种方法的结合进一步提高了模型的性能。

3、缩小扩大批量规模的边际效用

根据大数定律，当样本数量增加时，样本的平均值收敛于方程1中的期望值，从而产生较小的近似误差。然而，当样本大小足够大时，由于近似误差的减小而获得的精度增益可以忽略不计。换句话说，Batch size的扩大呈现出边际效用递减的趋势。

在图5中，对一些Batch size进行了随机采样，并通过BRECQ在0.5标度的MobileNetV2上获得了4/4比特的PTQ精度。证明了采样精度的中位数，以防止异常值的影响。作者注意到，当Batch size较小时，采样精度波动更大，这意味着较小Batch size的近似误差会产生较大的噪声。随着Batch size的扩大，这种情况有所缓和。此外，可以观察到中值精度的增加，然后趋于稳定，这意味着扩大Batch size可以为PTQ带来精度增益。同时，这种收益受到边际效用递减的制约。

4、损失分布

如图6所示，给出了不同算法的损失分布。从Adaround的分布可以看出，它具有最大的振荡幅度。因此，在模型的更深层次，Adaround的重建损失迅速增加。此外，BRECQ使用块重建进行PTQ优化，这在某种程度上缓解了损耗振荡问题，从而提高了性能。

混合重建粒度通过联合优化容量差异较大的相邻模块来平滑损耗振荡。可以看出，与Adaround和BRECQ相比，MRECG的损失变化更稳定。此外，当比较不同场景下的MRECG损失时，发现基于无数据场景获得的MRECG仍然具有较小的振幅损失振荡。作者认为，这种适度的振荡与ModCap MRECG只能联合优化两个相邻模块的事实有关，这只能实现局部最优。相比之下，MRECG具有最平滑的损耗曲线。然而，这种全局最优是以延长获得量化模型的时间为代价的。

...

#SPARSE DETR

DETR家族又一成员,具有可学习稀疏性的高效端到端目标检测

DETR是第一个使用transformer编码器-解码器架构的端到端对象检测器，在高分辨率特征图上展示了具有竞争力的性能但计算效率低。随后的工作Deformable DETR通过将密集注意力替换为可变形注意力来提高DETR的效率，从而实现了10倍的收敛速度和性能提升。

DETRDeformable DETR使用多尺度特征来改善性能，然而，与DETR相比，encoder token的数量增加了20倍，并且编码器注意力的计算成本仍然是瓶颈。在我们的初步实验中，我们观察到即使只更新了一部分encoder token，检测性能也几乎不会恶化。受此观察的启发，研究者提出了稀疏DETR，它选择性地仅更新预期被解码器引用的标记，从而帮助模型有效地检测目标。

此外，研究者展示了在编码器中对所选标记应用辅助检测损失可以提高性能，同时最大限度地减少计算开销。我们验证了即使在COCO数据集上只有10%的encoder token，Sparse DETR也比可变形DETR实现了更好的性能。尽管只有encoder token被稀疏化，但与可变形DETR相比，总计算成本降低了38%，每秒帧数 (FPS) 增加了42%。 

近年来，我们见证了深度学习中目标检测的巨大进步和成功。已经提出了多种目标检测方法，但现有算法将与GT进行正匹配作为一种启发式方法，需要对近似重复预测进行非极大值抑制 (NMS) 后处理。最近Carion等人通过基于集合的目标消除了对NMS后处理的需要，引入了完全端到端的检测器DETR。训练目标采用匈牙利算法设计，既考虑分类成本，又考虑回归成本，并获得极具竞争力的性能。但是，DETR无法使用多尺度特征，例如特征金字塔网络，这些特征常用于目标检测，以提高对小目标的检测。主要原因是通过添加Transformer 架构增加了内存使用和计算。因此，它对小物体的检测能力比较差。

为了解决这个问题，有人提出了一种受可变形卷积 (deformable convolution) 启发的可变形注意力，并通过注意力模块中的关键稀疏化将二次复杂度降低为线性复杂度。通过使用可变形注意力，可变形DETR解决了DETR收敛速度慢和复杂度高的问题，使编码器能够使用多尺度特征作为输入，显着提高了检测小物体的性能。然而，使用多尺度特征作为编码器输入会使要处理的token量增加约20倍。最终，尽管对相同的token长度进行了有效的计算，但整体复杂性再次增加，使得模型推理甚至比普通的DETR更慢。

(a) DETR中的密集注意力需要二次复杂度。(b) Deformable DETR使用密钥稀疏化，因此具有线性复杂度。(c) Sparse DETR进一步使用查询稀疏化。Sparse DETR中的Attention也采用线性复杂度，但比Deformable DETR轻得多。 

上图说明了如何通过预测二值化解码器交叉注意力图(DAM)来学习评分网络，其中橙色虚线箭头表示反向传播路径。左边部分展示了编码器中的前向/反向传播，右边部分展示了如何构建DAM来学习评分网络。 

稀疏DETR引入了三个附加组件：(a)评分网络，(b)编码器中的辅助头，以及(c)为解码器选择前k个token的辅助头。稀疏DETR使用评分网络测量编码器token的显着性，并选择top-ρ%的token，在上图中称为(1)。在仅精炼编码器块中选定的token后，辅助头从编码器输出中选择前k个token，用作解码器对象查询。这个过程在上图中被称为(2)。此外，我们注意到每个编码器块中的附加辅助磁头在提高性能方面发挥着关键作用。仅将稀疏编码器token传递给编码器辅助头以提高效率。编码器和解码器中的所有辅助头都经过Hungarian损失训练，如Deformable DETR中所述。 

实验及可视化

....

#最大似然估计和最大后验估

深入浅出最大似然估计和最大后验估。

TLDR (or the take away)

• 频率学派 - Frequentist - Maximum Likelihood Estimation (MLE，最大似然估计)
• 贝叶斯学派 - Bayesian - Maximum A Posteriori (MAP，最大后验估计)

概述

有时候和别人聊天，对方会说自己有很多机器学习经验，深入一聊发现，对方竟然对MLE和MAP一知半解，至少在我看来，这位同学的机器学习基础并不扎实。难道在这个深度学习盛行的年代，不少同学都只注重调参数？

现代机器学习的终极问题都会转化为解目标函数的优化问题，MLE和MAP是生成这个函数的很基本的思想，因此我们对二者的认知是非常重要的。这次就和大家认真聊一聊MLE和MAP这两种estimator。

两大学派的争论

抽象一点来讲，频率学派和贝叶斯学派对世界的认知有本质不同：频率学派认为世界是确定的，有一个本体，这个本体的真值是不变的，我们的目标就是要找到这个真值或真值所在的范围；而贝叶斯学派认为世界是不确定的，人们对世界先有一个预判，而后通过观测数据对这个预判做调整，我们的目标是要找到最优的描述这个世界的概率分布。

这里有两点值得注意的地方：

• 随着数据量的增加，参数分布会越来越向数据靠拢，先验的影响力会越来越小
• 如果先验是uniform distribution，则贝叶斯方法等价于频率方法。因为直观上来讲，先验是uniform distribution本质上表示对事物没有任何预判

MLE - 最大似然估计

Maximum Likelihood Estimation, MLE是频率学派常用的估计方法！

最后这一行所优化的函数被称为Negative Log Likelihood (NLL)，这个概念和上面的推导是非常重要的！

我们经常在不经意间使用MLE，例如

• 上文中关于频率学派求硬币概率的例子，其方法其实本质是由优化NLL得出。本文末尾附录中给出了具体的原因 :-)
• 给定一些数据，求对应的高斯分布时，我们经常会算这些数据点的均值和方差然后带入到高斯分布的公式，其理论依据是优化NLL
• 深度学习做分类任务时所用的cross entropy loss，其本质也是MLE

MAP - 最大后验估计

Maximum A Posteriori, MAP是贝叶斯学派常用的估计方法！

再稍微补充几点：

• 我们不少同学大学里学习概率论时，最主要的还是频率学派的思想，其实贝叶斯学派思想也非常流行，而且实战性很强
• CMU的很多老师都喜欢用贝叶斯思想解决问题；我本科时的导师朱军老师也在做贝叶斯深度学习(https://arxiv.org/abs/1709.05870)的工作，有兴趣可以关注一下。

后记

有的同学说：“了解这些没用，现在大家都不用了。”这种想法是不对的，因为这是大家常年在用的知识，是推导优化函数的核心，而优化函数又是机器学习 (包含深度学习) 的核心之一。这位同学有这样的看法，说明对机器学习的本质并没有足够的认识，而让我吃惊的是，竟然有不少其他同学为这种看法点赞。内心感到有点儿悲凉，也引发了我写这篇文章的动力，希望能帮到一些朋友 :-)

....

#代码实现深度学习研究论文の要点

深度学习领域涌现了大量研究论文，使得对现有研究的复现和使用成为一项挑战。原因在于缺乏作者提供的开源实现。本文作者就这一问题详细介绍了将深度学习研究论文实现为代码的步骤及技巧，并辅以举例讲解。

导读

如果深度学习是一种超能力，那么将理论从论文转化为可用的代码就是一种超超能力。

为什么要去复现机器学习研究论文？

正如我所说的，能够将一篇论文转换成代码绝对是一种超超能力，尤其是在像机器学习这样每天都在快速发展的领域。大多数研究论文来自大型科技公司或大学里的人，他们可能是博士，也可能是研究前沿技术的人。还有什么比复现这些顶尖专业人士的研究成果更酷的呢？另一件需要注意的事情是，行业中对这些能够将研究论文进行代码复现的人需求量很大。一旦你掌握了撰写研究论文的窍门，你就会处于与这些研究人员同等的地位。这些研究人员也是通过阅读和复现研究论文的练习获得了这些技能。

如何来阅读和对论文进行复现的？

你可能会说，“嗯，我对深度学习算法有一个大致的了解，像全连接网络，卷积神经网络，循环神经网络，但问题是，我想开发SOTA(最新的)语音克隆AI，但我对语音克隆一无所知:(”。

好吧，这里是你的答案，我的方法的一些部分取自“Andrew Ng关于阅读论文的建议”：https://www.youtube.com/watch?v=733m6qBH-jI&list=PLoROMvodv4rOABXSygHTsbvUz4G_YQhOb&index=8。

如果你想了解一个特定的主题：

1. 收集与特定主题相关的5-6篇论文(你可以通过arxiv或类似的网站找到与某个主题相关的论文)。
2. 不要把每一篇论文完整读完，而是浏览所有的论文，然后挑一篇你感兴趣的，或者如果你心里有一篇特别的论文，那就挑一这篇。
3. 仔细阅读摘要，从高层次上理解其中的思想，看看你的兴趣是否还在继续，如果还在，那就继续浏览图片，看看你是否能对论文内容做出假设。
4. 现在，逐行仔细阅读引言，因为论文所包含的大部分内容将在这里用最简单的方式和最小的数学来解释。
5. 如果你愿意，你可以跳过第一轮的数学方公式，但是不要跳过那些有熟悉的希腊字母的数学公式。
6. 在任何情况下，如果你陷入了困境或某些词让你迷惑不解，不要犹豫，去google 吧，没有人生来什么都懂。
7. 在完成第一关之后，你将处于一种对论文试图证明或改进的地方有一个高层次的理解的状态。
8. 在第二步中，尝试理解本文中的几乎所有内容，如果遇到任何伪代码，尝试将其转换为你选择的python库(PyTorch、TensorFlow……)
9. 你可以阅读更多的论文，并通过阅读每篇论文的参考资料部分来更好地了解该领域。

💡这里是一些高效理解论文的小技巧：

• 如果你是研究论文的初学者，最好在阅读论文之前阅读一些与该主题/研究论文相关的博客文章和视频。这使你的工作更容易。
• 在复现论文时，一定要做笔记，并把重要的地方圈出来，以方便做参考。
• 如果你是研究论文实现的新手，并且在任何地方遇到了困难，那么尝试一下开源实现并看看其他人是如何做到这一点的，这不是一个坏主意。

注意: 不要把第三点当成常规操作，因为这会导致你的学习曲线会下降，你会过拟合。你应该发展自己的阅读和实现论文的方法，这只有通过开始才有可能，所以上面的步骤将帮助你开始。Andrew Ng表示，如果你在一个主题上能读5 - 10篇论文，比如语音克隆，你会在实现的时候有一个较好的状态， 如果你读了50 - 100篇论文，那在这个主题上，你可以进行研究或做前沿技术的研发。

来讨论一篇论文

1. 高层次的概要

现在，你已经了解了如何阅读论文，让我们阅读并为自己实现一篇论文。我们将研究Ian Goodfellow的论文 —— 生成对抗网络(GAN)，并使用PyTorch实现同样的功能。

论文摘要中对论文内容进行了详细的概述。摘要告诉我们，研究人员提出了一个包含两种神经网络的新框架，它们被称为“生成器”和“判别器”。不要被名字弄懵，它们只是两个神经网络的名字。

但在摘要部分要注意的主要一点的是，上面提到的生成器和判别器会相互竞争。好了，让我来讲清楚一点。

让我们以用GANs生成不存在的新人脸为例。

该发生器生成与真实图像尺寸(H×W×C)相同的人脸，并将其喂给判别器，判别器判断该图像是由发生器生成的伪图像还是真实的人脸。

现在你可能会有一个问题，“嗯，这个判别器是如何辨别真假图像的？”，下面就是你的答案：

判别图像是否是真实的是一个分类问题，也就是说，判别器必须分辨图像是真实的还是假的(0或1)。所以我们可以像训练狗和猫分类卷积神经网络那样来训练判别器，而本文中用的是全连接的网络。

💡DCGAN是另一种类型的GAN，使用卷积神经网络代替全连接网络会有更好的结果。所以我们训练判别器的方式是将图像输入判别器中，输出0或1，也就是说，假的或真的。

当我们训练我们的判别器时，我们将把由生成器生成的图像传递给判别器，并分类它是真的还是假的。生成器调整它所有的权值，直到它能够欺骗分类器预测生成的图像是真实的。

我们将给生成器一个随机概率分布(一个随机张量)，生成器的职责是改变这个概率分布，以匹配真实图像的概率分布。

这些是我们在执行代码时应该遵循的步骤：

→加载包含真实图像的数据集。

→创建一个二维随机张量（假数据的概率分布）。

→创建判别器和生成器模型。

→在真实图像和虚假图像上训练判别器。

→将假图像的概率分布送到生成器中，并用判别器测试是否可以区分出这个图像是由生成器生成的虚假图像。

→调整生成器的权值（通过随机梯度下降）直到判别器无法区分真假图像。

你可能有几个疑问，但现在没关系，一旦我们实现了理论代码，你会了解它是如何工作的。

1. 损失函数

在我们实现代码之前，我们需要一个损失函数，以便我们可以优化我们的生成器网络和判别器网络。

该判别器模型是个二分类问题，因此我们使用二元交叉熵损失作为判别器，也可以使用本文讨论的自定义损失函数。

本文的损失函数：[log D(x)] + [log(1−D(G(z)))]

x →真实图像

z →假数据或噪声（随机张量）

D →判别模型

G →生成模型

G(z) →将假数据或噪声送到生成器中（输出是假图像）

D(x) →将真实图像送到判别器中（输出是0或1）

D(G(z)) →将假数据送到生成器中，将生成器输出的图像送到判别器中得到预测（输出是0或1）

如果你想用论文中的损失函数，让我来解释一下：

本文认为，对于判别器，我们需要将上述损失函数最大化。

让我们看方程的第一部分：

— D(x) 输出0或1，所以，当我们最大化 *log[D(x)]*时，这使得当把真实图像喂给判别器的时候，输出趋向于1，这正是我们所需要的。

我们再看方程的第二部分：

— G(z) 输出一张图像，和真实的图像具有相同的尺寸，现在将假图像送到判别器*D(G(z))*中，当最大化判别器的输出的时候，判别器的输出会趋向于1，此时，当我们最大化[1 − D(G(z))]的时候，*D(G(z))*会得到趋向于0的值，这也正是当我们将假图像送到判别器的时候所需要的。

注意: 你可以在方程上加上一个负号，然后将损失函数转化为判别器的最小化问题这比最大化更容易。

对于生成器，我们需要最小化上述方程，但本文只考虑方程的第二部分*[log(1−D(G(z)))]*进行最小化。

— 当我们最小化*D(G(z))*时，判别器输出一个接近于0的值，并且方程的总输出接近于1，这就是我们的生成器想要达到的，当从生成器得到假图像时，欺骗鉴别器预测1(真实)。

开始写代码！

我已经在谷歌colab中完成了代码实现，你试试在谷歌colab或jupyter中写代码。1、导入所需的库—

import torch
from torch import nn
from torch import optim
from torchvision.transforms import transforms
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

from tqdm.notebook import tqdm
import warnings
warnings.filterwarnings("ignore")

2、我们将使用一个单一的图像作为真实的图像，以更快的训练和得到结果，所以图像生成的生成器将类似于这个图像，你也可以使用一组图像的数据，这一切由你。我们将使用_PIL library_将图像加载为PIL image，然后使用_torchvision transforms_调整大小并将图像转换为张量，然后创建大小为(1×100)的伪噪声来生成图像。   

transform = transforms.Compose([
                                transforms.Resize((32, 32)),
                                transforms.ToTensor()
])

flat_img = 3072  #32×32×3 --size of flattened image

img = Image.open('truck.jpeg')
real_img = transform(img)

torch.manual_seed(2)
fake_img = torch.rand(1, 100)

plt.imshow(np.transpose(real_img.numpy(), (1, 2, 0)))
print(real_img.size())

3、创建一个判别器模型，它是一个全连接的神经网络，接收真实图像或伪图像，输出0或1。

class Discriminator(nn.Module):
  def __init__(self):
    super().__init__()
    self.linear = nn.Sequential(
        nn.Linear(flat_img, 10000),
        nn.ReLU(),
        nn.Linear(10000, 1),
        nn.Sigmoid()
    )

  def forward(self, img):
    img = img.view(1, -1)
    out = self.linear(img)

    return out

4、创建一个生成器模型，它也是一个全连接的网络，接受随机噪声并输出一个与真实图像大小相同的图像张量。

class Generator(nn.Module):
  def __init__(self):
    super().__init__()
    self.linear = nn.Sequential(
        nn.Linear(100, 10000),
        nn.LeakyReLU(),
        nn.Linear(10000, 4000),
        nn.LeakyReLU(),
        nn.Linear(4000, flat_img)
    )

  def forward(self, latent_space):
    latent_space = latent_space.view(1, -1)
    out = self.linear(latent_space)

    return out

5、初始化模型，优化器和损失函数，然后将它们移动到所需的设备(cuda或cpu)。我们在判别器中使用二元交叉熵损失，并对生成器使用本文中讨论的损失函数_log(1 - D(G(z))_。

device = 'cuda:0' if torch.cuda.is_available() else 'cpu'

discr = Discriminator().to(device)
gen = Generator().to(device)

opt_d = optim.SGD(discr.parameters(), lr=0.001, momentum=0.9)
opt_g = optim.SGD(gen.parameters(), lr=0.001, momentum=0.9)

criterion = nn.BCELoss()

6、现在我们对模型进行训练，整个GAN被训练500个大的epoch，判别器先

训练4个epoch，然后生成器再训练3个epoch。

epochs = 500
discr_e = 4 
gen_e = 3

#whole model training starts here
for epoch in tqdm(range(epochs), total=epochs):

  #discriminator training
  for k in range(discr_e):
    opt_d.zero_grad()

    out_d1 = discr(real_img.to(device))
    #loss for real image
    loss_d1 = criterion(out_d1, torch.ones((1, 1)).to(device))
    loss_d1.backward()

    out_d2 = gen(fake_img.to(device)).detach()
    #loss for fake image
    loss_d2 = criterion(discr(out_d2.to(device)), torch.zeros((1, 1)).to(device))
    loss_d2.backward()

    opt_d.step()

  #generator training
  for i in range(gen_e):
    opt_g.zero_grad()
    
    out_g = gen(fake_img.to(device))
    
    #Binary cross entropy loss
    #loss_g =  criterion(discr(out_g.to(device)), torch.ones(1, 1).to(device))

    #----Loss function in the GAN paper
    #[log(1 - D(G(z)))]
    loss_g = torch.log(1.0 - (discr(out_g.to(device)))) 
    loss_g.backward()

    opt_g.step()

7、将生成的图像与真实图像进行比较。你可以调整学习率，动量，epochs以及生成器和判别器中的层以得到更好的结果。

最后的思考

生成的图像可能分辨率不是很高，因为本文只是整个生成模型的开始。如果你仍然在坚持，你可以继续阅读DCGANs或其他论文：https://github.com/nightrome/really-awesome-gan，并实现看看那些了不起的结果，但请记住本文是这些论文的基础。

...

#对抗对比学习の论文

2篇对抗对比学习论文导读，一个增强 ACL 的有效性的方法和一个提升ACL的效率的技术 

基础模型 （foundation models）[1]是通过在大规模未标记数据集上进行自监督预训练 （self-supervised learning）得到的，可以通过微调 （fine-tuning）迁移到广泛的下游任务。 现有的工作表明[2]，存在对抗攻击 （adversarial attacks）可以“愚弄”通过微调基础模型获得的任何下游模型。 这种对抗攻击的存在驱动我们去开发鲁棒的基础模型 （robust foundation models），该模型可以在安全关键的下游任务中具有很好的泛化性 （generalization ability）和对抗鲁棒性 （adversarial robustness）。 目前，对抗对比学习[3]（adversarial contrastive learning, ACL）是构建鲁棒的基础模型的最有效方法之一。 在本篇博客中，我介绍两篇NeurIPS 2023 论文，分别提出了一个增强 ACL 的有效性的方法[4]和一个提升ACL的效率的技术[5]:

• [NeurIPS'23] Enhancing Adversarial Contrastive Learning via Adversarial Invariant Regularization, Xu et al. 2023.

https//openreview.net/forum%3Fid%3DzuXyQsXVLF

这篇论文建立了因果理论框架来解释ACL，并根据因果框架提出了对抗不变性正则化 (adversarial invariant regularization, AIR) 来提升ACL达到了SoTA performance。

AIR在Robust Self-Supervised Learning (RobustSSL) Benchmark 上排名第一。RobutSSL Benchmark的Model Zoo(https//github.com/GodXuxilie/RobustSSL_Benchmark)提供大部分ACL方法预训练后得到的权重文件，可供大家下载使用。

https//robustssl.github.io/

https//github.com/GodXuxilie/RobustSSL_Benchmark

• [NeurIPS'23 Spotlight] Efficient Adversarial Contrastive Learning via Robustness-Aware Coreset Selection, Xu et al. 2023.

https//openreview.net/forum%3Fid%3DfpzA8uRA95

这篇论文介绍了一种鲁棒性感知核心集选择 (robustness-aware coreset selection, RCS) 方法来加速 ACL。 RCS 不需要标签信息并搜索有助于学习到鲁棒特征的训练子集。 RCS首次将ACL应用于大规模ImageNet-1K数据集。

鲁棒基础模型 (Robust Foundation Models)

基础模型比如（GPT[6], Vision transformer[7], BLIP[8], CLAP[9]）最近非常流行。 构建和利用基础模型 (foundation models) 是分为2个阶段：

1. 预训练阶段 (pre-training)：将一个模型在大规模没有标签的数据集上进行自监督预训练 (self-supervised learning)后得到预训练的基础模型；
2. 微调阶段 (fine-tuning)：在下游任务上进行微调后，基础模型可以来很好地解决下游任务，比如图像分类问题和情感分析。

但是对抗攻击可以通过在下游任务的原始输入中添加难以察觉的对抗性扰动来欺骗基础模型学习到的特征，从而输出错误的预测。

基础模型的特征很容易受到对抗性攻击，这种攻击可以让模型错误地将汽车预测为“不是汽车”。

对抗攻击的存在使得基础模型在被应用在一些安全性关键下游任务，比如医疗分析[10]和自动识别路标[11]，存在潜在安全风险。因此我们需要构建鲁棒的基础模型来使得这些它们能够被可靠地应用于下游任务。

鲁棒的基础模型具有以下2个特征：

• 依然可以很好地泛化到下游任务中；
• 能在下游任务中，对对抗攻击具有很强的鲁棒性。

其中对抗视角的公式如下:

PGD生成对抗数据过程。PGD根据损失梯度方向一步一步将自然数据（绿色的点 在low-loss区域）更新到对抗数据（红色的点在high-loss区域）。

在每个 epoch，ACL 交替执行步骤 (1) 和 (2)：

• 步骤(1): 通过PGD生成对抗数据；
• 步骤(2): 通过最小化对抗对比损失来更新模型参数。

如何实现ACL预训练？

你可以使用以下脚本在 CIFAR-10 上使用 ResNet-18 进行ACL 预训练。

# Pre-training stage via ACL
git clone https://github.com/GodXuxilie/Enhancing_ACL_via_AIR.git
cd Enhancing_ACL_via_AIR
PRE_TRAIN_DIR=ACL_ResNet18_cifar10
python pretraining.py $PRE_TRAIN_DIR --dataset cifar10 \
                                     --model r18 \
                                     --DynAug --lambda1 0 --lambda2 0

如何进行微调，来利用预训练模型？

在微调阶段，随机初始化分类器并将其附加到预训练的特征提取器以解决分类任务。微调模式分为三种类型：

1. 标准线性微调（standard linear fine-tuning, SLF）：仅对分类器进行标准微调，同时冻结特征提取器。
2. 对抗线性微调（adversarial linear fine-tuning, ALF）：仅对分类器进行对抗性微调，同时冻结特征提取器。
3. 对抗完全微调（adversarial full fine-tuning, AFF）：对抗性微调特征提取器和分类器。

你可以使用以下脚本通过微调将在 CIFAR-10 上预训练 ResNet-18 迁移到下游任务 CIFAR-100：

# Fine-tuning stage
cd Enhancing_ACL_via_AIR
PRE_TRAIN_DIR=ACL_ResNet18_cifar10
FINETUNE_DIR=ACL_ResNet18_cifar10_cifar100
MODE=SLF/ALF/AFF/ALL
python finetuning.py --mode $MODE \
                     --experiment $FINETUNE_DIR \
                     --checkpoint ./checkpoints/$PRE_TRAIN_DIR/model.pt \
                     --dataset cifar100 \
                     --model r18 \
                     --eval-AA --eval-OOD --pretraining DynACL

[NeurIPS'23] Enhancing Adversarial Contrastive Learning via Adversarial Invariant Regularization 论文导读

从因果分析角度理解ACL

ACL的因果图。

在数据生成过程 (data generation procedure) 期间：

AIR正则化

风格不变标准

AIR的损失函数

为了实现风格不变的标准，AIR正则化是来将特征规范为风格无关，如下所示:

直观上来说，AIR 旨在最大化原始数据 (original data)，对抗视角 (adversarial view)，以及自然视角 (natural view) 之间的一致性。

AIR 的学习目标

我们的代码公开在GitHub:

https//github.com/GodXuxilie/Enhancing_ACL_via_AIR

你可以使用以下脚本在 CIFAR-10 上使用 ResNet-18 进行 AIR 预训练：

# Pre-training stage via AIR
git clone https://github.com/GodXuxilie/Enhancing_ACL_via_AIR.git
cd Enhancing_ACL_via_AIR
PRE_TRAIN_DIR=AIR_ResNet18_cifar10
python pretraining.py $PRE_TRAIN_DIR --dataset cifar10 --model r18 --DynAug

实验结果

AIR在下游任务的鲁棒性上达到了最佳。

AIR在common corruption下的鲁棒准确率。

如果要复现上述从 CIFAR-10 到 CIFAR-100 的迁移结果，你可以使用以下脚本：

• 在预训练阶段，使用ResNet-18在CIFAR-10上进行AIR。

# Pre-training stage using AIR
git clone https://github.com/GodXuxilie/Enhancing_ACL_via_AIR.git
cd Enhancing_ACL_via_AIR
PRE_TRAIN_DIR=AIR_ResNet18_cifar10
python pretraining.py $PRETRAIN_DIR --dataset cifar10 --model r18 --DynAug

• 在微调阶段，你可以微调预训练的 ResNet-18 到下游任务 CIFAR-100. 在微调阶段，以下脚本将自动执行所有三种微调模式（即 SLF、ALF 和 AFF）。 微调阶段结束后，您可以从“$FINETUNE_DIR/results/log.txt”的日志文件中检查标准准确度 (standard accuracy, SA)、在对抗攻击下的鲁棒准确率 (robust accuracy under AutoAttack, AA)以及在common corruption的鲁棒准确率。

cd Enhancing_ACL_via_AIR
PRE_TRAIN_DIR=AIR_ResNet18_cifar10
FINETUNE_DIR=AIR_ResNet18_cifar10_cifar100
python finetuning.py --experiment $EXP_DIR \
                     --checkpoint ./checkpoints/$PRE_TRAIN_DIR/model.pt \
                     --dataset cifar100 \
                     --model r18 \
                     --mode ALL \
                     --eval-AA --eval-OOD --pretraining DynACL_AIR

AIR 在RobustSSL Benchmark上的排行榜排名第一！

有关排行榜的更多信息，请查看https//robustssl.github.io/网站。

[NeurIPS'23 Spotlight] Efficient Adversarial Contrastive Learning via Robustness-Aware Coreset Selection 论文导读

这篇文章提出了鲁棒性感知核心集选择（RCS），它选择一个没有标签注释的信息丰富的核心集来加速 ACL。 从理论上讲，我们证明了贪婪搜索算法可以有效地找到核心集。实验上，我们展示RCS 可以在 CIFAR 和 ImageNet-1K 数据集上大幅加速 ACL 和有监督的鲁棒预训练，而不会显着损害鲁棒性可迁移性。 这篇论文首次证明了在大规模数据集上应用 ACL 的可能性的概念。

动机--- ACL是非常耗时的

ACL 在大规模数据集上的计算量巨大，因为生成对抗性数据需要昂贵的计算开销。

ACL 效率低下，因为 T次PGD迭代需要昂贵的计算开销。

根据实验结果，在 RTX A5000 GPU 上评估整个 ImageNet-1K 数据集（1,281,167 个训练数据点）的 ACL 需要大约 650 小时。由于ACL效率低下，ACL尚未应用于不带RCS的ImageNet-1K数据集。

鲁棒性感知核心集选择（Robustness-Aware Coreset Selection, RCS）

直观的加速想法

RCS 生成信息丰富的核心集，使 ACL 高效地获得有效的鲁棒基础模型。图片来自 https://medium.com/analytics-vidhya/sampling-statistical-approach-in-machine-learning-4903c40ebf86。

通过贪婪搜索进行 RCS

通过 RCS 实现加速 ACL 的算法

通过 RCS 的加速训练ACL。 在预热期（warm-up）结束后，模型将在核心集上进行训练。 因此，RCS 通过减少训练数据的数量使训练过程更加高效。

我们的代码公开在GitHub。

https//github.com/GodXuxilie/Efficient_ACL_via_RCS

实验结果

RCS 显着加快了 CIFAR-10 上的 ACL。

你可以使用以下脚本来复现上述结果---从 CIFAR-10 到 CIFAR-100 的鲁棒可迁移性。

# Pre-training stage using RCS
git clone https://github.com/GodXuxilie/Efficient_ACL_via_RCS.git
cd Efficient_ACL_via_RCS/ACL_RCS/small_scale_datasets
PRE_TRAIN_DIR=ACL_RCS_ResNet18_cifar10
python DynACL_RCS.py $PRE_TRAIN_DIR --ACL_DS --dataset cifar10 --fraction 0.2

# Fine-tuning stage (SLF, ALF, AFF)
cd Efficient_ACL_via_RCS/ACL_RCS/small_scale_datasets
PRE_TRAIN_DIR=ACL_RCS_ResNet18_cifar10
FINETUNE_DIR=ACL_RCS_ResNet18_cifar10_cifar100
python finetuning.py --experiment $FINETUNE_DIR \
                     --checkpoint ./checkpoints/$PRE_TRAIN_DIR/model.pt \
                     --dataset cifar100 \
                     --model r18 \
                     --mode ALL --eval-AA --eval-OOD --pretraining DynACL_RCS

首次通过 RCS 在 ImageNet-1K 上高效地进行了ACL预训练。

你可以使用以下脚本来复现上述结果---从 ImageNet-1K 到 CIFAR-10 的鲁棒可迁移性。

# Pre-training stage using RCS
git clone https://github.com/GodXuxilie/Efficient_ACL_via_RCS.git
cd Efficient_ACL_via_RCS/ACL_RCS/ImageNet_32
PRE_TRAIN_DIR=ACL_RCS_WRN_ImageNet
python ACL_RCS.py $PRE_TRAIN_DIR --gpu 0,1,2,3 --ACL_DS --fraction 0.05

# Fine-tuning stage
cd Efficient_ACL_via_RCS/ACL_RCS/ImageNet_32
PRE_TRAIN_DIR=ACL_RCS_WRN_ImageNet
FINETUNE_DIR=ACL_RCS_WRN_ImageNet_cifar10
# Fine-tuning stage (SLF)
python transfer.py --out_dir $FINETUNE_DIR/SLF \
                   --resume $PRE_TRAIN_DIR/model.pt 
                   --dataset cifar10 \
                   --lr 0.01 --linear 
# Fine-tuning stage (ALF)
python adv_tune.py --out_dir $FINETUNE_DIR/ALF \
                   --resume $PRE_TRAIN_DIR/model.pt \
                   --dataset cifar10 \
                   --lr 0.1 --linear 
# Fine-tuning stage (AFF)
python adv_tune.py --out_dir $FINETUNE_DIR/AFF \
                   --resume $PRE_TRAIN_DIR/model.pt \
                   --dataset cifar10 \
                   --lr 0.1

RCS 可以加速 ImageNet-1K 上的标准对抗训练 (standard adversarial training, SAT)。结果表明，RCS 适用于有监督的鲁棒预训练。       

你可以使用以下脚本来复现上述结果---从 ImageNet-1K 到 CIFAR-10 的鲁棒可迁移性。

git clone https://github.com/GodXuxilie/Efficient_ACL_via_RCS.git
cd Efficient_ACL_via_RCS/SAT_RCS/ImageNet_32
# Pre-training stage using RCS
PRE_TRAIN_DIR=SAT_RCS_WRN_ImageNet
nohup python SAT_RCS.py --gpu 0,1,2,3 --out_dir $PRE_TRAIN_DIR --fraction 0.2

# Fine-tuning stage
cd Efficient_ACL_via_RCS/SAT_RCS/ImageNet_32
PRE_TRAIN_DIR=SAT_RCS_WRN_ImageNet
FINETUNE_DIR=SAT_RCS_WRN_ImageNet_cifar10
# Fine-tuning stage (ALF)
python adv_tune.py --out_dir $FINETUNE_DIR/ALF \
                   --resume $PRE_TRAIN_DIR/checkpoint.pth.tar \
                   --dataset cifar10 \
                   --lr 0.1 \
                   --linear 
# Fine-tuning stage (AFF)
python adv_tune.py --out_dir $FINETUNE_DIR/AFF \
                   --resume $PRE_TRAIN_DIR/checkpoint.pth.tar 
                   --dataset cifar10 \
                   --lr 0.1

结语

这两项工作都是由以下作者合作完成:

Xilie Xu 徐曦烈- 新加坡国立大学(http//godxuxilie.github.io)

Jingfeng Zhang 张景锋- 理化学研究所 RIKEN-AIP 奥克兰大学(https//zjfheart.github.io/)

Feng Liu 刘峰- 墨尔本大学(https//fengliu90.github.io/)

Masashi Sugiyama 杉山 将- 理化学研究所 RIKEN-AIP 东京大学(http//www.ms.k.u-tokyo.ac.jp/sugi/profile-jp.html)

Mohan Kankanhalli- 新加坡国立大学(https//www.comp.nus.edu.sg/~mohan/)

参考

1.Bommasani, R., Hudson, D. A., Adeli, E., Altman, R., Arora, S., von Arx, S., ... & Liang, P. (2021). On the opportunities and risks of foundation models. arXiv preprint arXiv:2108.07258.

2.Ban, Y., & Dong, Y. (2022). Pre-trained Adversarial Perturbations. Advances in Neural Information Processing Systems, 35, 1196-1209.

3.Luo, R., Wang, Y., & Wang, Y. (2022, September). Rethinking the Effect of Data Augmentation in Adversarial Contrastive Learning. In The Eleventh International Conference on Learning Representations.

4.https://openreview.net/forum?id=zuXyQsXVLF

5.https://openreview.net/forum?id=fpzA8uRA95

6.Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J. D., Dhariwal, P., ... & Amodei, D. (2020). Language models are few-shot learners. Advances in neural information processing systems, 33, 1877-1901.

7.Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., ... & Houlsby, N. (2020). An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929.

8.Li, J., Li, D., Xiong, C., & Hoi, S. (2022, June). Blip: Bootstrapping language-image pre-training for unified vision-language understanding and generation. In International Conference on Machine Learning (pp. 12888-12900). PMLR.

9.Elizalde, B., Deshmukh, S., Al Ismail, M., & Wang, H. (2023, June). Clap learning audio concepts from natural language supervision. In ICASSP 2023-2023 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP) (pp. 1-5). IEEE.

10.He, K., Gan, C., Li, Z., Rekik, I., Yin, Z., Ji, W., ... & Shen, D. (2023). Transformers in medical image analysis. Intelligent Medicine, 3(1), 59-78.

11.Eykholt, K., Evtimov, I., Fernandes, E., Li, B., Rahmati, A., Xiao, C., ... & Song, D. (2018). Robust physical-world attacks on deep learning visual classification. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 1625-1634).

12.Chen, T., Kornblith, S., Norouzi, M., & Hinton, G. (2020, November). A simple framework for contrastive learning of visual representations. In International conference on machine learning (pp. 1597-1607). PMLR.

13.Madry, A., Makelov, A., Schmidt, L., Tsipras, D., & Vladu, A. (2017). Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083.

14.实际上，我们严格证明了一个代理集合函数是weakly submodular。 进一步，我们利用这个代理集合函数，来证明了所提出的贪婪搜索算法为集函数最大化问题提供了有保证的下界。 更多细节请参考我们的RCS论文。

....

#MUDDFormer

Transformer还有救？魔改残差连接，MUDDFormer硬刚超深网络

将原单一残差流拆为 Q/K/V/R 四路动态稠密跨层连接，仅用 0.23% 额外参数即可让 2.8 B 模型在零样本和 5-shot 任务上分别追平 6.9 B 和 12 B 的 Pythia，深度扩展至 42 层仍持续增长，显著缓解表征坍塌与残差流信息过载。

当下大多数人都觉得 Transformer 已经被研究得差不多了，想在结构上做出能超越它的创新，基本不太可能了。

但是总有人愿意打破常规，最近一篇 ICML 2025 的论文，又让 Transformer 有了新活力。它把目光放在了 Transformer 里一个我们平时没太在意、甚至有点忽略的部分——残差连接。

残差连接（residual connections）自何恺明在 2015 年开山之作 ResNet [1] 中提出后，就成为深度学习乃至 Transformer LLMs 的一大基石。但在当今的深度 Transformer LLMs 中仍有其局限性，限制了信息在跨层间的高效传递。

彩云科技与北京邮电大学近期联合提出了一个简单有效的残差连接替代：多路动态稠密连接（MUltiway Dynamic Dense (MUDD) connection），大幅度提高了 Transformer 跨层信息传递的效率。

论文标题：

MUDDFormer: Breaking Residual Bottlenecks in Transformers via Multiway Dynamic Dense Connections

论文链接：

​​https://arxiv.org/abs/2502.12170​​

代码链接：

​​https://github.com/Caiyun-AI/MUDDFormer​​

模型链接：

​​https://huggingface.co/Caiyun-AI/MUDDFormer-2.8B​​

​​https://huggingface.co/Caiyun-AI/MUDDPythia-1.4B​​

​​https://huggingface.co/Caiyun-AI/MUDDPythia-2.8B​​

大规模语言模型预训练实验表明，仅增加 0.23% 的参数量和 0.4% 的计算量，采用该架构的 2.8B 参数量 MUDDPythia 模型即可在 0-shot 和 5-shot 评估中分别媲美 6.9B 参数量（~2.4 倍）和 12B 参数量（~4.2 倍）的 Pythia 模型，表明了 MUDD 连接对 Transformer 的基础能力（尤其是上下文学习能力）的显著提升。

这是该团队继 DCFormer [2]（ICML 2024）后又一项大模型底层架构创新工作，已被 ICML 2025 接收，论文、代码和模型权重均已公开。

01 背景

在 Transformer 中残差流汇集了多层的信息，同时也为 Attention 和 FFN 提供多路信息，比如在 Attention 模块中需要获取 query、key、value 三路信息，残差流本身也可以看作一路信息流（记作 R）。

虽然残差连接的引入首次让训练超深度网络成为可能，但在当今的深度 Transformer LLMs 中仍有其局限：

深层隐状态的表征坍塌（Representation Collapse）：目前 Transformer LLM 普遍采用 Pre-Norm 训练，多个理论和实证工作 [3,4] 表明，当达到一定层深后，再增加更多的层会出现边际效应递减，相邻层的隐状态表征高度相似（即「表征坍塌」），让参数和算力 scaling 的效果大打折扣。

残差流的信息过载：Transformer 机制可解释性研究表明，跨越不同层的注意力头和前馈网络通过读写残差流（residual stream）交互组成回路（circuit），对模型的上下文学习（in-context learning）等能力至关重要。
在非常深的 Transformer 模型中，残差流作为多层间「通信总线」可能因为多路信息共享残差流，以及多层信息在深层汇集而「超载」成为瓶颈，妨碍形成解决困难任务所必须的复杂回路。

针对上述局限，MUDD 根据当前隐状态动态搭建跨层连接（可视为深度方向的多头注意力），来缓解深层隐状态的表征坍塌，同时针对 Transformer 每层的 query、key、value、残差等不同输入流采用各自的动态连接，来减少多路信息流的相互干扰，缓解残差流的信息过载，这样既大幅度拓宽了跨层信息传输带宽，又保证了非常高的参数和计算效率。

02 核心架构

如图 1a 所示，为了实现更直接的跨层交互，DenseNet [5] 将当前 Block 和前面所有的 Block 进行稠密连接（Dense Connectivity）。

最近 Pagliardini 等人 [6] 将其引入 Transformer，提出了 DenseFormer（NeurIPS 2025），如图 1b 所示。

它通过一组可学习但静态的权重（如 w_i,j）来加权求和前面所有层的输出。这种方式虽然拓宽了信息通路，但静态权重使得对于序列中不同 token 都做同样处理，限制了表达能力。

▲ 图1. MUDD 的架构图

研究者首先提出了 DynamicDenseFormer（如图 1c），用  表示第个 token 的跨层信息聚合模块（Depth－wise Aggregate），连接权重不再是固定的参数，而是由当前层的隐状态  动态生成的一个权重矩阵  。

这意味着，模型可以根据每个 token 的上下文语境，自适应地决定应该从前面的哪一层、以多大的权重提取信息。本质上，这可以看作是在深度维度上的一次单头注意力，与 Vaswani 等人 [7] 在 Transformer 中提出的 token 维度上的注意力机制遥相呼应。

在 DynamicDenseFormer 的基础上引入多路连接就得到了 MUDDFormer，如图 1d 所示，它将原本单一的动态连接，解耦成四路独立的动态连接，分别为 Q、K、V、R（图 1d 中的等）定制各自的跨层信息聚合模块。

这样每一路信息流都可以根据自己的需求，更高效地从前面层中获取对应信息。可看作是深度向的多头注意力。

02 实验评估

Scaling Law

▲ 图2. MUDDFormer和基线模型的扩展实验

研究者在 Pile 数据集上测试了 MUDDFormer 和其他基线模型的扩展能力，如图 2 所示。

Hyper-Connections [8] 也是字节跳动 Seed 最近一个发表在 ICLR 2025 的改进残差连接的工作，图 2 中可见 DynamicDenseFormer 已经比 DenseFormer 和 Hyper-Connections 都表现好，而且在解耦多路信息流后，MUDDFormer 又有明显的效果提升。

在所有模型尺寸下 MUDDFormer 都显著领先 Transformer++ 和其他基线模型 (Loss 越低越好)，并且其领先优势随着模型增大并未减小。MUDDFormer-834M 的性能，已经超越了需要 1.89 倍计算量的 Transformer++ 基线模型，展现了惊人的计算效率提升。

▲ 图3. MUDDFormer和Transformer++的深度扩展实验

为了验证 MUDDFormer 在更深层模型上的有效性，研究者在不增加参数量的前提下增加模型的深度，并进行了扩展实验，如图 3。

Transformer++ 在超过 24 层后收益递减（缩放曲线几乎重合），而 deep MUDDFormer 在高达 42 层时仍能保持收益，使得在 797M 下达到了 2.08 倍 Transformer++ 的性能。这进一步验证了 MUDD 连接可以通过增强跨层信息流来缓解深度引起的瓶颈。​

下游任务测评

研究者将 MUDD 架构与开源的 Pythia 模型框架结合，在 300B tokens 的数据上进行训练，并与从 1.4B 到 12B 的全系列 Pythia 模型进行比较，如图 4。

▲ 图4. 下游任务对比测评

首先，MUDDPythia 在 0-shot 和 5-shot 任务上的平均准确率，都明显高于同等计算量下的 Pythia 模型，而且在 5-shot 下的提升效果更明显，说明上下文能力得到了额外的增强。

从图 5 中可以看出在 0-shot 下，2.8B 的 MUDDPythia 的性能媲美了 6.9B 的 Pythia，实现了 2.4 倍的计算效率飞跃；在 5-shot 下，2.8B 的 MUDDPythia 的性能，甚至追平了 12B 的 Pythia，实现了 4.2 倍计算效率提升！

▲ 图5. 下游任务准确率对比曲线

这表明，MUDD 所构建的高效信息通路，极大地增强了模型在上下文中动态构建复杂推理回路的能力。​

分析

图 6 展示了模型注意力头激活比例随层数的变化，在标准的 Pythia 模型中，随着层数加深大量注意力头都只关注少数几个 token（attention sink [9]）并未激活。

▲ 图6. 注意力头激活比例的逐层变化曲线

然而，在 MUDDPythia 中，几乎在所有层的注意力头激活率都远高于 Pythia，平均高出约 2.4 倍。这说明 MUDD 连接加强了对 Attention 的利用，也部分解释了上下文能力的增强。​

04 结语

MUDDFormer 通过简单高效的实现改进了残差连接，为 Transformer 内部不同的信息流（Q、K、V、R）建立各自独立的动态跨层连接，不仅增强了 Transformer 模型的跨层交互，而且进一步提升了模型的上下文学习能力。

实验证明这种新的连接机制能以微弱的代价，换来模型性能和计算效率的巨大飞跃。MUDDFormer 所展示的潜力，使其有望成为下一代基础模型架构中不可或缺的新基石。

参考文献

[1] He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition (CVPR), pp. 770–778, 2016.

[2] Xiao, Da, et al. "Improving transformers with dynamically composable multi-head attention." Proceedings of the 41st International Conference on Machine Learning. 2024.

[3] Liu, L., Liu, X., Gao, J., Chen, W., and Han, J. Understanding the difficulty of training transformers. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2020b.

[4] Gromov, A., Tirumala, K., Shapourian, H., Glorioso, P., and Roberts, D. A. The unreasonable ineffectiveness of the deeper layers. arXiv preprint arXiv:2403.17887, 2024.

[5] Huang, G., Liu, Z., Van Der Maaten, L., and Weinberger, K. Q. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition (CVPR), pp. 4700–4708, 2017.

[6] Pagliardini, M., Mohtashami, A., Fleuret, F., and Jaggi, M. Denseformer: Enhancing information flow in transformers via depth weighted averaging. In Proceedings of the Thirty-Eighth Annual Conference on Neural Information Processing Systems (NeurIPS), 2024.

[7] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., and Polosukhin, I. Attention is all you need. Advances in neural information processing systems, 30, 2017.

[8] Zhu, D., Huang, H., Huang, Z., Zeng, Y., Mao, Y., Wu, B., Min, Q., and Zhou, X. Hyper-connections. In Proceedings of the Thirteenth International Conference on Learning Representations (ICLR), 2025

[9] Xiao, G., Tian, Y., Chen, B., Han, S., and Lewis, M. Efficient streaming language models with attention sinks. In The Twelfth International Conference on Learning Representations (ICLR), 2024b.

....

#Local Dense Relational Logit Distillation, LDRLD

不止于模仿：LDRLD深挖Logit内部关系，开启知识蒸馏新篇章

知识蒸馏（Knowledge Distillation, KD）作为一种高效的模型压缩和优化技术，其核心思想在于让一个强大的“教师”网络，将其所学到的“知识”传授给一个轻量的“学生”网络。其中，基于Logits（模型在最终输出概率前的原始得分）的蒸馏方法因其简洁、高效而备受青睐。然而，这些方法大多停留在让学生模仿教师整体Logits分布的层面，却忽略了Logits中蕴含的、更为丰富的细粒度类别关系。

为了挖掘这部分被忽视的“暗知识”，来自东北大学、华南师范大学等机构的研究者们提出了局部密集关系Logits蒸馏（Local Dense Relational Logit Distillation, LDRLD），这是一种新颖的蒸馏方法，它通过递归地解耦和重组Logits信息，迫使学生网络学习类别之间更精细、更清晰的内在关联，从而在多个基准测试上取得了超越SOTA的性能。

• 论文标题： Local Dense Logit Relations for Enhanced Knowledge Distillation
• 作者： Liuchi Xu, Kang Liu, Jinshuai Liu, Lu Wang, Lisheng Xu, Jun Cheng
• 机构： 东北大学；华南师范大学；中国科学院；香港中文大学
• 论文地址：​​ https://arxiv.org/pdf/2507.15911v1​​
• 会议/期刊： 已被 ICCV 2025 接收

核心思想：从全局模仿到局部关系解耦

传统的知识蒸馏（KD）方法通常使用一个全局的Softmax函数来软化教师的Logits，这虽然保留了类别间的相对大小关系（例如，教师认为图片是“猫”的可能性比“汽车”大），但也将所有类别的Logits耦合在一起计算概率，这在一定程度上“稀释”了那些最相似、最易混淆类别之间的细微差别。

LDRLD的核心洞察在于：真正有价值的知识，往往隐藏在那些最相似的类别对（category pairs）的关系中。如下图所示，“猫”和“狗”之间的区别是通过概率分布反映出来的，但引入无关的（例如“汽车”）可能会干扰和削弱它们的类间可辨性。

这些限制共同阻碍了学生捕捉独特类别特征的能力，可能会降低其表现。因此，在综合利用logit关系的同时，提高类间可辨性至关重要。

为了实现这一目标，LDRLD设计了一个包含三大核心组件的精巧框架：

1.  递归解耦与重组 (Recursive Decoupling and Recombination):

这是LDRLD的基石。它不再一次性蒸馏所有类别的Logits，而是递归地、成对地解耦Logits信息。在每一层递归中，它都聚焦于当前最相似的类别对，提取它们之间的关系知识，然后将剩余的知识传入下一层递归，直至所有关系被充分挖掘。

2. 自适应衰减权重 (Adaptive Decay Weight, ADW):

为了让模型更关注那些最重要的类别关系，研究者引入了ADW策略。它包含两个子策略：

• 逆序权重 (Inverse Rank Weighting, IRW): 根据教师Logits的排名，为排名更接近的类别对赋予更高的权重。例如，如果教师认为最可能的是“猫”，其次是“狗”，那么“猫-狗”这对关系的学习权重就应该很高。
• 指数秩衰减 (Exponential Rank Decay, ERD): 根据类别对的整体排名分数，自适应地控制权重衰减，确保模型不会在那些教师认为完全不相关的类别上花费过多精力。

3. 剩余知识蒸馏 (Distilling Remaining Knowledge):

在递归地提取完成类别对的关系知识后，为了保证知识的完整性，LDRLD还会将剩余的非目标知识进行一次整体蒸馏，确保学生不会丢失全局信息。

实验结果：全面超越SOTA

在CIFAR-100、ImageNet-1K和Tiny-ImageNet等多个标准数据集上，LDRLD展现了其卓越的性能。

如下表所示，无论教师和学生的网络架构相同还是不同，LDRLD在Top-1准确率上均显著优于包括经典KD、DKD、MLKD在内的多种SOTA Logits蒸馏方法。

特征图可视化也直观地证明了LDRLD的有效性。如下图所示，使用LDRLD训练的学生网络，其倒数第二层的特征图展现出比使用传统KD方法训练的学生网络更高的类内紧凑性和类间可分性，这意味着学生学到了更具辨识力的特征。

为了验证该方法的泛化能力，将任务扩展到人Re-ID。如下表所示，结果表明，与其他蒸馏方法（如AT和DKD）相比，所提出方法表现出更优的性能，证实了其有效性。

论文贡献与价值

• 提出LDRLD新方法： 提出通过递归解耦和重组Logits来挖掘和传递细粒度类别关系知识的新范式，为知识蒸馏领域提供了新的视角。
• 设计ADW策略： 创新的自适应衰减权重策略，能够动态地聚焦于最关键的知识进行传递，显著提升了蒸馏效率和效果。
• 性能SOTA： 在多个基准测试中取得了全面领先的性能，为知识蒸馏领域设立了新的性能标杆。
• 代码即将开源： 研究团队承诺将公开代码，这将极大地促进社区对细粒度知识蒸馏的研究。

总而言之，LDRLD不再满足于让学生模仿教师的“最终答案”，而是通过一种更精细的方式，引导学生去学习教师在得出答案过程中的“思考逻辑”和“权衡过程”，为训练出更强大的轻量级模型提供了一条极具潜力的新路径。

.....

#Diffusion/VAE/RL 数学原理

最近做的两个project，一个训VAE，一个训RL都进行project尾声了，但是对于数学原理上的掌握还很浅

看到了这个up的slide做的非常不错，在这里结合自己的理解分享一下

【大白话01】一文理清 Diffusion Model 扩散模型 | 原理图解+公式推导_哔哩哔哩_bilibili​

Diffusion

原图提供gaussian distribution的mean value，noise系数提供Gaussian distribution的variance value

​​!$\sqrt{\alpha_t-\alpha_t\alpha_{t-1}}\epsilon_{t-2}\sim N(0,\alpha_t-\alpha_t\alpha_{t-1}) \\ \sqrt{1- \alpha_t}\epsilon_{t-1}\sim N(0,1- \alpha_t) \\ \sqrt{1- \alpha_t}\epsilon_{t-1}+\sqrt{\alpha_t-\alpha_t\alpha_{t-1}}\epsilon_{t-2}\sim N(0,1-\alpha_t\alpha_{t-1}) $​​

假设每一步denoise都满足gaussian distribution，所以network训练目标是拟合这两个gaussian distribution的mean&variance

先忽略推导，只关注KL项

中间这个KL项就是在拟合denoise中理论值和network预测值

虽然  ​​!$q(x_{t-1}|x_t)$​​​ 是不确定的，但是  ​​!$q(x_{t-1}|x_t,x_0)$​​ 是个确定的过程

这里的推导比较复杂，化简的结果就是  ​​!$x_0$​​ 是未知的

将本来不确定的  ​​!$x_0$​​​  转为不确定的  ​​!$\epsilon$​​  ，迭代预测noise

最后这里就没啥好说的了，将拟合两个distribution转为拟合两个noise​

VAE

VAE假设latent distribution是个gaussian distribution

AE是没有生成能力的

用神经网络拟合encoder

最小化KL loss，相当于要最大化ELBO

logp(x)相当于是在原始数据集的分布，是确定的

为了避免latent space退化为variance=0的尖锐分布，无法学出gaussian distribution

通过假设p(z|x)即encode处满足gaussian distribution

将VAE的训练转为重建loss+KL约束loss

training&sampling

reconstruction loss & kl loss的PCA消融实验

补充一下表征这件事情

1. semantic representation：希望它趋近于脉冲分布
2. generate representation：希望它趋近于Gaussian分布

原因：希望对generate representation进行插值，但是semantic representation希望它进行classification​

RL

markov decision process就是(s1,a1,s2,a2...)

结合马尔可夫的图，分清楚在哪个点上是action value，哪个点上是state value

temporal difference：往前多走一步，用更准确的结果更新过去的估计

policy gradient：让network去学习怎么样在知道s的情况下，s-->a可以取到最合适的转换

....

#抛开数学，轻松学懂VAE

本文作者用“编码成一条线”的直觉比喻，带你绕过数学推导，10 分钟看懂 VAE 如何把自编码器的点变成分布、用 KL 散度防过拟合，并给出 PyTorch 从零训练人脸生成的完整代码。

变分自编码器（VAE）是一类常见的生成模型。纯VAE的生成效果不见得是最好的，但VAE还是经常会被用作大模型的子模块。即使是在VAE发明多年的今天，学习VAE还是很有必要的。相比GAN等更符合直觉的模型，彻底理解VAE对数学的要求较高。在这篇文章中，我会从计算机科学的角度出发，简明地讲清楚VAE的核心原理，并附上代码实现的介绍。同时，我会稍微提及VAE是怎么利用数学知识的，以及该怎么去拓展了解这些数学知识。​

用自编码器生成图像

在正式开始学习VAE之前，我们先探讨一下内容生成的几种方式，并引入自编码器（Autoencoder, AE）这个概念。为了方面描述，我们仅讨论图像的生成。

在设计生成图像的程序之前，我们要考虑一个问题——程序的输入是什么？如果程序没有任何输入，那么它就应该有一个确定的输出，也就是只能画出一幅图片。而只能画出一幅图片的程序没有任何意义的。因此，一个图像生成模型一定要有输入，用于区分不同的图片。哪怕这种输入仅仅是0, 1, 2这种序号也可以，只要模型能看懂输入，为每个输入生成不同的图片就行了。

可是，我们不仅希望不同的输入能区分不同的图片，还要让相近的输入生成相近的图片。比如1.5号图片应该长得和1号和2号相似。为了让模型满足这种性质，我们可以干脆把模型的输入建模成有意义的高维实数向量。这个向量，可以是看成对图像的一种压缩编码。比如(170, 1)就表示一幅身高为170cm的男性的照片。

绝大多数生成模型都是用这种方式对生成过程建模。所有的输入向量  来自于一个标准正态分布  。图像生成，就是把图像的编码向量  解码成一幅图像的过程。不同的生成模型，只是对这个过程有着不同的约束方式。

自编码器的约束方式十分巧妙：既然把  翻译回图像是一个解码的过程，为什么不可以把编码的过程也加进来，让整个过程自动学习呢？如下图所示，我们可以让一个模型（编码器）学会怎么把图片压缩成一个编码，再让另一个模型（解码器）学会怎么把编码解压缩成一幅图片，最小化生成图片与原图片之间的误差。

最后，解码器就是我们需要的生成模型。只要在标准多元正态分布里采样出  ，就可生成图片了。另外，理想情况下， 之间的插值向量也能代表在语义上插值的图片。

可是，由于自编码器本身的限制，这种理想不一定能实现。​

自编码器的问题——过拟合

自编码器的信息压缩能力十分强大。只要编码器和解码器的神经网络足够复杂，所有训练集里的图像都可以被压缩成非常短的编码。这种编码短到什么程度了呢？——只要一个一维向量（实数）就可以描述所有训练集里的图像了。

想做到这一点并不难。还记得我们开头对生成模型的输入的讨论吗？只要让模型把所有图片以数组的形式存到编码器和解码器里，以0, 1, 2这样的序号来表示每一幅训练集里的图片，就能完成最极致的信息压缩。当然，使用这种方式的话，编码就失去了所有的语义信息，编码之间的插值也不能表示图像语义上的插值了。

这是由模型过拟合导致的。如果仅使用自编码器本身的约束方式，而不加入其他正则化方法的话，一定会出现过拟合。​

VAE——一种正则化的自编码器

VAE就是一种使用了某种正则化方法的自编码器，它解决了上述的过拟合问题。VAE使用的这种方法来自于概率论的变分推理，不过，我们可以在完全不了解变分推理的前提下看懂VAE。

VAE的想法是这样的：我们最终希望得到一个分布，或者说一条连续的直线。可是，编码器每次只能把图片编码成一个向量，也就是一个点。很多点是很难重建出一条连续的直线的。既然如此，我们可以把每张图片也编码成一个分布。多条直线，就可以比较容易地拼成我们想要的直线了。

当然，只让模型去拟合分布是不够的。如果各个分布都乱七八糟，相距甚远，那么它们怎么都拼不成一个标准正态分布。因此，我们还需要加上一个约束，让各个分布和标准正态分布尽可能相似。

这样，我们可以总结一下VAE的训练框架。VAE依然使用了编码器-解码器的架构。只不过，编码器的输出是一个可学习的正态分布。对分布是不可能做求导和梯度下降的，但我们可以去分布里采样，对采样出来的编码解码并求导。

另外，VAE的损失函数除了要最小化重建图像与原图像之间的均方误差外，还要最大化每个分布和标准正态分布之间的相似度。

常见的描述分布之间相似度的指标叫做KL散度。只要把KL散度的公式套进损失函数里，整个训练框架就算搭好了。

VAE的原理其实就是这么简单。总结一下，VAE本身是一个编码器-解码器结构的自编码器，只不过编码器的输出是一个分布，而解码器的输入是该分布的一个样本。另外，在损失函数中，除了要让重建图像和原图像更接近以外，还要让输出的分布和标准正态分布更加接近。​

VAE 与变分推理

前几段其实只对VAE做了一个直觉上的描述，VAE的损失函数实际上是经严谨的数学推导得到的。如果你对数学知识不感兴趣，完全可以跳过这一节的讲解。当然，这一节也只会简单地描述VAE和变分推理的关系，更详细的数学推导可以去参考网上的其他文章。

让我们从概率论的角度看待生成模型。生成模型中的  可以看成是隐变量，它决定了能观测到的变量  。比如说，袋子里有黑球和白球，你不断地从袋子里取球出来再放回去，就能够统计出抽到黑球和白球的频率。然而，真正决定这个频率的，是袋子里黑球和白球的数量，这些数量就是观测不到的隐变量。简单来说，隐变量  是因，变量  是果。

生成模型，其实就是假设  来自标准正态分布，想要拟合分布 （解码器），以得到  的分布（图像分布）。为了训练解码器，自编码器架构使用了一个编码器以描述  。这样，从训练集里采样，等于是采样出了一个  。根据  求出一个  ，再根据  试图重建  。优化这个过程，就是在优化编码器和解码器，也就是优化  和  。

然而， 和  之间有一个约束，它们必须满足贝叶斯公式：

假如我们要用一个和  有关的关于  的分布  去拟合  ，就要让  和  这两个分布尽可能相似。如果这个相似度是KL散度，经过一系列的推导，就可以推导出我们在 VAE里使用的那个损失函数。

简单来说，拟合一个未知分布的技术就叫做变分推理。VAE利用变分推理，对模型的编码器和解码器加了一个约束，这个约束在化简后就是VAE的损失函数。

VAE和变分推理的关系就是这样。如果还想细究，可以去先学习KL散度相关的知识，再去看一下VAE中KL散度的公式推导。当然，不懂这些概念并不影响VAE的学习。​

总结

VAE其实就是一个编码器-解码器架构，和U-Net以及部分NLP模型类似。然而，为了抑制自编码过程中的过拟合，VAE编码器的输出是一个正态分布，而不是一个具体的编码。同时，VAE的损失函数除了约束重建图像外，还约束了生成的分布。在这些改进下，VAE能够顺利地训练出一个解码器，以把来自正态分布的随机变量画成一幅图像。如果你想通过代码实践进一步加深对VAE的理解，可以阅读附录。​

参考资料

1. 一篇不错的VAE讲解。我是跟着这篇文章学习的。https://towardsdatascience.com/understanding-variational-autoencoders-vaes-f70510919f73
2. 我的VAE PyTorch实现参考了这个仓库：https://github.com/AntixK/PyTorch-VAE 。开头的人脸生成效果图是从这个项目里摘抄过来的。​

VAE PyTorch 实现

项目网址：https://github.com/SingleZombie/DL-Demos/tree/master/dldemos/VAE​

数据集

在这个项目中，我使用了CelebA数据集。这个数据集有200k张人脸，裁剪和对齐后的图片只有1个多G，对实验非常友好。

CelebA的下载链接可以在官方网站上找到：https://mmlab.ie.cuhk.edu.hk/projects/CelebA.html。

下载好了图片后，可以用下面的代码创建Dataloader。

import os

import torch
from PIL import Image
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms


class CelebADataset(Dataset):
    def __init__(self, root, img_shape=(64, 64)) -> None:
        super().__init__()
        self.root = root
        self.img_shape = img_shape
        self.filenames = sorted(os.listdir(root))

    def __len__(self) -> int:
        return len(self.filenames)

    def __getitem__(self, index: int):
        path = os.path.join(self.root, self.filenames[index])
        img = Image.open(path).convert('RGB')
        pipeline = transforms.Compose([
            transforms.CenterCrop(168),
            transforms.Resize(self.img_shape),
            transforms.ToTensor()
        ])
        return pipeline(img)


def get_dataloader(root='data/celebA/img_align_celeba', **kwargs):
    dataset = CelebADataset(root, **kwargs)
    return DataLoader(dataset, 16, shuffle=True)

这段代码是一段非常常规的根据图片路径读取图片的代码。只有少数地方需要说明：

• 为了尽快完成demo，所有人脸图片的分辨率都是。
• CelebA里裁剪后的人脸图片是长方形的。要先调用​​CenterCrop​​裁剪出正方形人脸，再做Resize。

为了验证Dataloader的正确性，我们可以写一些脚本来查看Dataloader里的一个batch的图片。

if __name__ == '__main__':
    dataloader = get_dataloader()
    img = next(iter(dataloader))
    print(img.shape)
    # Concat 4x4 images
    N, C, H, W = img.shape
    assert N == 16
    img = torch.permute(img, (1, 0, 2, 3))
    img = torch.reshape(img, (C, 4, 4 * H, W))
    img = torch.permute(img, (0, 2, 1, 3))
    img = torch.reshape(img, (C, 4 * H, 4 * W))
    img = transforms.ToPILImage()(img)
    img.save('work_dirs/tmp.jpg')

这段代码使用了一些小技巧。首先，​​next(iter(dataloader))​​可以访问Dataloader的第一个数据。其次，在把一个batch的图片转换成图片方格的过程中，我使用了比较骚的换维度、换形状操作，看起来很帅。

模型

我的VAE模型使用了类似U-Net的操作：编码器用卷积把图像的边长减半，通道翻倍，解码器用反卷积把图像的边长翻倍，通道减半。

模型结构的定义函数如下：

import torchimport torch.nn as nnclass VAE(nn.Module):    '''    VAE for 64x64 face generation. The hidden dimensions can be tuned.    '''    def __init__(self, hiddens=[16, 32, 64, 128, 256], latent_dim=128) -> None:        super().__init__()        # encoder        prev_channels = 3        modules = []        img_length = 64        for cur_channels in hiddens:            modules.append(                nn.Sequential(                    nn.Conv2d(prev_channels,                              cur_channels,                              kernel_size=3,                              stride=2,                              padding=1), nn.BatchNorm2d(cur_channels),                    nn.ReLU()))            prev_channels = cur_channels            img_length //= 2        self.encoder = nn.Sequential(*modules)        self.mean_linear = nn.Linear(prev_channels * img_length * img_length,                                     latent_dim)        self.var_linear = nn.Linear(prev_channels * img_length * img_length,                                    latent_dim)        self.latent_dim = latent_dim        # decoder        modules = []        self.decoder_projection = nn.Linear(            latent_dim, prev_channels * img_length * img_length)        self.decoder_input_chw = (prev_channels, img_length, img_length)        for i in range(len(hiddens) - 1, 0, -1):            modules.append(                nn.Sequential(                    nn.ConvTranspose2d(hiddens[i],                                       hiddens[i - 1],                                       kernel_size=3,                                       stride=2,                                       padding=1,                                       output_padding=1),                    nn.BatchNorm2d(hiddens[i - 1]), nn.ReLU()))        modules.append(            nn.Sequential(                nn.ConvTranspose2d(hiddens[0],                                   hiddens[0],                                   kernel_size=3,                                   stride=2,                                   padding=1,                                   output_padding=1),                nn.BatchNorm2d(hiddens[0]), nn.ReLU(),                nn.Conv2d(hiddens[0], 3, kernel_size=3, stride=1, padding=1),                nn.ReLU()))        self.decoder = nn.Sequential(*modules)

首先来看编码器的部分。每个卷积模块由卷积、BN、ReLU构成。卷完了再用两个全连接层分别生成正态分布的均值和方差。注意，卷积完成后，图像的形状是​​[prev_channels, img_length, img_length]​​，为了把它输入到全连接层，我们到时候会做一个flatten操作。

# encoder
        prev_channels = 3
        modules = []
        img_length = 64
        for cur_channels in hiddens:
            modules.append(
                nn.Sequential(
                    nn.Conv2d(prev_channels,
                              cur_channels,
                              kernel_size=3,
                              stride=2,
                              padding=1), nn.BatchNorm2d(cur_channels),
                    nn.ReLU()))
            prev_channels = cur_channels
            img_length //= 2
        self.encoder = nn.Sequential(*modules)
        self.mean_linear = nn.Linear(prev_channels * img_length * img_length,
                                     latent_dim)
        self.var_linear = nn.Linear(prev_channels * img_length * img_length,
                                    latent_dim)
        self.latent_dim = latent_dim

解码器和编码器的操作基本完全相反。由于隐变量的维度是​​latent_dim​​​，需要再用一个全连接层把图像的维度投影回​​[prev_channels, img_length, img_length]​​。之后就是反卷积放大图像的过程。写这些代码时一定要算好图像的边长，定好反卷积的次数，并且不要忘记最后把图像的通道数转换回3。

# decoder
modules = []
self.decoder_projection = nn.Linear(
    latent_dim, prev_channels * img_length * img_length)
self.decoder_input_chw = (prev_channels, img_length, img_length)
for i in range(len(hiddens) - 1, 0, -1):
    modules.append(
        nn.Sequential(
            nn.ConvTranspose2d(hiddens[i],
                                hiddens[i - 1],
                                kernel_size=3,
                                stride=2,
                                padding=1,
                                output_padding=1),
            nn.BatchNorm2d(hiddens[i - 1]), nn.ReLU()))
modules.append(
    nn.Sequential(
        nn.ConvTranspose2d(hiddens[0],
                            hiddens[0],
                            kernel_size=3,
                            stride=2,
                            padding=1,
                            output_padding=1),
        nn.BatchNorm2d(hiddens[0]), nn.ReLU(),
        nn.Conv2d(hiddens[0], 3, kernel_size=3, stride=1, padding=1),
        nn.ReLU()))
self.decoder = nn.Sequential(*modules)

网络前向传播的过程如正文所述，先是用编码器编码，把图像压平送进全连接层得到均值和方差，再用​​randn_like​​​随机采样，把采样的​​z​​投影、变换成正确的维度，送入解码器，最后输出重建图像以及正态分布的均值和方差。

def forward(self, x):
    encoded = self.encoder(x)
    encoded = torch.flatten(encoded, 1)
    mean = self.mean_linear(encoded)
    logvar = self.var_linear(encoded)
    eps = torch.randn_like(logvar)
    std = torch.exp(logvar / 2)
    z = eps * std + mean
    x = self.decoder_projection(z)
    x = torch.reshape(x, (-1, *self.decoder_input_chw))
    decoded = self.decoder(x)

    return decoded, mean, logvar

用该模型随机生成图像的过程和前向传播的过程十分类似，只不过来自于标准正态分布而已，解码过程是一模一样的。

def sample(self, device='cuda'):
    z = torch.randn(1, self.latent_dim).to(device)
    x = self.decoder_projection(z)
    x = torch.reshape(x, (-1, *self.decoder_input_chw))
    decoded = self.decoder(x)
    return decoded

主函数

在主函数中，我们要先完成模型训练。在训练前，还有一件重要的事情要做：定义损失函数。

from time import time

import torch
import torch.nn.functional as F
from torchvision.transforms import ToPILImage

from dldemos.VAE.load_celebA import get_dataloader
from dldemos.VAE.model import VAE

# Hyperparameters
n_epochs = 10
kl_weight = 0.00025
lr = 0.005


def loss_fn(y, y_hat, mean, logvar):
    recons_loss = F.mse_loss(y_hat, y)
    kl_loss = torch.mean(
        -0.5 * torch.sum(1 + logvar - mean**2 - torch.exp(logvar), 1), 0)
    loss = recons_loss + kl_loss * kl_weight
    return loss

如正文所述，VAE的loss包括两部分：图像的重建误差和分布之间的KL散度。二者的比例可以通过​​kl_weight​​来控制。

KL散度的公式直接去网上照抄即可。

这里要解释一下，我们的方差为什么使用其自然对数​​logvar​​。经过我的实验，如果让模型输出方差本身的话，就要在损失函数里对齐取一次自然对数。如果方差很小，趋于0的话，方差的对数就趋于无穷。这表现在loss里会出现nan。因此，在神经网络中我们应该避免拟合要取对数的数，而是直接去拟合其对数运算结果。

准备好了损失函数，剩下就是常规的训练操作了。

def train(device, dataloader, model):
    optimizer = torch.optim.Adam(model.parameters(), lr)
    dataset_len = len(dataloader.dataset)

    begin_time = time()
    # train
    for i in range(n_epochs):
        loss_sum = 0
        for x in dataloader:
            x = x.to(device)
            y_hat, mean, logvar = model(x)
            loss = loss_fn(x, y_hat, mean, logvar)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            loss_sum += loss
        loss_sum /= dataset_len
        training_time = time() - begin_time
        minute = int(training_time // 60)
        second = int(training_time % 60)
        print(f'epoch {i}: loss {loss_sum} {minute}:{second}')
        torch.save(model.state_dict(), 'dldemos/VAE/model.pth')

训练好模型后，想要查看模型重建数据集图片的效果也很简单，去dataloader里采样、跑模型、后处理结果即可。

def reconstruct(device, dataloader, model):
    model.eval（)
    batch = next(iter(dataloader))
    x = batch[0:1, ...].to(device)
    output = model(x)[0]
    output = output[0].detach().cpu()
    input = batch[0].detach().cpu()
    combined = torch.cat((output, input), 1)
    img = ToPILImage()(combined)
    img.save('work_dirs/tmp.jpg')

想用模型随机生成图片的话，可以利用之前写好的模型采样函数。

def generate(device, model):
    model.eval（)
    output = model.sample(device)
    output = output[0].detach().cpu()
    img = ToPILImage()(output)
    img.save('work_dirs/tmp.jpg')

在3090上跑这个实验，100个epoch需要5个多小时。但是，模型差不多在10多个epoch的时候就收敛了。最朴素的VAE的重建效果并不是很好，只能大概看出个脸型。这可能也和我的模型参数较少有关。

随机生成的图片也是形状还可以，但非常模糊。

....

#Single Trajectory Distillation，STD

小红书AIGC团队提出风格迁移加速算法STD

本论文主要作者来自小红书 AIGC 团队（Dynamic-X-Lab），Dynamic‑X‑LAB 是一个专注于 AIGC 领域的研究团队，致力于推动姿态驱动的人像生成与视频动画技术。他们以高质量、高可控性的生成模型为核心，围绕文生图（t2i）、图像生成（i2i）、图像转视频（i2v）和风格迁移加速等方向展开研究，并通过完整的开源方案分享给开发者与研究者社区。

基于一致性模型（Consistency Models, CMs）的轨迹蒸馏（Trajectory Distillation）为加速扩散模型提供了一个有效框架，通过减少推理步骤来提升效率。然而，现有的一致性模型在风格化任务中会削弱风格相似性，并损害美学质量 —— 尤其是在处理从部分加噪输入开始去噪的图像到图像（image-to-image）或视频到视频（video-to-video）变换任务时问题尤为明显。

这一核心问题源于当前方法要求学生模型的概率流常微分方程（PF-ODE）轨迹在初始步骤与其不完美的教师模型对齐。这种仅限初始步骤对齐的策略无法保证整个轨迹的一致性，从而影响了生成结果的整体质量。

为了解决这一问题，文章提出了单轨迹蒸馏（Single Trajectory Distillation，STD），一个从部分噪声状态出发的训练框架。

为了抵消 STD 引入的额外时间开销，文章设计了一个轨迹状态库（Trajectory Bank），预先存储教师模型 PF-ODE 轨迹中的中间状态，从而有效减轻学生模型训练时的计算负担。这一机制确保了 STD 在训练效率上可与传统一致性模型保持一致。

此外，该工作还引入了一个非对称对抗损失（Asymmetric Adversarial Loss），可显著增强生成结果的风格一致性和感知质量。

在图像与视频风格化任务上的大量实验证明，STD 在风格相似性和美学评估方面均优于现有的加速扩散模型。

论文地址：https://arxiv.org/abs/2412.18945

项目主页：https://single-trajectory-distillation.github.io/

项目 Github: https://github.com/dynamic-X-LAB/Single-Trajectory-Distillation

项目模型：https://huggingface.co/Single-Trajectory-Distillation/Single-Trajectory-Distillation

关键词：AIGC、视频风格迁移、扩散模型加速

STD 与其他方法的差异

如图 2 所示，(a) 中的传统一致性蒸馏方法（Other CMs）从 x_0 加噪得到不同的 x_t，再拟合多条 PF-ODE 轨迹的初始部分，存在轨迹不对齐问题。而在 (b) 中，文章提出的单轨迹蒸馏（Single-Trajectory Distillation, STD）方法则从一个固定的加噪状态 x_(τ_η ) 出发，通过教师模型完整地去噪出多个 x_t，并以此为训练目标，使学生模型在一条完整轨迹上实现自一致性。这种策略有效解决了训练 - 推理路径不一致的问题，提升了整体生成质量。

为了避免从 x_(τ_η ) 开始反复推理带来的训练开销，进一步提出了轨迹缓存库（trajectory bank），用于预存教师模型轨迹中的中间状态，从而保持训练效率不变。同时，引入了非对称对抗损失（asymmetric adversarial loss），对不同噪声级别下的生成图与真实图进行对比，有效提升图像饱和度，减少纹理噪声。

前置理论

【扩散模型】

扩散模型通过多步噪声叠加模拟数据退化过程，并在生成阶段通过逆向去噪获得真实样本。基于分数匹配理论，前向过程可表述为将数据分布转化为高斯噪声的随机微分方程（SDE）：

。Song 等人证明存在概率流常微分方程（PF-ODE）与 SDE 具有相同边界概率密度，其形式为 

，其中

 为去噪模型预测的分数项。基于此可发展多种数值解法，包括 DDIM-Solver、DPM 系列等求解器。

【轨迹】

在扩散模型中，轨迹直观表征了样本在加噪与去噪过程中的演化过程，但现有研究鲜少明确定义这一概念。文章将轨迹点定义为特定时间步的边界概率密度（可通过样本分布估计），从而支持轨迹样本分布的量化分析。前向扩散 SDE 轨迹可表述为 

，其中 

；反向扩散轨迹则定义为 

。当模型充分预训练且 

 时，有 

 成立，此时 

 表示带去噪模型 ϕ 的 ODE 求解器。

【基于部分加噪的编辑】

自一致性模型通过减少推理步数实现加速，其核心在于确保任意时刻的生成函数满足不同时间步 t,t' 反向扩散到 

 的自一致性，即 

。基于蒸馏方法可高效构建一致性模型，其损失函数定义为:

其中 n 均匀采样于 {1,...,N-1}，s 为目标步长。计算期望时 

  通过 SDE 生成，而 

 由 ODE 求解器 

确定。为提升训练稳定性，采用 EMA 策略更新目标网络参数 

。

方法介绍

【单轨迹蒸馏理论】

在扩散模型中，理想情况下反向去噪轨迹应与前向扩散轨迹严格互逆。但实际中，不完美去噪模型会导致：

• 轨迹不一致性：不同起点 η,η' 的反向轨迹 

• 

•  与

• 

• 互不等价。
• 误差传播：若模型预测噪声误差为 

• 

• ，则去噪样本 

• 

•  与前向样本 

• 

•  的偏差满足：

针对图像 / 视频风格化任务中固定起点 η 的需求，提出基于一致性模型仅在固定起点的单条轨迹上做一致性蒸馏，具体包含两个关键点：

• 固定噪声强度起点 τ_η=η⋅T（即 

• 

• ）。 
• 使用教师模型 ϕ 生成完整轨迹 

• 

• ，引导学生模型 θ 学习该轨迹的自一致性。

根据第二部分对轨迹的定义，可以写出单轨迹蒸馏损失函数的表达式如下：

为降低蒸馏误差，约束学生模型学习的时间步 s 接近教师步 t： 

其中 γ 表示控制目标时间步 s 的取值下限比例因子通过缩短 t 与 s 的距离，可以减小误差上界，同时保留随机性提升模型性能。

【轨迹状态库】

在 STD 训练过程中，教师模型的全轨迹状态需通过多步 ODE-Solver 进行反向扩散，导致训练耗时显著增加。为解决此问题，提出轨迹状态库（Trajectory Bank），其存储教师模型沿反向扩散轨迹 

的中间状态。通过按采样概率 ρ 从库中随机抽取 

，可直接获取 t 时刻的轨迹状态样本，避免从 x_0 加噪至 τ_η 再逐步去噪的高耗时过程。

【非对称对抗损失】

受到 MCM 方法启发，提出非对称对抗损失函数。不同于传统方法约束

 与真实图像 

 的匹配，论文中建立 

 与 x_r 的约束关系（0<r<s），实验发现通过时间步错位可以显著增强图像风格化程度。具体实现:

其中 F 表示 DINO-v2 模型，D_ψ 表示判别器，ψ 表示判别器的可学习参数，x_r 指对 x_0 加噪 r 步后获得的样本。

 实验结果

• 训练集：Open-Sora-Plan-v1.0.0
• 测试集：wikiArt（10 张） + COCO（100 张） + 自定义 100 张图像 / 12 个视频及 15 种风格图像的测试集
• 评估指标：风格相似度（CSD）、LAION 美学评分和时间一致性（Warping Error）指标
• 对比方法：LCM / TCD / PCM / TDD / Hyper-SD / SDXL-Lightning / MCM

【对比实验】

STD 与当前多种加速方法在 8 步、6 步、4 步下进行对比，在风格相似性和美学分数上达到 SOTA 水平。其中图像生成在 NFE=8 时 CSD 分数比 Hyper-SD 提升↑0.032；视频生成的 Warping Error 达到 0.166，显著优于 MCM 的 0.257。从可视化（图 4）中可以看出 STD 方法的风格质量和图像质量显著更高；在不同 CFG 的定量指标折线图中（图 5）也表现出了更优水平。

视频效果：

，时长00:03

，时长00:03

【消融实验】

文章对单轨迹蒸馏方法、轨迹状态库以及非对称对抗损失函数做了消融实验（表 2），当使用轨迹状态库时，抵消了 STD 带来的额外 3.8 倍训练耗时，而 STD 方法和非对称对抗损失函数都显著提升了风格相似性分以及美学分。

其他重要参数的取值和特性消融实验：

STD 和非对称对抗损失强度（Fig 6）：强度越大，细节和噪点越少，对比度越强，画质越好。

不同的噪声起点（Fig 8）：η 越大，风格化程度越大，但是内容相关性越弱。

不同的目标时间步 s 的取值下限比例因子（Fig 10）：更大的 γ 值带来更低噪声，更强的非对称对抗损失产生更高对比度；γ=0.7 在风格保持与细节呈现间取得最佳平衡。

非对称对抗损失目标时间步位置（Table 3、Fig 9）：当 r<s 时风格化程度最佳，噪点最少。

【可扩展性试验】

文章进一步讨论了 STD 方法的适用范围，从 STD 的理论推导上看，该方法可用于其他任何 “基于部分噪声的图像 / 视频编辑” 任务，如 inpainting 等。为了验证猜想，文章展示了一组使用 STD 和其他加速方法用于 inpainting 的对比图。如图 7，相比 LCM 和 TCD 方法，STD 的 inpainting 效果更加自然。

结语

文章针对基于一致性模型的图像视频风格迁移加速方法，重点优化了风格相似性与美学质量。研究发现前向 SDE 轨迹中不同噪声强度会导致 PF-ODE 轨迹产生差异，据此提出基于特定噪声强度的单轨迹蒸馏方法（STD），有效解决了训练与推理轨迹不对齐问题。为降低 STD 方法的训练成本，创新性引入轨迹库机制，并采用非对称对抗损失提升生成质量。对比实验验证了本方法在风格保持与美学表现上的优越性，系统消融实验证实了各模块的有效性。该方法可扩展至部分噪声编辑任务，文章已探索了基于 STD 的图像修复应用，为后续相关工作提供新思路。

...

#Representation-Shift

高丽大学等提出“表示偏移”，统一Token压缩与FlashAttention

Transformer模型已成为AI领域的绝对主力，但其核心的自注意力（self-attention）机制存在一个“弱点”：计算和内存开销会随着输入序列（token数量）的增长而呈二次方爆炸。为了给Transformer“瘦身”，业界主要有两大流派：一是通过“Token压缩”丢弃不重要的信息，减少计算量；二是通过FlashAttention等融合内核优化GPU内存读写，提升I/O效率。然而，这两大流派长期以来“水火不容”，因为最高效的FlashAttention恰恰绕过了Token压缩方法赖以判断重要性的“注意力图”。

现在，来自韩国高丽大学、Adobe研究院和韩国科学技术院（KAIST）的研究者们提出了一种名为“表示偏移”（Representation Shift）的全新方法，巧妙地统一了这两大优化思路。这项无需训练、与模型无关的创新，使得Token压缩能够与FlashAttention无缝集成，实现了“鱼与熊掌兼得”的高效模型加速。

作者: Joonmyung Choi, Sanghyeok Lee, Byungoh Ko, Eunseo Kim, Jihyung Kil, Hyunwoo J. Kim

• 机构: 高丽大学; Adobe研究院; 韩国科学技术院 (KAIST)
• 论文标题：Representation Shift: Unifying Token Compression with FlashAttention
• 论文地址:​​ https://arxiv.org/pdf/2508.00367v1​​
• 项目地址:​​ https://github.com/mlvlab/Representation-Shift​​
• 录用会议: ICCV 2025

研究背景：Token压缩与FlashAttention的“世纪难题”

随着模型和任务复杂度的提升，Transformer需要处理的token数量越来越多，其自注意力机制的二次方计算成本和内存访问开销成为性能瓶颈。

• Token压缩：这类方法通过识别并丢弃冗余或信息量较少的token来缩短序列长度，从而直接降低计算复杂度。许多无需训练的方法依赖分析注意力图（attention map）来判断每个token的重要性。
• FlashAttention：这是一种革命性的I/O感知（I/O-aware）注意力算法，它通过分块计算、避免在GPU高带宽内存（HBM）中读写完整的注意力图，极大地减少了内存访问开销，从而实现了显著加速。

核心矛盾在于：FlashAttention的高效，正是因为它不生成完整的注意力图。这使得那些依赖注意力图进行token重要性判断的压缩方法，在与FlashAttention结合时直接“失灵”。

“表示偏移”：一种全新的重要性度量

为了解决上述矛盾，研究者提出了一种全新的、无需训练、与模型无关的token重要性度量标准——表示偏移（Representation Shift）。

其核心思想非常直观：一个token在经过模型某个计算层（如MLP层）后，其表示（representation）发生的变化越大，说明模型认为这个token越重要，并对其进行了更深度的加工。

如下图所示，该方法通过计算一个token在进入和离开MLP层（或注意力层）前后的表示向量之间的L2距离，来量化这种“偏移程度”，并以此作为其重要性的度量。

这种方法的巨大优势在于：

1. 完全不依赖注意力图，因此可以与FlashAttention完美兼容。
2. 无需训练，可以即插即用地应用于任何预训练好的模型。
3. 模型无关，不仅适用于Transformer，还能推广到CNN和状态空间模型（SSMs）。

实验与结果分析

视频理解

如上表所示，由于表征偏移能与FlashAttention兼容，该方法在UMT-B和UMT-L上分别实现5.47倍和5.5倍加速，吞吐量达到传统注意力剪枝方法的近两倍。尽管推理速度更快，该方法仍保持竞争力甚至更优性能——在ActivityNet上UMT-L的R@1指标最高提升9.7%，平均提升7.2%。值得注意的是，采用表征偏移的UMT-L(66 vid/s)在吞吐量达到基础UMT-B(32 vid/s)两倍的同时，性能持续领先。

在相同压缩率下，表征偏移使UMT-B和UMT-L分别获得3.74倍和3.67倍加速，且性能下降极小。原vid-TLDR因使用注意力度量无法兼容FlashAttention，而表征偏移成功解决了这一问题。

在视频问答任务(MSRVTT-QA、MSVD-QA)中，如上表所示，相比基线模型，所提出方法在UMT-B/L上分别实现约4倍/3.83倍吞吐量提升。UMT-L在MSRVTT和MSVD上性能还显著提升0.5%和0.7%，在加速同时保持性能优势。

图像分类

针对 Transformer 图像分类性能。如上表所示，在DeiT的[1,4,7]层剪枝20%token时，表征偏移方法结合FlashAttention使DeiT-T/S/B的top-1准确率分别提升2.8%、5.7%和2.7%，吞吐量提高1.2倍，显著优于基于注意力分数的方法(EViT[33]、BAT[39])。这表明表征偏移能提供更鲁棒的重要性评估。

针对CNN架构，在ResNet第一阶段剪除8行8列、第二阶段剪除4行4列后，两种方法均实现至少18%加速。其中L-W方法在ResNet-34/50上分别达到7112/3553 img/s的吞吐量，性能接近未剪枝模型。

在状态空间模型(Vision Mamba[77])的实验中(表7)，表征偏移方法在ViM-T上取得0.4%准确率提升，同时保持与ToP-ViM[74]相当的吞吐量。这些结果验证了表征偏移对不同架构的通用性。

定性结果

各阶段的表征偏移可视化

论文贡献与价值

这项研究的核心贡献在于：

1. 统一优化路径：首次提出了一种能够将Token压缩与FlashAttention等I/O感知注意力内核无缝结合的无需训练的方法，解决了两者之间的根本不兼容问题。
2. 提出新颖度量：引入“表示偏移”作为一种全新的、高效且通用的token重要性度量标准。
3. 强大的通用性：证明了该方法不仅适用于Transformer，还能有效推广到CNN和状态空间模型，具有广泛的应用前景。
4. 开源社区贡献：代码将开源。

总而言之，“表示偏移”为解决大模型时代的效率瓶颈提供了一个优雅且强大的新范式，让追求极致性能的道路上不再有“二选一”的烦恼。

....

#尝试终结Attention Sink起因的讨论

文章提出并论证：Attention Sink 源自 Transformer 需要“上下文相关的恒等层”——深层用第一个 token 的极小 key/value 作为可学习的 k_zero，使 Softmax 精确地输出 0 实现恒等映射；早期解码、非归一化注意力和门控机制等实验均支持这一解释。

Attention Sink来源于Transformer需要Context Aware的Identity Layer，即需要Attention Block根据Context不输出任何变化的能力。

背景：

最早是Streaming LLM发现了这一个现象，越深的层越会关注第一个token，成为Attention Sink，但是没有解释原因。

​​https://arxiv.org/abs/2309.17453​​

But Why？

在我的认知里面，似乎至今没有论文给出一个令人信服的解释，关于为什么模型会有如此的表现，去年有一个工作(https://arxiv.org/pdf/2410.10781)专门做了empirical study来研究一些规律：

​​https://arxiv.org/pdf/2410.10781​​

Understanding Attention Sink

我们尝试来提出一个假设，来解释所有的Attention Sink相关的实验：

Attention Sink来源于Transformer需要Context Aware的Identity Layer，即需要Attention Block根据Context不输出任何变化的能力。

证据一：首个token的value几乎为0

​​https://arxiv.org/pdf/2410.10781​​

empirical study的图中第一行第三列的图可以发现，第一个token的value的norm非常小，意味着即使被attend到，对最终结果的贡献也不会太大，那模型为什么要attend一个0呢？

• 对于前面两、三个token而言，模型学到的就是bigram和trigram，这些都是比较简单的任务，有理由认为不需要很深的层就可以完成。
• 假设这个时候浅层已经输出了答案，深层要做的事情就是保持恒等变换。

但是Attention Block如何做恒等变化呢？

• 考虑残差，也就是Attention如何输出 0 ，这样实现整个block完成恒等变换。
• 由于每个token每一层是否要恒等的情况不一样（data dependent），所以不能靠  这样的静态参数来实现。
• 那么必须靠Softmax Attention来实现，也就是key空间里面必须存在一个特殊的key： ，这个key的value是 0 ，且需要模型在想要输出 0 的时候可以精确的attend到。
• 这也意味着模型必须给这个  分配一个单独的子空间，这个  和所有的其他key都是正交或者负相关的，这样可以保证  夹角很小的时候  的分数最高，实现 attend到sink token并输出0。
• 同时这个key的模长也必须比较小，这样在不需要输出恒等的时候，对正常的Attention结果尽量产生小的影响。如下图所示。

sink token和其余token的key会有什么区别

​​https://arxiv.org/pdf/2410.10781​​

empirical study的图中实验图的第二行第二列也可以看出，sink发生的时候，其他key的相似度几乎都是0或者负的，同时第一行第二列可以看出第一个token的key的模长显著小，这佐证了我们的猜想。​

证据二：模型存在early decoding，且越深的层sink越明显

我们如果用lm head去probe中间层feat预测的token，我们可以发现模型确实存在浅层就完成编码的情况。即从中间某层开始，输出的Top-1和最后一层输出的Top-1相同。

而如果我们probe不同层的Attention map，Attention Sink也确实在深层更加明显，这进一步佐证了我们的猜想。

（部分实验图片可能涉密，无法公开，这里仅分享结论）​

证据三：非归一化或者非正定kernel会消除sink

假设手动设置一个和所有key的相似度都为1，value为0的虚拟token（等价于相当于给Softmax的分母加上了一个e），这个时候理论上会缓解sink。 @小明同学(https://www.zhihu.com/people/989c111b1fcd2a02482616583338b6e9) 进行了实验，验证了这个猜想。

​​https://arxiv.org/pdf/2410.10781​​

同时empirical study的论文（上图）发现了非归一化的Attention没有sink问题，也佐证了我们的猜想。 如果模型score不一定非负，那么也可以组合出0的Attention，也不会有sink。​

证据四：Attention Sink浪费了dim，Gate可以解决

Attention Sink导致必须给k_\text{zero}分配一个子空间，我们合理怀疑这个会产生dim的浪费（给分母加e也无法解决）。一个想法是使用gating操作，使得模型可以data-dep的输出0.
正好Qwen最近做了这个实验：

​​https://arxiv.org/pdf/2505.06708​​

先不谈效果提升幅度，他们发现Attention在输出阶段（G1）加入gate最有效，且消除了Attention Sink。这和我们的猜想一致（在G2、G3、G4都不能使得Attention输出0，但是G1可以）。​

总结

Transformer模型中的Attention Sink现象很可能源于模型对context-aware的identity layer的内在需求。多项经验性证据支持这一假设：

• Sink token的value接近于0，且key有专用子空间；
• Transformer存在early decoding，且更深的层恰好sink更严重；
• 通过非归一化或非正的注意力核会移除Attention Sink；
• 门控机制能够消除Attention Sink，且可能因为解决子空间浪费从而提升性能。

这一假设为Attention Sink提供了一个连贯的解释，并得到了来自多项实验的经验性证据支持。欢迎讨论。

#AFOG

当注意力机制成“内鬼”，巧妙瓦解目标检测Transformer

本篇介绍的论文是《Adversarial Attention Perturbations for Large Object Detection Transformers》，这项研究来自佐治亚理工学院等机构，并已被ICCV 2025会议接收。

研究者们提出了一种名为“注意力聚焦攻击梯度”（AFOG）的新型对抗性攻击方法，它能像“精确制导”一样，找到并攻击大型目标检测模型（特别是Transformer架构）最脆弱的区域，导致其失效。实验表明，AFOG的攻击性能在某些情况下甚至比现有SOTA方法高出 83%，同时生成的扰动更难以被察觉，攻击速度也更快。

• 论文标题：Adversarial Attention Perturbations for Large Object Detection Transformers
• 作者：Zachary Yahn, Selim Furkan Tekin, Fatih Ilhan, Sihao Hu, Tiansheng Huang, Yichang Xu, Margaret Loper, Ling Liu
• 机构：佐治亚理工学院、Georgia Tech Research Institute
• 论文地址：https://arxiv.org/pdf/2508.02987v1
• 项目地址：https://github.com/zacharyyahn/AFOG
• 会议：ICCV 2025

研究背景与意义

对抗性攻击（Adversarial Attack）是检验神经网络“智商”和“视力”的一种方式。它通过在输入数据（如图片）上添加人眼难以察觉的微小扰动，来欺骗训练有素的AI模型，使其做出错误的判断。这对于评估和提升AI系统（尤其是在自动驾驶、安防等关键领域）的安全性至关重要。

近年来，基于Transformer的检测器（如DETR）因其出色的性能而备受关注。然而，现有的对抗性攻击方法大多是为传统CNN架构设计的，在攻击这些新型的Transformer模型时显得力不从心。如何有效评估并攻击这些大型检测Transformer，揭示其潜在的脆弱性，成为了一个亟待解决的问题。

AFOG：注意力聚焦攻击方法

为了解决上述问题，研究者提出了 注意力聚焦攻击梯度（Attention-Focused Offensive Gradient, AFOG） 方法。其核心思想是利用一个可学习的对抗性注意力机制，智能地将攻击“火力”（即扰动）集中到图像中最容易让模型犯错的区域。

AFOG的整体攻击框架如下图所示。在攻击的每次迭代中，它会同时做两件事：

1. 通过计算边界框（bounding-box）和分类（class）的损失梯度来更新对抗性扰动。
2. 通过一个对抗性注意力模块（Adversarial Attention Map）来学习如何调整每个像素上的扰动强度，即对脆弱区域进行“放大增强”，对非关键区域进行“抑制削弱”，从而实现对扰动的精确聚焦。

这种设计使得AFOG具有“模型架构无关性”，不仅能有效攻击Transformer检测器，对传统的CNN检测器同样有效。

下图展示了AFOG的注意力图在攻击迭代过程中的演变。初始时，注意力会学习图像中的重要区域（如物体本身），然后通过迭代不断优化，最终找到前景和背景中最脆弱的像素进行攻击，甚至包括一些意想不到的区域（比如小船上方的天空）。

实验设计与结果分析

研究团队在COCO数据集上，对包括DETR、Swin Transformer在内的12个大型检测Transformer和多种CNN检测器进行了全面的实验。

攻击效果可视化

从下图的攻击案例可以看出，AFOG生成的微小扰动在视觉上几乎无法察觉，但却能让强大的DETR模型完全“失明”，无法检测出原图中清晰可见的物体。

下图展示了更多攻击成功的例子，涵盖了不同类别、尺度、光照和纹理的物体，证明了AFOG的广泛有效性。

性能对比

与现有的SOTA攻击方法相比，AFOG在攻击DETR和Swin等Transformer模型时，将模型的mAP（平均精度均值，越低表示攻击越成功）降得更低，展现出更强的攻击性能。

AFOG在12个检测Transformer上的有效性，通过受扰图像上的mAP进行测量。

AFOG与DETR和Swin上其他最先进的目标检测攻击的比较基准

同时，AFOG在攻击基于CNN的经典检测器时，效果同样优于其他方法。

效率与隐蔽性

如下表所示，AFOG在攻击速度（t）和扰动隐蔽性（L2、L0、SSIM等指标）方面均表现出色，做到了“又快又好”。

注意力机制的贡献

为了验证其核心创新点——“对抗性注意力机制”的有效性，研究者进行了消融实验。结果显示，与不带注意力的版本相比，完整的AFOG性能平均提升了15.1%，在InternImage模型上提升幅度高达 30.6%，证明了注意力机制的巨大价值。

攻击机理分析

研究者还深入分析了AFOG是如何“搞破坏”的。下图通过可视化DETR编码器自注意力图的变化，揭示了AFOG的攻击过程。在攻击初期，模型能正确地将大象身体的各个部分关联起来。随着攻击迭代，这种关联性被逐渐破坏，最终导致模型无法识别出完整的大象。

当然，AFOG也并非万能。在一些情况下，如果AFOG生成的对抗性注意力图没能聚焦到关键结构，或者无法有效破坏模型编码器的自注意力结构，攻击便会失败。

论文贡献与价值

1. 提出AFOG方法：首次提出一种基于可学习注意力机制的对抗性攻击方法，专门用于高效攻击大型目标检测Transformer。
2. 架构无关性：AFOG的设计使其能够统一攻击基于Transformer和CNN的多种检测器，具有很强的通用性。
3. SOTA性能：在COCO数据集上对12个大型检测器进行了广泛验证，性能超越现有方法，同时兼具速度和隐蔽性。
4. 开源社区贡献：研究者开源了代码，方便社区进行复现和进一步的研究，共同推进AI安全领域的发展。

总而言之，AFOG不仅提供了一个强大的工具来探查当前最先进的目标检测器的“软肋”，也为设计更鲁棒、更安全的AI模型指明了方向。

....