51c视觉~合集23_细长目标标记-CSDN博客

本文链接：https://blog.csdn.net/weixin_49587977/article/details/144233683

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

#工业缺陷检测中数据标注需要注意的几个事项

在工业场景中，网络结构决定了下限，数据决定着上限，要想模型有好的表现，数据是至关重要的。下面就这个项目来说一说，工业缺陷检测在标注数据时需要注意的几个事项：

1、离得比较近的缺陷就合并在一个框里

编辑

以上两个图里的缺陷都是可以合并的，一是为了保持缺陷的完整性，同一个缺陷被标注成好多个，会给神经网络造成误解，同时也避免出现多个小目标。

2、尽量不要有太细长的目标

神经网络的卷积基本上都是3*3的，而且先验框anchor在设计宽高比时一般也是在1左右，回归非常细长的目标，需要比较大的感受野和宽高比，不一定能做得很好。如图左边那块目标，可以合并一下，稍微标大一点，把长宽比例搞得居中一点。

编辑

3、不要打太小的目标，比如低于10x10像素的

模型一般都对小目标不敏感，除非采用比较好的trick，就拿YOLOv4来说，到第三次下采样的特征图才拿去后面做检测，也就是在原图上最小都有8个像素，才能在特征图上体现为1个像素。有人会杠了，那我的目标就是小目标啊，小哥，我说了，另外还有很多trick的，不在本文讨论范围，打标签这个环节你要么打大点，要么不要打，或者把局部区域放大成大图，再打标签，不然送到模型里头，也是没用的。这跟严谨不严谨没有任何关系。

编辑

YOLOv4网络结构图

4、不要标注特别不明显的特征

这一条相信都能理解，特征连人都认不出来，哪个网络都不好识别吧。像这种标注框，恐怕谁都不好认吧。

编辑

5、框的位置尽量准确一点，把缺陷部分刚好框进去

像右下角那个框，完全可以打大点吧。

编辑

6、需要检测的缺陷在训练集中至少要出现一次相似的

另外，需要多说一句，跟标注无关的。就是虽然都是缺陷，但实际上也分很多种的，如果训练集里都没有出现过相似的，就基本上别指望测试时能够检测出来了。比如下图中，虽然只划分了一类缺陷，但是从特征的角度来说，实际上已经是好几类了，比如划痕、凸起、裂开。还是回到开头那句话：网络结构决定了下限，数据决定上限。目前的技术，不靠大量的数据喂，是训练不出很好的模型的。

#PGTFormer

首个视频人脸修复技术！让人脸细节更清晰！

本篇分享 IJCAI 2024 论文Beyond Alignment: Blind Video Face Restoration via Parsing-Guided Temporal-Coherent Transformer，西电、西南科大联合提出首个视频人脸修复技术！让人脸细节更清晰！

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

论文主页：https://kepengxu.github.io/projects/pgtformer/

开源代码地址：https://github.com/kepengxu/PGTFormer

研究者主页：https://kepengxu.github.io

引言

视频人脸恢复结果。左侧是输入的低质量视频人脸，右侧是通过PGTFormer恢复后的高质量人脸。

在计算机视觉领域，视频人脸恢复一直是一个备受关注的研究方向。然而，大多数现有的方法主要针对静态图像，无法有效处理视频中的时序信息，往往需要繁琐的对齐操作，并且在面对长视频时，容易出现恢复结果不一致的问题。

针对这些挑战，研究者首创性地提出了PGTFormer（Parsing-Guided Temporal-Coherent Transformer），这是第一个专门为视频人脸恢复设计的方法。PGTFormer采用了端到端的设计，摒弃了传统方法中的复杂对齐步骤，实现了更加高效和连贯的视频人脸恢复。

方法介绍

设计动机

框架对比

图中展示了过去方案和PGTFormer在处理视频人脸恢复时的不同流程。(a)展示过去方案需要对齐操作的复杂流程，(b)展示PGTFormer的方法，完全省去了对齐步骤，直接实现了端到端的视频恢复。

现有的视频人脸恢复方法面临的主要问题在于时序一致性和对齐的复杂度。许多方法为了保持视频帧间的一致性，依赖于对帧进行精确对齐，这不仅增加了计算复杂度，还可能引入对齐误差，导致恢复效果不佳。

为了克服这些问题，研究者设计了PGTFormer。该方法通过引入解析引导和时序一致性建模，完全抛弃了对齐操作，实现了端到端的视频人脸恢复。这一创新设计大大简化了处理流程，同时显著提升了恢复结果的连贯性和视觉效果。

网络结构

图中详细展示了PGTFormer的网络结构。图中还展示了TS-VQGAN与PGTFormer之间的协作关系，说明了两阶段训练的过程。

PGTFormer的网络结构旨在从根本上解决视频人脸恢复中的关键难题。其训练过程分为两个主要阶段：

第一阶段 - 训练TS-VQGAN（时空VQGAN）：在这个阶段，研究者首先训练TS-VQGAN，该模型通过嵌入高质量的视频人脸先验信息，为PGTFormer后续的恢复任务提供了强大的基础。TS-VQGAN能够有效地捕捉和表示高质量人脸的空间和时间特征，生成与真实人脸非常接近的先验嵌入。这些嵌入在后续步骤中将作为PGTFormer的查询目标。
第二阶段 - 训练PGTFormer：在第二阶段，PGTFormer通过人脸解析模块和时空Transformer模块，利用第一阶段中训练得到的高质量视频人脸先验，完成视频人脸恢复任务。具体而言，PGTFormer首先解析输入的低质量视频帧，提取出关键的面部特征，然后通过时空Transformer模块，从TS-VQGAN生成的高质量人脸先验中查询相应的细节信息。最终，解码器将这些查询得到的高质量特征整合到原始视频中，输出高清且时序一致性强的恢复视频。

实验结果

为了验证PGTFormer的有效性，研究者在多个公开数据集上与其他最先进的方法进行了对比。以下是PGTFormer与其他方法在多个定量指标上的表现，涵盖了在对齐和非对齐人脸视频上的训练和测试结果。

定量实验结果

如表格所示，PGTFormer在多个关键指标上显著超越了现有的最先进方法，具体包括：

PSNR（峰值信噪比）：PGTFormer在对齐人脸视频和非对齐人脸视频上的PSNR值分别达到了30.74和29.66，明显高于其他方法，表明其在重建图像质量上的强大能力。
SSIM（结构相似性）：PGTFormer在SSIM指标上也展现了卓越的表现，在对齐和非对齐数据集上的SSIM值分别为0.8668和0.8408，远高于其他竞争方法，证明了PGTFormer在保持结构一致性方面的优势。
LPIPS（感知相似度）：PGTFormer在LPIPS指标上取得了最低值，分别为0.2095（对齐）和0.2230（非对齐），表明在主观视觉感受上，PGTFormer生成的图像与高质量图像的差异最小，具有更好的视觉效果。
Deg、LMD、TLME、MSRL：在这些用于评价面部特征、扭曲程度、时间一致性和细节保留的指标上，PGTFormer也全面领先于其他方法，展现出极强的全方位恢复能力。

主观对比结果

除了定量评价外，研究者还进行了大量的主观视觉对比实验。主观结果清晰地展示了PGTFormer在恢复视频人脸时的卓越表现：

视觉结果

图中展示了PGTFormer与其他方法在视觉效果上的差异。可以看到PGTFormer在细节保留、伪影去除以及及面部自然度上明显优于其他方法。

主观视觉对比结果表明，PGTFormer能够有效恢复面部细节，如眼睛、嘴巴的轮廓和纹理。与其他方法相比，PGTFormer生成的面部更加生动，色彩还原度更高，几乎没有伪影和不自然的过渡。

结论

PGTFormer作为第一个专门为视频人脸恢复设计的方法，在该领域中开创了一个新的方向。其端到端的设计彻底解决了传统方法中对齐操作复杂且易引入误差的问题，同时通过解析引导和时序一致性建模，实现了高效、自然的视频人脸恢复。

未来，研究者计划进一步优化网络结构，并将其应用到更广泛的视频增强任务中，期待PGTFormer能够在更多实际场景中展现出卓越的性能。

#自动驾驶场景下面向真实世界布局的转变

本文提出一种新颖的多模态场景适应方法DCF，被ACM Multimedia 2024提名为口头报告（Oral Presentation，3.97%）。本方法通过手工设计的基于深度感知的类别过滤器，手动将自动驾驶场景的物体分类为近景，中景，远景，并且将不符合预先定义分布的数据进行过滤，实现由虚拟到真实世界分布的转变。提出的方法显著提高了小物体类别的性能，并能灵活地迁移到不同模型，取得SOTA结果。

论文一作陈牧是来自澳大利亚悉尼科技大学ReLER Lab的在读博士，导师为杨易教授。近两年在视觉及多媒体领域顶级会议发表多篇一作论文，并担任T-PAMI等ACM/IEEE顶级期刊和会议审稿人。主要研究兴趣为计算机视觉，包括视觉场景理解、视频分割、领域自适应、以人为中心的场景交互等。更多信息见个人主页：https://chen742.github.io

引用：

@inproceedings{chen2024transferring,
  title={Transferring to Real-World Layouts: A Depth-aware Framework for Scene Adaptation},
  author={Chen, Mu and Zheng, Zhedong and Yang, Yi },
  booktitle={ACM Multimedia},
  year={2024}
}

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

代码地址：https://github.com/chen742/DCF

作者主页：https://chen742.github.io

Abstract

通过无监督领域自适应（UDA）进行场景分割，可以将从源合成数据中获得的知识转移到现实世界的目标数据，从而大大减少了在目标领域中手动标注像素级别的需求。为了促进领域不变特征的学习，现有的方法通常通过简单地复制和粘贴像素，将源领域和目标领域的数据混合。这种简单的方法通常是次优的，因为它们没有考虑混合的布局与现实场景的匹配程度。现实场景具有固有的布局特征。我们观察到，诸如人行道、建筑物和天空等语义类别，显示出相对一致的深度分布，并且在深度图中可以清晰地区分。由于不合理的混合，模型在预测目标领域时会出现混淆。例如，将近处的“行人”像素直接粘贴到远处的“天空”区域是没有意义的。基于这一观察，我们提出了一个深度感知框架，显式利用深度估计来混合类别，并在端到端的方式中促进两个互补任务，即分割和深度学习。特别地，该框架包含一个用于数据增强的深度引导上下文过滤器（DCF）和一个用于上下文学习的跨任务编码器。DCF模拟了现实世界的布局，而跨任务编码器进一步自适应地融合了两个任务之间的互补特征。此外，几个公共数据集没有提供深度标注，因此我们利用现成的深度估计网络来获取伪深度。大量实验表明，我们的方法即使使用伪深度，也能取得具有竞争力的性能。

Introduction

语义分割是机器视觉中的一项基本任务，支持着众多视觉应用。在过去的几年里，语义分割取得了显著的进展。值得注意的是，现有的主流模型通常需要大规模的高质量标注数据集，例如ADE20K，才能获得良好的性能。然而，在现实世界中，获取像素级别的标注数据通常代价高昂且耗时。一种直接的解决方案是使用合成数据进行网络训练，因为合成数据的像素级别标注相对容易获得。然而，由于天气、光照和道路设计等多种因素，使用合成数据训练的网络在实际应用中表现出较差的可扩展性。因此，研究人员转向无监督领域自适应（UDA）以应对不同领域间的差异。UDA方法的一个分支试图通过对齐领域分布来减轻领域偏移。另一种可能的范式是自训练，它通过递归地优化目标伪标签来逐步减少领域偏移。更进一步，最近的DACS方法及其后续工作结合了自训练和ClassMix方法，在源域和目标域之间混合图像。通过这种方式，这些方法能够创建高度扰动的样本，以促进两个领域之间共享知识的学习，从而辅助训练。具体而言，跨域混合的目标是将某些类别的对应区域从源域图像中复制并粘贴到未标注的目标域图像中。然而，我们注意到，这种简单的策略会导致将大量对象粘贴到不合理的深度位置。这是因为每个类别在深度分布上都有其特定的位置。例如，背景类如“天空”和“植被”通常出现在较远的位置，而占用像素较少的类别如“交通志”和“电杆”通常出现在较近的位置。这种合成的训练数据会损害上下文学习，导致特别是在小物体的定位预测性能上表现不佳。为了解决这些局限性，我们观察了现实世界中的深度分布，发现语义类别在深度图中可以轻松分离（解耦），因为在特定场景（例如城市场景）下，它们遵循相似的分布。因此，我们提出了一个新的深度感知框架，该框架包含深度上下文过滤器（DCF）和一个跨任务编码器。具体而言，DCF利用深度信息去除与现实世界目标训练样本不匹配的非现实类别。另一方面，多模态数据可以提高深度表示的性能，因此有效利用这些深度多任务特征以提高最终预测的准确性显得尤为关键。我们提出的跨任务编码器包含两个特定的头部，用于为每个任务生成中间特征，并且包含一个自适应特征优化模块（AFO）。AFO鼓励网络通过端到端的方式来优化融合的多任务特征。具体来说，所提出的AFO采用了一系列Transformer模块来捕捉区分不同类别所需的关键信息，并为区分性特征分配高权重，反之亦然。

我们的主要贡献如下：

（1）我们提出了一个简单的深度引导上下文过滤器（DCF），以显式利用深度图中隐藏的关键语义类别分布，增强跨域信息混合的现实性，并优化跨域布局混合。

（2）我们提出了一个自适应特征优化模块（AFO），使跨任务编码器能够利用区分性的深度信息，并将其嵌入到视觉特征中，从而共同促进语义分割和伪深度估计。

（3）尽管方法简单，但通过广泛的消融实验验证了我们提出的方法的有效性。尽管使用的是伪深度，我们的方法在两个常用的场景自适应基准上仍然取得了具有竞争力的准确性，即在GTA→Cityscapes任务上达到77.7 mIoU，在Synthia→Cityscapes任务上达到69.3 mIoU。

Method1. Problem Formulation

在一般的 UDA 设置中, 标签丰富的合成数据被用作源域 , 而标签稀缺的真实世界数据被视为目标域。例如，我们在源域中从源域数据采样个标记的训练样本 , 其中是第 i 个样本数据, 就是对应的语义分割真实标签，是深度估计任务的标签。相应的，我们有 m 个从目标域数据采样的未标记目标图像 , 被标记为 , 其中是目标域中第 i 个的未标记样本, 是深度估计任务的标签。由于公共数据集不支持深度信息标注, 因此我们采用了现成模型可以简单生成的伪深度图。

2. Depth-guided Contextual Filter

在UDA中，最近的工作通过混合像素的策略来生成跨域增强样本。典型的混合是从源域图像复制一组像素，并将这些像素粘贴到目标域图像的一组像素。由于源和目标领域数据之间的不同布局，要想制作高质量的跨领域混合样本进行训练对这种普通方法具有挑战性。为了减少噪声信号并使用真实世界的布局模拟增强的训练样本，我们提出了Depth-guided Contextual Filter来减少跨域混合的噪声像素。

基于大多数语义类别通常属于有限深度范围的假设，我们引入DCF，将目标深度图划分为几个离散的深度区间。DCF的实现在Algorithm中用伪代码表示如下：

Algorithm

DCF的实现被表示为Algorithm 1中的伪代码，其中图像和对应的语义标签是从源域数据中采样的。图像和深度标签来自目标域数据。然后生成伪标签：

对于给定真实世界目标输入图像 , 我们有对应的伪标签和目标域的深度图组合。在每个深度间隔中，对于每个类都是可以预先计算。例如，深度间隔处的类别 i 的密度值被计算为。所有的密度值构成目标域图像中的深度分布。然后我们随机选择源图像上的一半类别。在实际过程中，我们应用二进制掩码来表示相应的像素。然后, 朴素跨域混合图像和混合标签可以公式化为:

⊙表示掩模和图像之间的逐元素乘法, 图 2 显示了原始混合图像。可以观察到, 由于两个域之间的深度分布差异, "Building"类别的像素从源域混合到目标域的过程中, 产生了不真实的图像。使用这样的训练样本进行训练将损害上下文学习。因此, 我们建议对混合图像中与深度密度分布不匹配的像素进行过滤。初始混合后, 我们在每个深度区间重新计算每一类的密度值。例如处的类 i 的新密度值表示为 , 然后，我们计算每个粘贴类别的深度密度分布差异，并将深度间隔处的类别 i 的差异表示为旦超过该类别的阈值，这些粘贴的像素就会被删除。执行 DCF 后，我们确认最终要混合的真实像素并构造一个深度感知的根据当前目标图像的深度布局动态变化的二进制掩模，

然后生成过滤后的混合样本。在实践中，我们直接应用更新过的深度感知掩模来替换原始掩模。因此，新的混合样本和标签如下：

过滤后的样本如图2所示。由于“sky”和““terrain””等大物体通常聚集并占据大量像素，而小物体在一定深度范围内只占据少量像素，因此我们设置不同的像素。每个类别的过滤阈值。因为没有可用的真实label的基本事实，所以DCF对目标域使用伪语义标签。由于早期标签预测不稳定，我们采用warmup策略在10000次迭代后执行DCF的时候。输入图像、简单混合样本和过滤样本的示例如图2所示。经过DCF模块处理后的样本具有来自源域的像素与目标域的深度分布相匹配，帮助网络更好地处理域差距。

3. Multi-task Scene Adaptation Framework

为了利用分割和深度学习之间的关系，我们引入了一个多任务场景适应框架，包括高分辨率语义编码器和具有特征优化模块的跨任务共享编码器，如图3所示。框架整合并优化了深度信息的融合，以改进最终的语义预测。

High Resolution Semantic Prediction. 大多数监督方法使用高分辨率图像进行训练，但常见的场景适应方法通常使用全分辨率一半的图像随机裁剪。为了减少场景适应和监督学习之间的域差距，同时保持GPU内存消耗，我们采用高分辨率编码器来编码全分辨率一半的图像。为了缩小场景适应和监督学习之间的领域差距，同时保持GPU内存消耗，我们采用高分辨率编码器将HR图像作物编码为深度HR特征。然后使用语义解码器生成HR语义预测。这里，我们采用交叉熵损失进行语义分割：

这里和都是高分辨率语义预测的结果。是源域的 one-hot 语义标签, 是深度感知融合域的 one-hot 伪标签。

Adaptive Feature Optimization. 除了高分辨率编码器之外，我们还使用另一个跨任务编码器来编码两个任务共享的输入图像。深度图富含空间深度信息，但是深度信息直接与视觉信息的简单串联会造成一些干扰，例如相似深度位置的类别已经可以通过视觉信息很好地区分，注意力机制可以帮助网络选择多任务信息中的关键部分。在所提出的多任务学习框架中，视觉语义特征和深度特征分别由视觉头和深度头生成。如图 3 所示，应用批量归一化后，自适应特征优化模块将归一化的输入视觉特征和输入深度特征连接起来，以创建融合的多任务特征：

CONCAT(,)表示串联操作。融合的特征被输入到一系列转换器块中，以捕获两个任务之间的关键信息。注意力机制自适应地调整深度特征嵌入视觉特征的程度。

是transformer参数。Transformer blocks的学习输出是权重图γ，它乘回到输入视觉特征和深度特征，从而为每个任务产生优化的特征。

表示卷积参数, 表示卷积运算, 表示 sigmoid 函数。权重矩阵执行多任务特征的自适应优化。然后将融合后的特征输入不同的解码器以预测不同的最终任务,即视觉和深度任务。输出特征本质上是包含关键深度信息的多模态的特征。

其中⊙表示逐元素乘法。然后，优化的视觉和深度特征被输入多模通信模块进行进一步处理。多模态通信模块通过迭代使用 transformer blocks 来细化两个任务之间关键信息的学习。在特征优化完成后, 推断仅仅基于视觉输入。最终的语义预测和深度预测可以通过视觉头和深度头根据最终视觉特征和深度特征生成。与高分辨率预测类似，这里我们使用交叉熵损失进行语义损失计算：

我们还在源域使用berHu损失进行深度回归：

其中，和分别是预测的和真实语义标签图。根据SPIGAN[61]和Suman Saha[63]的工作，我们采用了反向Huber损失函数[71]，其定义为：

其中H是正阈值，我们将其设置为最大深度残差的0.2。最后，总损失函数为：

其中超参数深度是损失重量。考虑到我们的主要任务是语义分割, 深度估计是辅助任务, 我们经验地得出 , 我们还设计了消融研究, 以改变深度任务的权重参数的数量级为或。

ExperimentImplementation Details

数据集。我们在两个场景适应设置上评估了所提出的框架，即，GTA→Cityscapes和SYNTHIA→Cityscapes。GTA5数据集是从视频游戏收集的合成数据集，其包含由19个类注释的24966个图像。对于深度估计，我们采用了由Monodepth 2模型生成的深度信息，该模型仅在GTA图像序列上训练。SYNTHIA是一个包含9400个训练图像和16个类别的合成城市场景数据集。这里直接使用SYNTHIA所提供的模拟深度信息。GTA和SYNTHIA作为源域数据集。目标域数据集是Cityscapes，它是从真实世界的街景图像中收集的。Cityscapes包含2975个未标记的训练图像和500个验证图像。Cityscapes的分辨率为2048×1024，通用协议将尺寸缩小到1024 × 512以节省存储器。我们利用并集交集（IoU）来计算每个类的性能，并利用所有类的并集交集平均值（mIoU）来报告结果。该代码基于Pytorch。我们将使我们的代码开放源代码，以重现所有实验结果。

实验设置。我们采用DAFormer网络和MiT-B5骨干网实现高分辨率编码器，采用DeepLabV 2网络和ResNet-101骨干网实现跨任务编码器，来减少内存消耗。所有主干均使用ImageNet预训练进行初始化。我们的训练过程基于具有跨域混合的自训练方法，并通过我们提出的深度引导上下文过滤器来增强。输入图像分辨率对于跨任务编码器是全分辨率的一半，对于高分辨率编码器是全分辨率。我们使用相同的数据增强，例如，颜色抖动和高斯模糊，并根据经验设置伪标签阈值0.968。我们在Tesla V100 GPU上设置batch size大小为2训练网络，进行40000次迭代。

Comparison with SOTA

GTA→城市景观结果。

我们在GTA到Cityscapes的数据集迁移上展示了我们的实验结果。表1中显示了GTA到Cityscapes的结果，并用粗体标出了最佳成绩。可以看出，我们的方法相比于最先进的MIC[1]方法，在平均交并比（mIoU）上从75.9提升到了77.7，表现出了显著的性能改进。通常情况下，占据像素较少的类别较难适应，并且通常具有相对较低的IoU性能。然而，我们的方法在大多数类别上表现出有竞争力的IoU提升，特别是在小物体上，例如，““Rider”,”提高了+5.7，“Fence”提高了+5.4，“Wall”提高了+5.2，““Traffic Sign”提高了+4.4，“Pole”提高了+3.4。这一结果表明了所提出的上下文过滤器和跨任务学习框架在上下文学习中的有效性。我们的方法同样也对那些占据图像大量像素的大类别的mIoU性能有所提高，但提升幅度较小，比如“Pedestrain”提高了+1.8，“Bike”提高了+1.1，这可能是因为丰富的纹理和颜色信息已经具备了识别这些相对容易的类别的能力。上述观察也在图4中定性地反映出来，在该图中我们展示了所提出的方法与之前强大的基于变换器的方法HRDA[23]和MIC[1]的分割结果对比。用白色虚线框突出显示的定性结果表明，所提出的方法在挑战性的“Traffic Sign”和大类别“Terrain”上的预测质量有了大幅度的改善。

Synthia→城市景观的结果。

我们在表1中展示了我们在SYNTHIA→cityscape上的结果，结果表明我们的方法的性能得到了持续的改进，与最先进的方法MIC[1]相比，从67.3增加到69.3 (+2.0 mIoU)。特别是我们的方法将具有挑战性的“SideWalk”区块的IoU性能从50.5提高到63.1 (+12.6 mIoU)。同样值得注意的是，我们的方法在分割大多数个体类别方面仍然具有竞争力，并且在“Road”上获得+6.8，“Bus”上获得+6.6，“Pole”上获得+3.9，“Road”上获得+3.7，“Wall”上获得+3.2，“Truck”上获得+2.9。

Ablation Study on Different Scene Adaptation Frameworks

我们将我们的方法与GTA→Cityscapes上的不同场景适应架构相结合。表4显示我们的方法在不同网络架构的不同方法中实现了一致且显着的改进。首先，我们的方法将最先进的性能提高了+1.8 mIoU。然后，我们在基于Transformer Backbone的两种强大方法上评估所提出的方法，在DAFormer和HRDA上分别产生+3.2 mIoU和+2.3 mIoU性能提升。其次，我们在具有ResNet-101主干的DeepLabV2架构上评估我们的方法。我们表明，我们将基于CNN的跨域混合方法（即 DACS）的性能提高了+4.1 mIoU。消融研究验证了我们的方法在利用深度信息来增强跨域混合方面的有效性，不仅在基于Transformer的网络上，而且还在基于CNN的架构上。

Ablation Study on Different Components of theProposed Method

为了验证我们提出的组件的有效性，我们训练了从M1到M4的四种不同模型，结果如表3所示。“ST Base”是指具有语义分割分支和深度回归分支的自训练基线。“Naive Mix”表示跨域混合策略。“DCF”代表所提出的深度感知混合（深度引导上下文过滤器）。“AFO”表示提出的自适应特征优化模块，我们使用两种不同的方法来执行AFO。首先，我们利用通道注意力（CA），它可以沿着通道维度选择有用的信息来执行特征优化。在该方法中，融合特征由SENet [78] 自适应优化，输出是一个加权向量，乘以视觉和深度特征。我们用“AFO（CA）”来表示这种方法。其次，我们利用变压器块的迭代使用来自适应优化多任务特征。在这种情况下，变压器块的输出是加权图。然后使用多模态通信（MMC）模块来整合来自深度预测的丰富知识。我们将此方法表示为“AFO（Trans + MMC）”。M1是基于DAFormer架构的深度回归自训练基线。M2 添加了跨域混合策略进行改进，并显示出76.0 mIoU的竞争结果。M3是带有深度引导上下文滤波器的模型，将性能从76.0 mIoU 提高到77.1 mIoU (+1.1 mIoU)，这证明了在深度信息的帮助下将混合训练图像转移到真实世界布局的有效性。M4添加了多任务框架，利用通道注意力（CA）机制将判别深度特征融合到视觉特征中。分割结果小幅增加（+0.2 mIoU），这意味着CA可以在一定程度上帮助网络自适应地学习聚焦或忽略来自辅助任务的信息。M5 是我们提出的深度感知多任务模型，具有深度引导上下文过滤器和自适应特征优化（AFO）模块。与M3相比，M5的mIoU增加了+0.6，从77.1增加到77.7，这表明使用Transformer 进行多模态特征优化以促进上下文学习的有效性。

Conclusion

在这项工作中，我们引入了一个新的深度感知场景自适应框架，有效地利用深度的指导，以增强数据增强和上下文学习。提出的框架不仅通过激励真实世界布局的深度分布指导明确地优化跨领域混合，还引入了一个跨任务编码器，自适应优化多任务特征并专注于有助于上下文学习的具有区分性的深度特征。通过将我们的深度感知框架集成到现有的基于Transformer或CNN的自训练方法中，我们在两个广泛使用的基准测试中实现了最先进的性能，并在小规模类别上取得了显着的改进。大量的实验结果验证了我们将训练图像转移到真实世界布局的动机，并证明了我们的多任务框架在提高场景适应性能方面的有效性。

#CamoTeacher

玩转半监督伪装物体检测，双旋转一致性动态调整样本权重

论文提出了第一个端到端的半监督伪装目标检测模型CamoTeacher。为了解决半监督伪装目标检测中伪标签中存在的大量噪声问题，包括局部噪声和全局噪声，引入了一种名为双旋转一致性学习（DRCL）的新方法，包括像素级一致性学习（PCL）和实例级一致性学习（ICL）。DRCL帮助模型缓解噪音问题，有效利用伪标签信息，使模型在避免确认偏差的同时可以获得充分监督。广泛的实验验证了CamoTeacher的优越性能，同时显著降低了标注要求。

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

Introduction

伪装物体检测（COD）旨在识别在其环境中完全融入的物体，包括动物或具有保护色彩并具有融入周围环境能力的人造实体，这一任务由于低对比度、相似纹理和模糊边界而变得复杂。与一般物体检测不同，COD受到这些因素的挑战，使得检测变得格外困难。现有的COD方法严重依赖于大规模的像素级注释数据集，其创建需要大量的人力和成本，从而限制了COD的进展。

为了缓解这一问题，半监督学习作为一种有希望的方法出现，利用标记和未标记数据。然而，由于复杂的背景和微妙的物体边界，其在COD中的应用并不直接。半监督学习在COD中的有效性受到伪标签中存在的大量噪声的严重影响，伪标签的噪声有两种主要类型：像素级噪声，表明在单个伪标签内的变化，以及实例级噪声，显示不同伪标签之间的变化。这种区分是至关重要的，因为它指导了如何改进伪标签质量以提高模型训练的方法。（1）像素级噪声的特点是在伪标签的各个部分内部的标注不一致。如图1a中所示，在第一行中，壁虎的尾部在视觉上比头部更难以识别。由SINet生成的伪标签在其尾部区域中的准确性较低（由红色框标出）。这一观察结果强调了对伪标签内的所有部分统一处理的不当性。（2）实例级噪声指的是不同伪标签之间噪声水平的变化。如图1a所示，第三行的伪标签与第二行相比不太准确，因为第三行中的伪装对象更难以检测。这些差异表明每个伪标签对模型训练的贡献是不同的，强调了需要对整合伪标签信息采取细致差异的方法。

为了解决在没有未标记GT的数据的情况下评估伪标签噪声的挑战，论文提出了基于两个旋转视图的像素级不一致性和实例级一致性的两种新策略。具体来说，对于像素级噪声，论文观察到通过比较两个旋转视图的伪标签计算出的像素级不一致性，可以反映相对于GT的实际误差，如图2a所示。这种关系显示了不同部分之间平均像素级不一致性与平均绝对误差（MAE）之间的正相关性，如图2b的折线所示。因此，具有较高像素级不一致性的区域更容易出现不准确性，表明在训练过程中需要减弱这些区域的重要性。

对于实例级噪声，跨旋转视图具有更大相似性的伪标签展示了更低的噪声水平，如图3a所示。伪标签和GT计算的SSIM之间的实例级一致性与正相关性进一步支持了这一观察结果，如图3b所示。因此，表现出更高实例级一致性的伪标签可能具有更高质量，并应在学习过程中优先考虑。

通过这些观察结果，论文提出了一种名为CamoTeacher的半监督伪装物体检测框架，该框架结合了一种名为Dual-Rotation Consistency Learning（DRCL）的新方法。具体而言，DRCL通过两个核心组件来实现其策略：像素级一致性学习（PCL）和实例级一致性学习（ICL）。PCL通过考虑不同旋转视图之间的像素级不一致性，创新地为伪标签中的不同部分分配可变权重。同时，ICL根据实例级一致性调整各个伪标签的重要性，实现细致、噪声感知的训练过程。

论文采用SINet作为基础模型来实现CamoTeacher，并将其应用于更经典的伪装物体检测（COD）模型，即基于CNN的SINet-v2和SegMaR，以及基于Transforme的DTINet和FSPNet。在四个COD基准数据集（即CAMO，CHAMELEON，COD10K和NC4K）上进行了大量实验，结果显示CamoTeacher不仅在与半监督学习方法相比方面达到了最先进的水平，而且与已建立的全监督学习方法相媲美。具体来说，如图1b所示，仅使用了20%的标记数据，它几乎达到了在COD10K上全监督模型的性能水平。

论文的贡献可以总结如下：

引入了第一个端到端的半监督伪装物体检测框架CamoTeacher，为未来半监督伪装物体检测的研究提供了一个简单而有效的基准。

为解决半监督伪装物体检测中伪标签中大量噪声的问题，提出了Dual-Rotation Consistency Learning（DRCL），其中包括Pixel-wise Consistency Learning（PCL）和Instance-wise Consistency Learning（ICL），允许自适应调整不同质量伪标签的贡献，从而有效利用伪标签信息。

在COD基准数据集上进行了大量实验，相较于完全监督设置，取得了显著的改进。

MethodologyTask Formulation

半监督伪装物体检测旨在利用有限的标记数据训练一个能够识别与周围环境无缝融合的物体的检测器。由于物体与背景之间的对比度较低, 这个任务本身具有挑战性。给定一个用于训练的伪装物体检测数据集 , 含个标记样本的标记子集表示为 , 含个未标记样本的未标记子集表示为 , 其中和表示输入图像, 表示标记数据的相应注释掩码。通常, 只占整个数据集的很小一部分, 这突出了的半监督学习场景。对于的强调, 强调了半监督学习中的挑战和机遇: 通过利用末标记数据尚未发掘的潜力来提升检测能力，而这远远超过了标记子集。

Overall Framework

如图 4 所示, 采用 Mean Teacher 作为初步方案, 以实现端到端的半监督伪装物体检测框架。该框架包含两个具有相同结构的 COD 模型, 即教师模型和学生模型, 分别由参数和参数化。教师模型生成伪标签, 然后用于优化学生模型。整体损失函数可以定义为:

其中, 和分别表示有监督损失和无监督损失, 是平衡损失项的无监督损失权重。按照经典的 COD 方法, 使用二元交叉嫡损失用于训练。在训练过程中，采用弱数据增强和强数据增强策略的组合。弱数据增强应用于有标记数据以减轻过拟合，而无标记数据在强数据增强下经历各种数据扰动，以创造同一图像的不同视角。有监督损失的定义如下：

其中, 表示模型对第张图像在增强下的检测结果。对于无标记的图像, 首先应用弱数据增强 , 然后将其传递给教师模型。这一初始步骤对于在不显著改变图像核心特征的变化下生成可靠的伪标签至关重要。这些伪标签作为学生模型的一种软监督形式。接下来, 相同的图像经过强数据增强后传递给学生模型。这个过程引入了更高层次的变异性和复杂性, 模拟更具挑战性的条件, 以适应学生模型。学生模型基于这些经过强增强的图像生成预测 , 利用伪标签作为无标记数据学习的指导。可以将其形式化为:

因此，无监督损失可以表示为：

最后，学生模型通过总损失进行密集训练，该损失包含了半监督框架中有监督和无监督学习的两个方面。这种方法确保学生模型从有标记和伪标记数据中受益，提高其检测能力。同时，教师模型通过指数移动平均（EMA）机制进行系统更新，有效地提取学生知识并防止噪音干扰，具体表述为：

其中，是一个超参数，表示保留的比例。

Dual-Rotation Consistency Learning

由于物体的伪装性质，伪标签中包含大量噪音，直接使用它们来优化学生模型可能会损害模型的性能。为解决这个问题，最直观的一个可能方法是设置一个固定的高阈值来过滤高质量的伪标签，但这会导致召回率较低，并使得难以充分利用伪标签的监督信息。为此，论文提出了双旋转一致性学习（DRCL），以动态调整伪标签的权重，减少噪音的影响。

对图像进行两个独立的随机旋转, 其中在之前已进行了翻转和随机调整大小, 得到两个不同的旋转视图和。

其中, 表示将输入图像旋转度。将获得的旋转视图输入到教师模型中, 得到相应的预测值, 即。随后, 对预测值进行的相反旋转, 使其返回到原始的水平方向, 得到和 , 以便在不同的旋转视图下计算预测不一致性。

请注意，旋转会引入黑色的边界区域，这些区域不参与DRCL的计算过程。

由于伪标签的不同区域和不同伪标签之间的噪声水平不同，引入PCL和ICL动态调整不同像素在伪标签内部和各个伪标签之间的贡献。

Pixel-wise Consistency Learning

在像素级别上对水平预测和进行减法运算, 得到像素级别的不一致性。

不同视图之间的像素级不一致性反映了伪标签的可靠性。然而，在两个旋转视图的预测值都接近0.5的情况下，无法有效区分它们。这些预测表现出高度的不确定性，意味着不能明确将它们分类为前景或背景，并且很可能代表嘈杂的标签。因此，有必要通过降低它们的权重来减弱它们的影响。因此，计算水平预测值的平均值，

其中，表示计算两个像素级别输入的平均值，并使用其与0.5的L2距离作为调整权重的一个组成部分。

因此，根据不同旋转视图之间的像素级别不一致性，推导出像素级别一致性权重，如下所示：

其中, 是一个超参数, 。这个动态的像素级一致性权重会给与不同旋转视图间预测一致的区域分配更高的权重, 而对于预测不一致的区域则分配较小的权重。

总而言之, 将 PCL 损失函数表述为:

自适应地调整每个像素的权重，以确保对学生模型进行全面监督，同时避免带来偏见。

Instance-wise Consistency Learning

不同图像之间的伪装程度会有所不同，导致伪标签质量在图像之间存在显著变化。平等地对待所有伪标签是不合理的。不幸的是，对于未标记的图像，评估伪标签质量是具有挑战性的，因为没有可用的GT标签。论文呢观察到两个旋转视图的实例一致性和伪标签质量之间存在正相关，由SSIM量化。基于此，引入ICL来调整具有不同质量的伪标签的贡献。将实例级一致性权重表示如下：

其中，是一个超参数，用于调整实例级一致性和伪标签质量之间的分布关系。使用交并比（IoU）损失作为实例级限制，因此，ICL损失可以表示为：

因此, 最终的总损失由三个部分组成: 有监督损失损失和 ICL 损失 , 可以表示为:

其中, 是超参数。

Experiment

Experiment Settings

Dataset

在四个基准数据集CAMO、CHAMELEON、COD10K和NC4K上评估了CamoTeacher模型。在CAMO数据集中，共有2500张图像，包括1250张伪装图像和1250张非伪装图像。CHAMELEON数据集包含76张手动注释图像。COD10K数据集由5066张伪装图像、3000张背景图像和1934张非伪装图像组成。NC4K是另一个包含4121张图像的大规模COD测试数据集。根据先前的工作中的数据划分，使用COD10K的3040张图像和CAMO的1000张图像作为实验的训练集。剩余的图像来自这两个数据集，被用作测试集。在训练过程中，采用了半监督分割的数据划分方法。我们从训练集中随机采样了1%、5%、10%、20%和30%的图像作为有标签的数据，剩余的部分作为无标签的数据。

Evaluation Metrics参考先前的工作, 在 COD 中使用了 6 个常见的评估指标来评估我们的 CamoTeacher 模型,包括 S-measure ( )、加权 F-measure ( )、平均 E-measure ( )、最大 E-measure ( )、平均 F-measure ( )和平均绝对误差。
Implementation Details

提出的CamoTeacher模型使用PyTorch进行实现。采用SINet作为COD模型的基线。使用带有动量0.9的SGD优化器和多项式学习率衰减，初始学习率为0.01，来训练学生模型。训练周期设置为40个周期，其中前10个周期为burn-in阶段。批量大小为20，有标签数据和无标签数据的比例为1:1，即每个批次包含10个有标签和10个无标签的图像。在训练和推断过程中，每个图像被调整为的大小。通过EMA方法更新教师模型，动量为0.996。弱数据增强包括随机翻转和随机缩放，而强数据增强涉及颜色空间转换，包括Identity、Autocontrast、Equalize、Gaussian blur、Contrast、Sharpness、Color、Brightness、Hue、Posterize、Solarize，从这个列表中随机选择最多3个。

Results

#CNN~可解释的缺陷检测

尽管神经网络非常准确，但它在需要预测可解释性的领域（例如医学、银行、教育等）的应用并不广泛。

在本教程中，我将向您展示如何克服卷积神经网络的这种可解释性限制。通过探索、检查、处理和可视化深度神经网络层生成的特征图，我们将介绍该方法并讨论如何将其应用于现实世界的任务——缺陷检测。

本文数据集和源码下载链接：

https://github.com/OlgaChernytska/Visual-Inspection

任务

我们有一个包含 400 张图片的数据集，其中包含良好物品（标记为“良好”类）和有缺陷物品（标记为“异常”类）的图像。数据集是不平衡的 — 良好图像的样本多于有缺陷的图像样本。图像中的物品可能属于任何类型和复杂程度 — 瓶子、电缆、药丸、瓷砖、皮革、拉链等。以下是数据集可能的样子的示例。

我们的任务是构建一个模型，将图像分为“良好”/“异常”类别，如果图像被归类为“异常”，则返回缺陷的边界框。尽管这项任务看起来很简单，就像典型的对象检测任务一样，但有一个问题——我们没有边界框的标签。

幸运的是，这个任务是可以解决的。

数据准备

对于我的所有实验，我都使用了MVTEC 异常检测数据集（请注意，它是根据知识共享署名-非商业-相同方式共享 4.0 国际许可分发的，这意味着它不能用于商业目的）。

https://www.mvtec.com/company/research/datasets/mvtec-ad

该数据集包括 15 个不同物品类型的子集，例如瓶子、电缆、药丸、皮革、瓷砖等；每个子集总共有 300-400 张图像 — 每张标记为“良好”/“异常”

作为数据预处理步骤，将图像大小调整为 224×224 像素以加快训练速度。大多数子集中的图像大小为 1024×1024，但由于缺陷尺寸也很大，我们可以将图像大小调整为较低的分辨率而不会牺牲模型准确性。

考虑使用数据增强。一般来说，适当的数据增强总是对你的模型有益的。数据增强具体方法和介绍可以参考下面链接：

https://towardsdatascience.com/complete-guide-to-data-augmentation-for-computer-vision-1abe4063ad07

但是，让我们假设，当部署到生产环境时，我们的模型将“看到”与我们现在拥有的数据集格式完全相同的数据。因此，如果图像居中、缩放和旋转（如 Capsule 和 Cable 子集），我们可能根本不使用任何数据增强，因为测试图像预计也会居中、缩放和旋转。但是，如果图像没有旋转（而只是居中和缩放），如 Screw 和 Metal Nut 子集，将旋转作为预处理步骤添加到训练管道将有助于模型更好地学习。

将数据分为训练/测试部分。理想情况下，我们希望有训练、验证和测试部分——分别用于训练模型、调整超参数和评估模型准确性。但我们只有 300-400 张图像，所以我们将 80% 的图像放入训练集，将 20% 放入测试集。对于小型数据集，我们可以执行 5 倍交叉验证以确保评估结果是可靠的。

处理不平衡数据集时，应以分层方式进行训练/测试拆分，因此训练和测试部分将包含相同份额的两个类别 — “良好”/“异常”。此外，如果您有关于缺陷类型的信息（例如划痕、裂纹等），最好也根据缺陷类型进行分层拆分，因此训练和测试部分将包含相同份额的带有划痕/裂纹的物品。

模型

让我们使用在 ImageNet 上预先训练的VGG16，并更改其分类头 — 用 Global Average Pooling 和单个 Dense 层替换 Flattening 和 Dense 层。我将在“推理管道”部分解释为什么我们需要这些特定的层。

我们将模型训练为典型的二分类模型。该模型输出一个二维向量，其中包含“良好”和“异常”类别的概率（使用一维输出，该方法也应该有效，请随意尝试）。

在训练期间，前 10 个卷积层被冻结，我们只训练分类头和最后 3 个卷积层。这是因为我们的数据集太小，无法微调整个模型。损失是交叉熵；优化器是 Adam，学习率为 0.0001。

我已经尝试了 MVTEC 异常检测数据集的不同子集。我使用 batch_size=10 训练了模型，最多训练了 10 个时期，并在训练集准确率达到 98% 时提前停止。为了处理不平衡的数据集，我们可以应用损失权重：对“异常”类图像使用较高的权重，对“良好”类图像使用较低的权重。

推理管道

在推理过程中，我们不仅要将图像分类为“良好”/“异常”类别，而且如果图像被归类为“异常”，还要获取缺陷的边界框。

为此，我们让模型处于推理模式，输出类概率和热图，然后将其处理到边界框中。热图是根据深层的特征图创建的。

步骤1. 在 ReLU 激活后，从 Conv5-3 层获取所有特征图。对于单个输入，将有 512 个大小为 14×14 的特征图（大小为 224×224 的输入图像每次通过 4 个池化层进行两次下采样）。

步骤2. 将 Conv5-3 层的所有 512 个特征图相加，每个特征图都乘以影响“异常”类别分数计算的密集层中的权重。仔细查看图 7 和图 8 以了解此步骤。

为什么这样？现在您将了解为什么分类头应该有一个全局平均池化层和一个密集层。这样的架构使得我们能够跟踪哪些特征图（以及在多大程度上）影响了最终预测并使其成为“异常”类。

每个特征图（Conv5-3 层的输出；见图 6）突出显示输入图像中的某些区域。全局平均池化层将每个特征图表示为单个数字（我们可以将其视为 1-D 嵌入）。密集层通过将每个嵌入乘以相应的权重来计算“良好”和“异常”类的分数（和概率）。此流程如图 7 所示。

因此，密集层权重表示每个特征图对“良好”和“异常”类别的分数的影响程度（我们只对“异常”类别的分数感兴趣）。将 Conv5-3 层的特征图相加，然后乘以密集层相应的权重 — — 非常有意义。

有趣的是，使用全局平均池化而不是全局最大池化对于让模型找到整个物体至关重要。以下是原始论文《学习深度特征进行判别定位》中所说的内容：

步骤3. 下一步是对热图进行上采样，以匹配输入图像大小 — 224×224。双线性上采样是可以的，就像任何其他上采样方法一样。

回到模型输出。模型返回“良好”和“异常”类别的概率，以及一个热图，该热图显示在计算“异常”分数时哪些像素很重要。无论将图像分类为“良好”还是“异常”，模型始终返回热图；当类别为“良好”时，我们只需忽略热图。

热力图看起来相当不错，并解释了哪个区域使模型决定该图像属于“异常”类别。我们可以在这里停下来，或者（正如我承诺的那样）将热图处理成边界框。

从热力图到边界框。您可能会想出几种方法。我将向您展示最简单的方法。在大多数情况下，它效果很好。

1. 首先，对热图进行标准化，使得所有值都在 [0,1] 范围内。

2. 选择一个阈值。将其应用于热图，这样所有大于阈值的值都会转换为 1，小于阈值的值则转换为 0。阈值越大，边界框就越小。我喜欢阈值在 [0.7, 0.9] 范围内时的结果。

3. 我们假设 1 的区域 — 是一个单一的密集区域。然后通过查找高度和宽度维度中的 argmin 和 argmax 在该区域周围绘制一个边界框。

但是，请注意，这种方法只能返回单个边界框（根据定义），因此如果图像有多个缺陷区域，它将会失败。

评估

让我们在 MVTEC 异常检测数据集的 5 个子集（榛子、皮革、电缆、牙刷和药丸）上评估该方法。

对于每个子集，我都训练了一个单独的模型；20% 的图像被随机分层地选为测试集。没有使用数据增强。我在损失函数中应用了类别权重——1 表示“良好”类别，“异常”类别为 3，因为在大多数子集中，良好图像的数量是异常图像的 3 倍。该模型最多训练 10 个时期，如果训练集准确率达到 98%，则提前停止。这是我的笔记本，里面有训练脚本。

以下是评估结果。子集的训练集大小为 80-400 张图像。平衡准确率在 81.7% 到 95.5% 之间。一些子集（例如 Hazelnut 和 Leather）对于模型来说更容易学习，而 Pill 是一个相对困难的子集。

现在让我们看看预测是什么样子。在大多数情况下，如果类别是“异常”，模型会产生正确的类别预测和精确的边界框。但是，当类别被正确预测为“异常”时，也存在一些错误：它们要么是错误的类别预测，要么是错误的边界框位置。

结论

在这篇文章中，我们向你展示神经网络不是某些人认为的黑盒算法，而是当你知道在哪里看的时候是可以解释的：）这里描述的方法是解释模型预测的众多方法之一。

当然，这个模型并不是那么准确，主要是因为这是我的快速小项目。但如果你正在做类似的任务，可以把我的结果作为起点，投入更多时间并获得所需的准确度。

本文数据集和源码下载链接：

https://github.com/OlgaChernytska/Visual-Inspection

#全景拼接的一般步骤

图像拼接可以概括为以下几个主要步骤：

计算两幅图像的关键点和描述符。
计算一幅图像中每个描述符与另一幅图像中每个描述符之间的距离。
为图像的每个描述符选择前“m”个匹配项。
执行比率测试以保留最准确的匹配对。
运行RANSAC来估计 Homography。
变换图像以对齐拼接。
现在将它们缝合在一起。

全景拼接是将多张视野重叠的图像组合起来，生成全景图或高分辨率图像的过程。要组合视野重叠的图像，我们需要检测图像对中的匹配特征和关键点。

从上面的两张图片很容易看出，如果我们选择海洋作为兴趣点，很难将左图的海洋斑块与右图进行具体匹配（因为海洋在广阔的空间区域中看起来相同）。我们还注意到，选择诸如小岩石的顶峰（橙色圆圈）等区域能够为我们以后的匹配提供更有价值的信息。

重点特征

a) 可重复的兴趣点

b）兴趣点的独特性

c) 尺度和旋转不变性

事实证明，角点实际上是一个很好的特征，可以作为兴趣点！有一种名为 Harris Corner Detector 的算法可以帮助我们在图像中找到这样的角点作为兴趣点。

Harris Corner 对旋转（因为 H 矩阵的特征值在旋转后保持不变）、平移和强度的附加变化具有不变性。但是，它对强度和比例的缩放不具有不变性。

其他方法如 SIFT 使用高斯差 (DoG) 来检测不同尺度的兴趣点，并且对尺度具有不变性。

描述符基本上是矢量表示，以数学方式描述图像中的某个区域。描述符也应该对旋转、缩放和平移具有不变性。

特征匹配

一旦检测到每个查询和训练图像的关键点和特征，就需要一个匹配器对象来匹配图像对的相应特征。这称为特征对应。有各种匹配器对象，如强力匹配器、基于 FLANN 的匹配器等。

暴力匹配器 (BF) 的作用正如其名称所示。给定 2 组特征（分别来自图像 A 和图像 B），将 A 组中的每个特征与 B 组中的所有特征进行比较。默认情况下，BF 匹配器会计算两点之间的欧几里得距离。

然而，如果我们想要考虑多个候选匹配，我们可以使用基于 KNN 的匹配程序。KNN 不会返回给定特征的单个最佳匹配，而是返回 k 个最佳匹配。

匹配率测试

为了确保 KNN 返回的特征具有很好的可比性，SIFT 论文的作者提出了一种称为比率测试的技术。基本上，我们迭代 KNN 返回的每一对并执行距离测试。对于每对特征（f1，f2 ），如果f1和f2之间的距离在某个比率范围内，我们保留它，否则，我们将其丢弃。此外，必须手动选择比率值。

单应性矩阵

想象两种场景。

(1) — 每次拍照时，向左走一步，同时保持相机静止。

(2) — 站在固定位置，手持相机旋转身体，在旋转的同时捕捉不同的照片。

如果我们想在 (1) 中将图像拼接在一起，我们可以简单地将一张照片叠加在另一张照片上，这样就能得到很好的效果。然而在 (2) 中，如果我们想通过简单地将图像叠加在一起来将图像拼接在一起，我们会发现拼接的结果很糟糕（由于捕获图像的平面不同，某些区域会被遗漏）。因此，我们需要使用单应性将一幅图像投影到另一幅图像的同一平面上，然后再将它们拼接在一起。

因此，一旦找到最精确、最准确的特征对，就会应用变换矩阵将两幅图像放在同一平面上。这种变换称为单应性矩阵。简而言之，单应性是一个 3x3 矩阵，可用于许多应用，例如相机姿势估计、透视校正和图像拼接。单应性是一种 2D 变换。它将点从一个平面（图像）映射到另一个平面。

计算单应性矩阵

然而，单应性矩阵对异常值很敏感。我们可以使用随机样本一致性 (RANSAC) 产生稳健的结果，其中我们在 H 矩阵的计算中只包括内点（True positive matches）。

我们可以使用随机样本共识 (RANSAC) 产生稳健的结果，其中我们在 H 矩阵的计算中只包括内点（True positive matches）。

线性回归等模型使用最小二乘估计来将最佳模型与数据拟合。我们可以看到，线性回归模型很容易受到异常值的影响。这是因为它试图减少平均误差。因此，它倾向于选择最小化所有数据点与模型本身的总距离的模型。这包括异常值。

因此，如果异常值的数量很大，它可能会失败。RANSAC 通过仅使用数据中的内点子集来估计参数来解决此问题。

图像变换

一旦我们得到了估计的单应性矩阵，我们就需要将其中一张图片变换到一个公共平面上。

在这里，我们将对其中一张图片应用透视变换。基本上，透视变换可以结合一个或多个操作，如旋转、缩放、平移或剪切。其理念是变换其中一张图片，使两张图片合并为一张。

#11种常用的深度学习图像分割模型

图像分割是计算机视觉领域的一项关键任务，其中图像中的每个像素被分配给特定的类别或对象。

近年来，随着深度学习的发展，图像分割技术取得了长足的进步。

本文将介绍11种常用的深度学习模型，帮助你理解和掌握这些强大的工具。

1. U-Net

U-Net 是一个经典的图像分割模型，最初设计用于生物医学图像分割。其架构采用编码器-解码器结构，通过跳跃连接将低级特征传递到更高级别，从而保留更详细的信息。

代码示例：

import torch
import torch.nn as nn


class UNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(UNet, self).__init__()
        # Encoder part
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # Decoder part
        self.decoder = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(64, out_channels, kernel_size=2, stride=2)
        )


    def forward(self, x):
        # Encoder
        x1 = self.encoder(x)
        # Decoder
        x2 = self.decoder(x1)
        return x2


# Create model instance
model = UNet(in_channels=3, out_channels=1)
print(model)

输出：

UNet(
  (encoder): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilatinotallow=1, ceil_mode=False)
  )
  (decoder): Sequential(
    (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): ConvTranspose2d(64, 1, kernel_size=(2, 2), stride=(2, 2), padding=(0, 0))
  )
)

2. DeepLab v3+

DeepLab v3+ 是一个基于卷积神经网络的分割模型，利用空洞卷积来捕捉多尺度信息，并通过 ASPP（空洞空间金字塔池化）模块增强其表达能力。

代码示例：

import torchvision.models.segmentation as segmentation_models


# Load pretrained DeepLab v3+ model
model = segmentation_models.deeplabv3_resnet101(pretrained=True)


# Modify output channels
model.classifier[4] = nn.Conv2d(256, 1, kernel_size=1)


print(model)

输出：

DeepLabV3(
  (backbone): IntermediateLayerGetter(
    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilatinotallow=1, ceil_mode=False)
    (layer1): Bottleneck(...)
    (layer2): Bottleneck(...)
    (layer3): Bottleneck(...)
    (layer4): Bottleneck(...)
  )
  (classifier): DeepLabHead(
    (aspp): ASPP(
      (convs): ModuleList(
        (0): ASPPConv(...)
        (1): ASPPConv(...)
        (2): ASPPConv(...)
        (3): ASPPPooling(...)
      )
      (project): Sequential(
        (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Dropout(p=0.5, inplace=False)
      )
    )
    (classifier): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1))
  )
  (aux_classifier): None
)

3. Mask R-CNN

Mask R-CNN 是基于 Faster R-CNN 的实例分割模型，不仅可以检测图像中的物体，还可以为每个物体生成像素级的 mask。

代码示例：

import torchvision.models.detection.mask_rcnn as mask_rcnn


# Load the pretrained Mask R-CNN model
model = mask_rcnn.maskrcnn_resnet50_fpn(pretrained=True)


# Modify the number of output classes
model.roi_heads.box_predictor.cls_score.out_features = 2
model.roi_heads.box_predictor.bbox_pred.out_features = 8
model.roi_heads.mask_predictor.mask_fcn_logits.out_channels = 1


print(model)

输出：

MaskRCNN(
  (backbone): BackboneWithFPN(
    (body): IntermediateLayerGetter(
      (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilatinotallow=1, ceil_mode=False)
      (layer1): Bottleneck(...)
      (layer2): Bottleneck(...)
      (layer3): Bottleneck(...)
      (layer4): Bottleneck(...)
    )
    (fpn): FeaturePyramidNetwork(
      (inner_blocks): ModuleList(
        (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))
        (1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
        (2): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))
        (3): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))
      )
      (layer_blocks): ModuleList(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      )
      (extra_blocks): LastLevelMaxPool()
    )
  )
  (rpn): RegionProposalNetwork(
    (anchor_generator): AnchorGenerator()
    (head): RPNHead(
      (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (cls_logits): Conv2d(256, 3, kernel_size=(1, 1), stride=(1, 1))
      (bbox_pred): Conv2d(256, 12, kernel_size=(1, 1), stride=(1, 1))
    )
  )
  (roi_heads): RoIHeads(
    (box_roi_pool): MultiScaleRoIAlign(featmap_names=['0', '1', '2', '3'], output_size=(7, 7), sampling_ratio=2)
    (box_head): TwoMLPHead(
      (fc6): Linear(in_features=12544, out_features=1024, bias=True)
      (fc7): Linear(in_features=1024, out_features=1024, bias=True)
    )
    (box_predictor): FastRCNNPredictor(
      (cls_score): Linear(in_features=1024, out_features=2, bias=True)
      (bbox_pred): Linear(in_features=1024, out_features=8, bias=True)
    )
    (mask_roi_pool): MultiScaleRoIAlign(featmap_names=['0', '1', '2', '3'], output_size=(14, 14), sampling_ratio=2)
    (mask_head): MaskRCNNHeads(
      (layers): ModuleList(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      )
    )
    (mask_predictor): MaskRCNNPredictor(
      (conv5_mask): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (mask_fcn_logits): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1))
    )
  )
  (transform): GeneralizedRCNNTransform(min_size=800, max_size=1333, image_mean=[0.485, 0.456, 0.406], image_std=[0.229, 0.224, 0.225])
)
4. PSPNet

4. PSPNet

PSPNet（金字塔场景解析网络）是一个基于金字塔池化的图像分割模型，通过不同尺度的池化操作来捕捉全局上下文信息。

代码示例：

import torchvision.models.segmentation as segmentation_models


# Load the pretrained PSPNet model
model = segmentation_models.fcn_resnet101(pretrained=True)


# Modify the number of output channels
model.classifier[4] = nn.Conv2d(512, 1, kernel_size=1)


print(model)

输出：

FCN(
  (backbone): IntermediateLayerGetter(
    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilatinotallow=1, ceil_mode=False)
    (layer1): Bottleneck(...)
    (layer2): Bottleneck(...)
    (layer3): Bottleneck(...)
    (layer4): Bottleneck(...)
  )
  (classifier): FCNHead(
    (0): Conv2d(2048, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.1, inplace=False)
    (3): Conv2d(512, 1, kernel_size=(1, 1), stride=(1, 1))
  )
  (aux_classifier): FCNHead(
    (0): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.1, inplace=False)
    (3): Conv2d(256, 21, kernel_size=(1, 1), stride=(1, 1))
  )
)

5. SegNet

SegNet 是一种基于编码器-解码器架构的图像分割模型。它使用最大池化索引进行上采样，这有助于保留更详细的信息。

代码示例：

import torch
import torch.nn as nn


class SegNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(SegNet, self).__init__()
        # Encoder part
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2, return_indices=True)
        )
        # Decoder part
        self.decoder = nn.Sequential(
            nn.MaxUnpool2d(kernel_size=2, stride=2),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, out_channels, kernel_size=3, padding=1)
        )


    def forward(self, x):
        # Encoder
        x, indices = self.encoder(x)
        # Decoder
        x = self.decoder((x, indices))
        return x


# Create model instance
model = SegNet(in_channels=3, out_channels=1)
print(model)

输出：

SegNet(
  (encoder): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilatinotallow=1, ceil_mode=False, return_indices=True)
  )
  (decoder): Sequential(
    (0): MaxUnpool2d(kernel_size=2, stride=2, padding=0)
    (1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (3): ReLU()
    (4): Conv2d(64, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  )
)

6. LinkNet

LinkNet是一个轻量级的图像分割模型，通过跳过连接来连接编码器和解码器，减少参数数量并提高计算效率。

代码示例：

import torch
import torch.nn as nn


class LinkNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(LinkNet, self).__init__()
        # Encoder part
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # Decoder part
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(64, 64, kernel_size=2, stride=2),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, out_channels, kernel_size=3, padding=1)
        )


    def forward(self, x):
        # Encoder
        x1 = self.encoder(x)
        # Decoder
        x2 = self.decoder(x1)
        return x2


# Create model instance
model = LinkNet(in_channels=3, out_channels=1)
print(model)

输出：

LinkNet(
  (encoder): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilatinotallow=1, ceil_mode=False)
  )
  (decoder): Sequential(
    (0): ConvTranspose2d(64, 64, kernel_size=(2, 2), stride=(2, 2))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  )
)

7. HRNet

HRNet（High-Resolution Network）是一种高分辨率网络，通过多尺度融合和并行处理来保持高分辨率的特征图，从而提高分割精度。

代码示例：

import torch
import torch.nn as nn


class HRNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(HRNet, self).__init__()
        # High-resolution branch
        self.high_res_branch = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU()
        )
        # Low-resolution branch
        self.low_res_branch = nn.Sequential(
            nn.Conv2d(in_channels, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # Fusion module
        self.fusion = nn.Sequential(
            nn.Conv2d(96, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, out_channels, kernel_size=1)
        )


    def forward(self, x):
        # High-resolution branch
        high_res = self.high_res_branch(x)
        # Low-resolution branch
        low_res = self.low_res_branch(x)
        # Upsample low-resolution feature map
        low_res_upsampled = nn.functional.interpolate(low_res, scale_factor=2, mode='bilinear', align_corners=True)
        # Fuse high-resolution and low-resolution feature maps
        fused = torch.cat([high_res, low_res_upsampled], dim=1)
        # Output
        output = self.fusion(fused)
        return output


# Create model instance
model = HRNet(in_channels=3, out_channels=1)
print(model)

输出：

HRNet(
  (high_res_branch): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (low_res_branch): Sequential(
    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilatinotallow=1, ceil_mode=False)
  )
  (fusion): Sequential(
    (0): Conv2d(96, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))
  )
)

8. RefineNet

RefineNet 是一个多路径细化网络，它通过多路径细化模块逐步细化特征图，从而提高分割精度。

代码示例：

import torch
import torch.nn as nn


class RefineNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(RefineNet, self).__init__()
        # Encoder part
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # Multi-path refinement module
        self.refine_module = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU()
        )
        # Decoder part
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(64, 64, kernel_size=2, stride=2),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, out_channels, kernel_size=3, padding=1)
        )


    def forward(self, x):
        # Encoder
        x1 = self.encoder(x)
        # Multi-path refinement
        x2 = self.refine_module(x1)
        # Decoder
        x3 = self.decoder(x2)
        return x3


# Create model instance
model = RefineNet(in_channels=3, out_channels=1)
print(model)

输出：

RefineNet(
  (encoder): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilatinotallow=1, ceil_mode=False)
  )
  (refine_module): Sequential(
    (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (5): ReLU()
  )
  (decoder): Sequential(
    (0): ConvTranspose2d(64, 64, kernel_size=(2, 2), stride=(2, 2))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  )
)

9. BiSeNet

BiSeNet（双边分割网络）是一种高效的实时图像分割模型，它通过空间和上下文路径分别捕获空间细节和全局上下文信息。

代码示例：

import torch
import torch.nn as nn


class BiSeNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(BiSeNet, self).__init__()
        # Spatial Path
        self.spatial_path = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU()
        )
        # Context Path
        self.context_path = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # Fusion Module
        self.fusion = nn.Sequential(
            nn.Conv2d(128, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, out_channels, kernel_size=1)
        )


    def forward(self, x):
        # Spatial Path
        spatial = self.spatial_path(x)
        # Context Path
        context = self.context_path(x)
        # Upsample context feature map
        context_upsampled = nn.functional.interpolate(context, scale_factor=2, mode='bilinear', align_corners=True)
        # Fuse spatial and context feature maps
        fused = torch.cat([spatial, context_upsampled], dim=1)
        # Output
        output = self.fusion(fused)
        return output


# Create model instance
model = BiSeNet(in_channels=3, out_channels=1)
print(model)

输出：

BiSeNet(
  (spatial_path): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (5): ReLU()
  )
  (context_path): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilatinotallow=1, ceil_mode=False)
  )
  (fusion): Sequential(
    (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))
  )
)

10. OCRNet

OCRNet（用于语义分割的对象上下文表示）是一种利用对象上下文表示来改进语义分割的模型。它通过注意力机制增强特征图的表现力。

代码示例：

import torch
import torch.nn as nn


class OCRNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(OCRNet, self).__init__()
        # Encoder part
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # Object-context module
        self.object_context = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU()
        )
        # Decoder part
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(64, 64, kernel_size=2, stride=2),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, out_channels, kernel_size=3, padding=1)
        )


    def forward(self, x):
        # Encoder
        x1 = self.encoder(x)
        # Object-context
        x2 = self.object_context(x1)
        # Decoder
        x3 = self.decoder(x2)
        return x3


# Create model instance
model = OCRNet(in_channels=3, out_channels=1)
print(model)

输出：

OCRNet(
  (encoder): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilatinotallow=1, ceil_mode=False)
  )
  (object_context): Sequential(
    (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (5): ReLU()
  )
  (decoder): Sequential(
    (0): ConvTranspose2d(64, 64, kernel_size=(2, 2), stride=(2, 2))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  )
)

11.Swin Transformer

Swin Transformer 是一个基于 Transformer 架构的图像分割模型，通过分层自注意力机制捕捉长距离依赖关系，提高分割准确率。

总结：

本文介绍了一系列专为 Python 图像分割任务而设计的高级深度学习模型。它涵盖了以编码器-解码器结构和跳过连接而闻名的 U-Net 模型、利用空洞卷积和 ASPP 捕获多尺度信息的 DeepLab v3+ 模型，以及扩展 Faster R-CNN 进行实例分割的 Mask R-CNN 模型。此外，本文还介绍了带有金字塔池化模块的 PSPNet 模型、使用最大池化索引进行上采样的 SegNet 模型，以及通过跳过连接专注于计算效率的 LinkNet 模型。介绍了用于保持高分辨率表示的 HRNet 模型，并讨论了用于多路径细化策略的 RefineNet 模型。重点介绍了 BiSeNet 模型用于具有空间和上下文路径的实时分割，以及 OCRNet 模型，它以使用对象上下文表示而闻名。最后，介绍了 Swin Transformer 模型，这是一种用于捕获远程依赖关系的基于 Transformer 的架构。每个模型都附有简短的描述、代码示例和模型输出，为对最先进的图像分割技术感兴趣的开发人员和研究人员提供了全面的资源。

U-Net定位为生物医学图像分割的基础模型，表明其在该领域的广泛应用和影响力。

DeepLab v3+ 及其 ASPP 模块的加入表明了对能够有效捕捉多种尺度物体的模型的偏好。

Mask R-CNN 的描述意味着实例分割（区分同一类别的不同实例）是计算机视觉领域的一个关键进步。

PSPNet 通过金字塔池化捕获全局上下文信息的能力受到重视，这表明在分割任务中理解场景级信息的重要性。

SegNet 使用最大池化索引进行上采样的方法被认为是一种保留详细信息的有效方法，凸显了模型的资源意识设计。

LinkNet 的架构被展示为其他分割模型的轻量级替代方案，强调模型复杂性和计算效率之间的权衡。

HRNet 的多尺度融合和并行处理被认为是实现高分辨率和准确分割结果的关键特征。

RefineNet 多路径细化模块的详细解释传达了这样的观点：特征图的迭代细化有利于提高分割准确性。

BiSeNet 的双路径架构被描绘为实时图像分割的有效解决方案，平衡了实际应用中对速度和准确性的需求。

关于 OCRNet 对对象上下文表示的关注的讨论反映了这样的观点：结合全局上下文和对象级信息可以显著增强分割性能。

提到 Swin Transformer 模型表明了一种观点：基于 Transformer 的架构对于图像分割任务越来越重要，这可能预示着从传统的卷积神经网络向基于注意力的模型的转变。

#计算机视觉中的自回归模型

本文是一篇关于自回归模型在视觉领域发展的综述论文，由港大、清华、普林斯顿、杜克、俄亥俄州立、UNC、苹果、字节跳动、香港理工大学等多所高校及研究机构的伙伴联合发布。

随着计算机视觉领域的不断发展，自回归模型作为一种强大的生成模型，在图像生成、视频生成、3D 生成和多模态生成等任务中展现出了巨大的潜力。然而，由于该领域的快速发展，及时、全面地了解自回归模型的研究现状和进展变得至关重要。本文旨在对视觉领域中的自回归模型进行全面综述，为研究人员提供一个清晰的参考框架。

论文标题：Autoregressive Models in Vision: A Survey

论文链接: https://arxiv.org/abs/2411.05902

项目地址：https://github.com/ChaofanTao/Autoregressive-Models-in-Vision-Survey

研究的主要亮点如下：

最新最全的文献综述：本文对视觉领域中的自回归模型进行了全面的文献综述，涵盖了约 250 篇相关参考文献，包括一些新兴领域的相关文献，比如 3D 医疗、具身智能等。通过对这些文献的整理和分析，本文能够为读者提供一个系统的了解自回归模型在视觉领域的发展历程和研究现状的有效帮助。

基于序列表征的分类：本文根据序列表示策略对自回归模型进行了分类，包括基于 pixel、基于 token 和基于 scale 的视觉自回归模型。同时，本文还对不同类型的自回归模型在图像生成、视频生成、3D 生成和多模态生成等任务中的性能进行了比较和分析。通过这些分类和比较，本文能够帮助读者更好地理解不同类型的自回归模型的特点和优势，为选择合适的模型提供参考。

左边图展示的是 3 种主流的用于自回归视觉模型的表征方法。右边图展示的是自回归视觉模型的主要组成：序列表征方法和自回归序列建模方式。

各种领域的应用总结：本文详细介绍了自回归模型在图像生成、视频生成、3D 生成和多模态生成等任务中的应用。通过对这些应用的总结和分析，本文能够为读者展示自回归模型在不同领域的应用潜力和实际效果，为进一步推动自回归模型的应用提供参考。下面是本文的文献分类框架图：

挑战与展望：本文讨论了自回归模型在视觉领域面临的挑战，如计算复杂度、模式崩溃等，并提出了一些潜在的研究方向。通过对这些挑战和展望的讨论，本文能够为读者提供一个思考和探索的方向，促进自回归模型在视觉领域的进一步发展。

2. 视觉自回归模型

基础知识

视觉自回归模型有两个核心的组成部分：序列表示和自回归序列建模方法。首先，让我们来了解这两个关键方面：

序列表示：将视觉数据转化为离散元素序列，如像素、视觉词元等。这种表示方法类似于自然语言处理（NLP）中的文本生成中把词分成词元进行后续处理，为自回归模型在计算机视觉领域的应用奠定了基础。举例来说，对于图像数据，可以将其划分为像素序列或者图像块序列，每个像素或图像块作为序列中的一个元素。这样，就可以利用自回归模型依次预测每个元素，从而实现图像的生成或重建。

自回归序列建模：基于先前生成的元素，通过条件概率依次预测每个元素。具体来说，对于一个序列中的第 t 个元素，自回归模型会根据前面 t-1 个元素的信息来预测第 t 个元素的概率分布。训练目标是最小化负对数似然损失。通过不断调整模型参数，使得模型预测的概率分布尽可能接近真实数据的分布，从而提高模型的性能。

2.1 通用框架分类

了解了自回归模型的基础之后，我们接下来看看不同的通用框架分类。下面我们分别介绍基于像素、基于视觉词元和基于尺度的模型。

2.1.1 基于像素（pixel）的模型：这类模型直接在像素级别表示视觉数据，如 PixelRNN 和 PixelCNN 等。PixelRNN 通过递归神经网络（RNN）捕捉像素间的依赖关系，从图像的左上角开始，依次预测每个像素的值。PixelCNN 则使用卷积神经网络（CNN）来实现像素级别的自回归建模，通过对图像进行卷积操作来获取像素间的局部依赖关系。

但是这类模型在高分辨率图像生成时面临计算成本高和信息冗余的挑战。由于需要对每个像素进行预测，随着图像分辨率的提高，计算量会呈指数增长。同时，像素之间的相关性可能导致信息冗余，影响模型的效率和性能。

2.1.2 基于视觉词元（token）的模型：将图像压缩为离散视觉词元序列，如 VQ-VAE 及其变体。

这类模型先使用编码器将图像映射到潜在空间并量化为离散代码，再用解码器重建图像。在此基础上，采用强大的自回归模型预测下一个离散视觉词元。例如，VQ-VAE 通过向量量化将图像编码为离散的视觉词元序列，然后使用自回归模型对视觉词元序列进行建模，实现图像的生成和重建。但是这类模型存在码本利用率低和采样速度慢的问题。码本中的视觉词元可能没有被充分利用，导致生成的图像质量受限。同时，由于需要依次预测每个视觉词元，采样速度相对较慢。

2.1.3 基于尺度（scale）的模型：以不同尺度的视觉词元图作为自回归单元，如 VAR。通过多尺度量化自动编码器将图像离散化为视觉词元学习不同分辨率的信息，生成过程从粗到细逐步进行。例如，VAR 首先在低分辨率下生成粗糙的视觉词元图，然后逐步细化到高分辨率，从而提高生成图像的质量和效率。相比基于视觉词元的模型，它能更好地保留空间局部性，提高视觉词元生成效率。通过多尺度的建模方式，可以更好地捕捉图像的局部结构和细节信息。

不同的通用框架分类各有特点，而自回归模型与其他生成模型也有着紧密的关系。接下来，我们探讨自回归模型与其他生成模型的关系。

2.3 与其他生成模型的关系

自回归模型与变分自编码器（VAEs）、生成对抗网络（GANs）、归一化流、扩散模型和掩码自编码器（MAEs）等生成模型在不同方面有着联系和区别。

变分自编码器（VAEs）：VAEs 学习将数据映射到低维潜在空间并重建，而自回归模型直接捕捉数据分布。两者结合的方法如 VQ-VAE，能有效利用两者优势进行图像合成。VQ-VAE 首先通过编码器将图像映射到潜在空间，然后使用向量量化将潜在空间离散化为视觉词元序列，最后使用自回归模型对视觉词元序列进行建模，实现图像的生成和重建。

生成对抗网络（GANs）：GANs 生成速度快，但训练不稳定且可能出现模式崩溃。自回归模型采用似然训练，过程稳定，虽采样速度慢，但模型性能随数据和模型规模提升。在图像生成任务中，GANs 可以快速生成逼真的图像，但可能会出现模式崩溃的问题，即生成的图像缺乏多样性。自回归模型则可以通过似然训练保证生成的图像具有较高的质量和多样性。

归一化流（Normalizing Flows）：通过一系列可逆变换将简单分布映射到复杂数据分布，与自回归模型都可通过最大似然估计直接优化。但归一化流需保证可逆性，自回归模型则通过离散化数据和顺序预测更具灵活性。归一化流需要设计可逆的变换函数，这在实际应用中可能会比较困难。而自回归模型可以通过离散化数据和顺序预测的方式，更加灵活地捕捉数据的分布特征。

扩散模型（Diffusion Models）：与自回归模型类似，两类模型都能生成高质量样本，但是两者在生成范式上有根本区别。当前自回归模型已经逐渐在性能上追赶上扩散模型，且展现了很好的scaling到更大模型的潜力。近期研究尝试结合两者的优势，进一步提高生成模型的性能。

掩码自编码器（MAEs）：MAEs 通过随机掩码输入数据并重建来学习数据表示，与自回归模型有相似之处，但训练方式和注意力机制不同。例如，MAEs 在训练时随机掩码一部分输入数据，然后通过重建被掩码的部分来学习数据的表示。自回归模型则是通过顺序预测的方式来学习数据的分布。两者在训练方式和注意力机制上存在差异。

3．视觉自回归模型的应用

自回归模型在图像生成、视频生成、3D 生成和多模态生成等任务中都有着广泛的应用。结合经典的和最新的相关工作，我们做出以下的分类，感兴趣的读者可以在论文中阅读每个子类的详情。

3.1 图像生成

无条件图像生成：像素级生成逐个像素构建图像，如 PixelRNN 和 PixelCNN 等。视觉词元级生成将图像视为视觉词元序列，如 VQ-VAE 及其改进方法。尺度级生成从低到高分辨率逐步生成图像，如 VAR。
文本到图像合成：根据文本条件生成图像，如 DALL・E、CogView 等。近期研究还探索了与扩散模型、大语言模型的结合，以及向新任务的扩展。
图像条件合成：包括图像修复、多视图生成和视觉上下文学习等，如 QueryOTR 用于图像外绘，MIS 用于多视图生成，MAE-VQGAN 和 VICL 用于视觉上下文学习。
图像编辑：分为文本驱动和图像驱动的图像编辑。文本驱动如 VQGAN-CLIP 和 Make-A-Scene，可根据文本输入修改图像。图像驱动如 ControlAR、ControlVAR 等，通过控制机制实现更精确的图像编辑。

3.2 视频生成

无条件视频生成：从无到有创建视频序列，如 Video Pixel Networks、MoCoGAN 等。近期方法如 LVT、VideoGPT 等结合 VQ-VAE 和 Transformer 提高了生成质量。
条件视频生成：根据特定输入生成视频，包括文本到视频合成、视觉条件视频生成和多模态条件视频生成。如 IRC-GAN、CogVideo 等用于文本到视频合成，Convolutional LSTM Network、PredRNN 等用于视觉条件视频生成，MAGE 用于多模态条件视频生成。
具身智能：视频生成在具身智能中用于训练和增强智能体，如学习动作条件视频预测模型、构建通用世界模型等。

3.3 3D 生成

在运动生成、点云生成、场景生成和 3D 医学生成等方面取得进展。如 T2M-GPT 用于运动生成，CanonicalVAE 用于点云生成，Make-A-Scene 用于场景生成，SynthAnatomy 和 BrainSynth 用于 3D 医学生成。

3.4 多模态：

多模态理解框架：通过离散图像视觉词元掩码图像建模方法学习视觉表示，如 BEiT 及其变体。
统一多模态理解和生成框架：将视觉和文本输出生成相结合，如 OFA、CogView 等早期模型，以及 NEXTGPT、SEED 等近期模型。最近还出现了原生多模态自回归模型，如 Chameleon 和 Transfusion。

3. 评估指标

评估视觉自回归模型的性能需要综合考虑多个方面的指标。我们从视觉分词器重建和模型生成的角度分别进行度量：

视觉分词器重建评估：主要关注重建保真度，常用指标包括 PSNR、SSIM、LPIPS 和 rFID 等。例如，PSNR（峰值信噪比）用于衡量重建图像与原始图像之间的像素差异，SSIM（结构相似性指数）则考虑了图像的结构信息和亮度、对比度等因素。

视觉自回归生成评估：包括视觉质量（如负对数似然、Inception Score、Fréchet Inception Distance 等）; 多样性（如 Precision 和 Recall、MODE Score 等）; 语义一致性（如 CLIP Score、R-precision 等）; 时间一致性（如 Warping Errors、CLIPSIM-Temp 等）; 以人为中心的评估（如人类偏好分数、Quality ELO Score 等）。

另外，我们在论文中总结了自回归模型、Diffusion、GAN、MAE 等生成方法在四个常用的图像生成基准上（例如 MSCOCO）的表现，揭示了当前自回归视觉生成方法与 SOTA 方法的差距。

5. 挑战与未来工作

自回归模型在计算机视觉领域虽然取得了一定的成果，但也面临着一些挑战:

5.1 视觉分词器设计：设计能有效压缩图像或视频的视觉分词器是关键挑战，如 VQGAN 及其改进方法，以及利用层次多尺度特性提高压缩效果。例如，可以通过改进向量量化算法、引入注意力机制等方式，提高视觉分词器的性能和压缩效果。

5.2 离散与连续表征的选择：自回归模型传统上采用离散表示，但连续表示在简化视觉数据压缩器训练方面有优势，同时也带来新挑战，如损失函数设计和多模态适应性。例如，可以探索连续表示下的自回归模型，设计合适的损失函数，提高模型在多模态数据上的适应性。

5.3 自回归模型架构中的归纳偏差：探索适合视觉信号的归纳偏差架构，如 VAR 利用层次多尺度视觉词元化，以及双向注意力的优势。例如，可以研究不同的归纳偏差架构对自回归模型性能的影响，寻找最适合视觉信号的架构。

5.4 下游任务：当前视觉自回归模型在下游任务上的研究相对滞后，未来需开发能适应多种下游任务的统一自回归模型。例如，可以将自回归模型应用于目标检测、语义分割等下游任务，探索如何提高模型在这些任务上的性能。

6. 总结

本文对计算机视觉中的自回归模型进行了全面综述，介绍了自回归模型的基础、通用框架分类、与其他生成模型的关系、应用领域、评估指标以及面临的挑战和未来工作。自回归模型在计算机视觉领域具有广阔的应用前景，但仍需进一步研究解决现有问题，以推动其发展和应用。

#HDR-GS

JHU 提出首个可渲染 HDR 场景的 3DGS

本文方法可以根据用户输入的曝光时间来改变渲染场景的光照强度，同时还可以直接渲染高动态范围场景。本文提出的方法比当前最好的算法 HDR-NeRF 速度上要快 1000 倍。

本文介绍我们在 NeurIPS 2024 上的新工作

《HDR-GS: Efficient High Dynamic Range Novel View Synthesis at 1000x Speed via Gaussian Splatting》

本文提出首个可以渲染高动态范围（High Dynamic Range, HDR）自然光的 3D Gaussian Splatting，命名为 HDR-GS，以用于新视角合成（Novel View Synthesis, NVS）。我们的方法可以根据用户输入的曝光时间来改变渲染场景的光照强度，同时还可以直接渲染高动态范围场景。本文提出的方法比当前最好的算法 HDR-NeRF 速度上要快 1000 倍。两者的性能对比如下图 1 所示。我们的工作还被推特科研风向标的 AK 和 MrNeRF 转发报道。

图1 HDR-GS 与 HDR-NeRF 各项性能对比图

Arxiv 文章链接：https://arxiv.org/abs/2405.15125

Github 代码链接：https://github.com/caiyuanhao1998/HDR-GS

Youtube 视频讲解：https://www.youtube.com/watch?v=wtU7Kcwe7ck

AK 推特报道：https://x.com/_akhaliq/status/1794921228462923925?s=46

MrNeRF 推特报道：https://x.com/janusch_patas/status/1794932286397489222?s=46

目前代码，数据，训练日志均已开源。欢迎大家来使用或是遇到问题来提交 issue。

一些渲染的视觉效果图：

1. 高动态范围新视角合成任务介绍

常见的 RGB 图像大都为低动态范围（Low Dynamic Range, LDR），亮度的取值范围在 [0, 255] 之间。然而人眼对亮度的感知范围要比这更宽广得多，一般为 [0, +∞]。这就导致 LDR 图像很难反映真实场景的亮度范围，使得一些较暗或者较亮的区域的细节难以被捕捉。为此，研究人员设计了亮度范围更广的图像类型 - 高动态范围（High Dynamic Range，HDR）图像。新视角合成（Novel View Synthesis，NVS）的主要任务是在给定一个场景的几张相机位姿已知的视角下，合成其他新视角的场景图像。同比于 LDR NVS，HDR NVS 能更好地拟合人类视觉，捕获更多的场景细节，渲染更高质量、视觉效果更好的图片。这门技术在自动驾驶、图像编辑、数字人等方面有着十分广泛的应用。

当前主流的 HDR NVS 方法主要基于神经辐射场（Neural Radiance Fields, NeRF）。然而，NeRF 的 ray tracing 加 volume rendering 机制都十分耗时，常常需要十分密集地采集射线，然后在每一条射线上采集多个 3D 点，对每一个 3D 点过一遍 MLP 来计算它的体密度和颜色。这严重拖慢了训练时间和推理速度。举个例子，当前最好的 NeRF 算法 HDR-NeRF 需要耗费 9 小时来训练一个场景，8.2 秒来渲染一张尺寸为 400x400 的图像。

近期出现的 3D Gaussian Splatting（3DGS）在保证图像质量的同时也大幅提升了训练和渲染速度。然而却很难直接地应用于 HDR NVS 上。主要有三个问题，首先，渲染的图片的动态范围依旧是 [0, 255]，仍旧属于 LDR。其次，直接使用不同光照的图片来训练 3DGS 容易导致模型不收敛，因为 3DGS 的球谐函数（Spherical Harmonics，SH）无法适应光照的变化，时常会导致伪影、模糊、颜色畸变等问题，如下图 2 所示。最后，常规的 3DGS 无法改变渲染场景的亮度，这极大限制了它的应用，尤其是在 AR / VR、电影、游戏等领域，时常需要改变光照条件来反映人物心情与氛围。

图2 常规 3DGS 对比本文的 HDR-GS

本文针对上述这些问题展开研究，做出了以下三点贡献：

我们提出了一个首个基于 3DGS 的方法，HDR-GS，用于三维 HDR 成像。
我们设计了一种有着双动态范围的三维高斯点云模型，同时搭配两条平行的光栅化处理管线以用于渲染 HDR 图像和光照强度可控的 LDR 图像
我们重新矫正了一个 HDR 多视角图像数据集，计算得到的相机参数和初始化点云能够支持 3DGS 类算法的研究。我们提出的算法 HDR-GS 在超过当前最好方法 1.91 dB PSNR 的同时仅使用 6.3 % 的训练时间并实现了 1000 倍的渲染速度。

2. 本文方法

图3 HDR-GS 的整体算法流程

上图 3 展示了我们 HDR-GS 的整体架构。我们首先使用 Structure-from-Motion（SfM）算法来重新矫正场景的相机参数并初始化高斯点云。然后这些数据喂入到我们设计的双动态范围（Dual Dynamic Range，DDR）的高斯点云模型来同时拟合 HDR 和 LDR 颜色，如图 3（b）所示。我们使用 SH 来直接拟合 HDR 颜色。然后使用三个独立的 MLP 来分别对 RGB 三通道做 tone-mapping 操作，根据用户输入的曝光时间将 HDR 颜色转为 LDR 颜色。然后这些 3D 点的 LDR 和 HDR 颜色喂入到我们设计的平行光栅化（Parallel Differentiable Rasterization, PDR）处理管线来渲染出 HDR 和 LDR 图像。本章节，我们首先介绍 DDR 点云模型，然后介绍 PDR 处理管线，最后介绍 HDR-GS 的初始化和训练过程。

2.1 双动态范围高斯点云模型

我们可以将一个场景用一个 DDR 高斯点云模型来表示为：

其中的是 3D Gaussians 的数量, 表示第 i 个 Gaussian。它的中心位置、协方差、不透明度、LDR 颜色和 HDR颜色记为。除了这些属性外, 每一个还包含一个用户输入的曝光时间和一个全局共享的基于 MLP 的 tone-mapper 。由一个旋转矩阵和一个缩放矩阵表示成如下形式:

其中的，和是可学习参数。Tone-mapping 操作模拟相机响应函数来将 HDR 颜色非线性地映射到 LDR 颜色:

为了训练稳定，我们将公式 (3) 从线性域转成对数域如下：

然后对此公式取反函数：

然后我们用三个 MLP 来在 RGB 三通道上分别拟合公式 (5) 的变换。简洁起见, 我们将 tonemapper 的映射函数记为。然后公式（5）便可被重新推导为

然后我们使用 SH 函数来拟合 HDR 颜色如下：

将公式 (7) 代入公式 (6) 便可得到：

每一个独立的 MLP 包括一层全连接、一层 ReLU、一层全连接和一个 Sigmoid 激活函数。

2.2 平行光栅化处理管线

将 3D Gaussian 的 HDR 颜色和 LDR 颜色输入到我们平行光栅化处理管线中分别渲染出 LDR 和 HDR 图像，这一过程可以被概括为如下：

接着我们详细描述这一过程的细节。首先我们计算出第 i 个 3D Gaussian 在一个 3D 点处概率值如下：

然后将 3D Gaussian 从三维空间中投影到 2D 成像平面上。在这一投影过程中，中心点的位置 \mu_i 首先被从世界坐标系变换到相机坐标系，然后再投影到图像坐标系上：

三维协方差矩阵也被从世界坐标系投影到相机坐标系上：

后在图像坐标系下的二维协方差矩阵是直接取的前两行前两列。将 2D projection 分割成互不重叠的 titles。每一个三维高斯点云都按照其对应投影所落在的位置分配到对应的 tiles 上。这些 3D 高斯点云按照与二维探测器平面的距离进行排序。那么, 在 2D projection 上像素点上的 HDR 颜色和 LDR 颜色便是混合个与重叠的排好序的 3D 点得到的, 如下公式所示

2.3 HDR-GS 的初始化与训练过程

阻碍 3DGS 类算法在三维 HDR 成像上发展的一大障碍，是原先 HDR-NeRF 搜集的多视角 HDR 图像数据集的仅提供 normalized device cooridnate（NDC）的相机位姿。然而 NDC 并不适用于 3DGS。主要有两个原因，首先，NDC 描述的是投影后 2D 屏幕上的位置。然而，3DGS 是一个显式的 3D 表征，需要对三维空间中的高斯点云进行变换和投影。其次，NDC 将坐标限制在 [-1, 1] 或者 [0, 1]。Voxel 的分辨率有限，使得 3DGS 很难刻画场景中的细节。另外，原先搜集好的数据中并没有提供 SfM 点云来给 3DGS 进行初始化。

为解决这一问题，我们是使用了 SfM 算法来对多视角 HDR 数据集重新计算相机参数和初始化点云如下：

其中的分别表示相机的内外参数矩阵。对 LDR 图像的训练监督函数如下：

类似于 HDR-NeRF，我们也对 HDR 图像施加限制。但请注意，HDR-NeRF 施加的约束是直接使用 CRF 矫正的 GT 参数，这是一个很强的先验。我们使用的是 - law tone-mapping 后的 HDR 图像。损失函数如下：

最终总的训练损失函数是两者的加权和：

3.实验结果

3.1 定量结果

表1 合成实验对比结果

表2 真实实验对比结果

合成实验和真实实验的定量对比结果分别如表 1 和表 2 所示，我们的 HDR-GS 在性能上显著超过之前方法的同时，训练和推理也分别达到了 16 倍速和 1000 倍速。

3.2 视觉结果

图4 合成场景的 LDR NVS 视觉对比

图5 真实场景的 LDR NVS 视觉对比

图6 HDR NVS 视觉对比

LDR NVS 的视觉对比结果如图 4 和图 5 所示，HDR NVS 的视觉对比结果如图 6 所示。我们的 HDR-GS 能够渲染出更丰富更清晰的图像细节，更好地捕获 HDR 场景并能灵活地改变 LDR 场景的光照强度。

#从39个kaggle竞赛中总结出来的图像分割的Tips和Tricks

作者参加了39个Kaggle比赛，按照整个比赛的顺序，总结了赛前数据的处理，模型的训练，以及后处理等可以助力大家的tips和tricks，非常多的技巧和经验，现在全部分享给大家。

想象一下，如果你能得到所有的tips和tricks，你需要去参加一个Kaggle比赛。我已经超过39个Kaggle比赛，包括：

Data Science Bowl 2017 – $1,000,000
Intel & MobileODT Cervical Cancer Screening – $100,000
2018 Data Science Bowl – $100,000
Airbus Ship Detection Challenge – $60,000
Planet: Understanding the Amazon from Space – $60,000
APTOS 2019 Blindness Detection – $50,000
Human Protein Atlas Image Classification – $37,000
SIIM-ACR Pneumothorax Segmentation – $30,000
Inclusive Images Challenge – $25,000

现在把这些知识都挖出来给你们！

外部数据

使用 LUng Node Analysis Grand Challenge 数据，因为这个数据集包含了来自放射学的标注细节。
使用 LIDC-IDRI 数据，因为它具有找到了肿瘤的所有放射学的描述。
使用Flickr CC，维基百科通用数据集
使用Human Protein Atlas Dataset
使用IDRiD数据集

数据探索和直觉

使用0.5的阈值对3D分割进行聚类
确认在训练集和测试集的标签分布上有没有不一样的地方

预处理

使用DoG（Difference of Gaussian）方法进行blob检测，使用skimage中的方法。
使用基于patch的输入进行训练，为了减少训练时间。
使用cudf加载数据，不要用Pandas，因为读数据更快。
确保所有的图像具有相同的方向。
在进行直方图均衡化的时候，使用对比度限制。
使用OpenCV进行通用的图像预处理。
使用自动化主动学习，添加手工标注。
将所有的图像缩放成相同的分辨率，可以使用相同的模型来扫描不同的厚度。
将扫描图像归一化为3D的numpy数组。
对单张图像使用暗通道先验方法进行图像去雾。
将所有图像转化成Hounsfield单位（放射学中的概念）。
使用RGBY的匹配系数来找到冗余的图像。
开发一个采样器，让标签更加的均衡。
对测试图像打伪标签来提升分数。
将图像/Mask降采样到320x480。
直方图均衡化（CLAHE）的时候使用kernel size为32×32
将DCM转化为PNG。
当有冗余图像的时候，为每个图像计算md5 hash值。

数据增强

使用 albumentations 进行数据增强。
使用随机90度旋转。
使用水平翻转，上下翻转。
可以尝试较大的几何变换：弹性变换，仿射变换，样条仿射变换，枕形畸变。
使用随机HSV。
使用loss-less增强来进行泛化，防止有用的图像信息出现大的loss。
应用channel shuffling。
基于类别的频率进行数据增强。
使用高斯噪声。
对3D图像使用lossless重排来进行数据增强。
0到45度随机旋转。
从0.8到1.2随机缩放。
亮度变换。
随机变化hue和饱和度。
使用D4：https://en.wikipedia.org/wiki/Dihedral_group增强。
在进行直方图均衡化的时候使用对比度限制。
使用AutoAugment：https://arxiv.org/pdf/1805.09501.pdf增强策略。

模型结构

使用U-net作为基础结构，并调整以适应3D的输入。
使用自动化主动学习并添加人工标注。
使用inception-ResNet v2 architecture结构使用不同的感受野训练特征。
使用Siamese networks进行对抗训练。
使用_ResNet50_, Xception, Inception ResNet v2 x 5，最后一层用全连接。
使用global max-pooling layer，无论什么输入尺寸，返回固定长度的输出。
使用stacked dilated convolutions。
VoxelNet。
在LinkNet的跳跃连接中将相加替换为拼接和conv1x1。
Generalized mean pooling。
使用224x224x3的输入，用Keras NASNetLarge从头训练模型。
使用3D卷积网络。
使用ResNet152作为预训练的特征提取器。
将ResNet的最后的全连接层替换为3个使用dropout的全连接层。
在decoder中使用转置卷积。
使用VGG作为基础结构。
使用C3D网络，使用adjusted receptive fields，在网络的最后使用64 unit bottleneck layer 。
使用带预训练权重的UNet类型的结构在8bit RGB输入图像上提升收敛性和二元分割的性能。
使用LinkNet，因为又快又省内存。
MASKRCNN
BN-Inception
Fast Point R-CNN
Seresnext
UNet and Deeplabv3
Faster RCNN
SENet154
ResNet152
NASNet-A-Large
EfficientNetB4
ResNet101
GAPNet
PNASNet-5-Large
Densenet121
AC-GAN
XceptionNet (96), XceptionNet (299), Inception v3 (139), InceptionResNet v2 (299), DenseNet121 (224)
AlbuNet (resnet34) from ternausnets
SpaceNet
Resnet50 from selim_sef SpaceNet 4
SCSEUnet (seresnext50) from selim_sef SpaceNet 4
A custom Unet and Linknet architecture
FPNetResNet50 (5 folds)
FPNetResNet101 (5 folds)
FPNetResNet101 (7 folds with different seeds)
PANetDilatedResNet34 (4 folds)
PANetResNet50 (4 folds)
EMANetResNet101 (2 folds)
RetinaNet
Deformable R-FCN
Deformable Relation Networks

硬件设置

Use of the AWS GPU instance p2.xlarge with a NVIDIA K80 GPU
Pascal Titan-X GPU
Use of 8 TITAN X GPUs
6 GPUs: 2_1080Ti + 4_1080
Server with 8×NVIDIA Tesla P40, 256 GB RAM and 28 CPU cores
Intel Core i7 5930k, 2×1080, 64 GB of RAM, 2x512GB SSD, 3TB HDD
GCP 1x P100, 8x CPU, 15 GB RAM, SSD or 2x P100, 16x CPU, 30 GB RAM
NVIDIA Tesla P100 GPU with 16GB of RAM
Intel Core i7 5930k, 2×1080, 64 GB of RAM, 2x512GB SSD, 3TB HDD
980Ti GPU, 2600k CPU, and 14GB RAM

损失函数

Dice Coefficient ，因为在不均衡数据上工作很好。
Weighted boundary loss 目的是减少预测的分割和ground truth之间的距离。
MultiLabelSoftMarginLoss 使用one-versus-all损失优化多标签。
Balanced cross entropy (BCE) with logit loss 通过系数来分配正负样本的权重。
Lovasz 基于sub-modular损失的convex Lovasz扩展来直接优化平均IoU损失。
FocalLoss + Lovasz 将Focal loss和Lovasz losses相加得到。
Arc margin loss 通过添加margin来最大化人脸类别的可分性。
Npairs loss 计算y_true 和 y_pred之间的npairs损失。
将BCE和Dice loss组合起来。
LSEP – 一种成对的排序损失，处处平滑因此容易优化。
Center loss 同时学习每个类别的特征中心，并对距离特征中心距离太远的样本进行惩罚。
Ring Loss 对标准的损失函数进行了增强，如Softmax。
Hard triplet loss 训练网络进行特征嵌入，最大化不同类别之间的特征的距离。
1 + BCE – Dice 包含了BCE和DICE损失再加1。
Binary cross-entropy – log(dice) 二元交叉熵减去dice loss的log。
BCE, dice和focal 损失的组合。
BCE + DICE - Dice损失通过计算平滑的dice系数得到。
Focal loss with Gamma 2 标准交叉熵损失的升级。
BCE + DICE + Focal – 3种损失相加。
Active Contour Loss 加入了面积和尺寸信息，并集成到深度学习模型中。
1024 * BCE(results, masks) + BCE(cls, cls_target)
Focal + kappa – Kappa是一种用于多类别分类的损失，这里和Focal loss相加。
ArcFaceLoss — 用于人脸识别的Additive Angular Margin Loss。
soft Dice trained on positives only – 使用预测概率的Soft Dice。
2.7 * BCE(pred_mask, gt_mask) + 0.9 * DICE(pred_mask, gt_mask) + 0.1 * BCE(pred_empty, gt_empty) 一种自定义损失。
nn.SmoothL1Loss()。
使用Mean Squared Error objective function，在某些场景下比二元交叉熵损失好。

训练技巧

尝试不同的学习率。
尝试不同的batch size。
使用SGD + 动量并手工设计学习率策略。
太多的增强会降低准确率。
在图像上进行裁剪做训练，全尺寸图像做预测。
使用Keras的ReduceLROnPlateau()作为学习率策略。
不使用数据增强训练到平台期，然后对一些epochs使用软硬增强。
冻结除了最后一层外的所有层，使用1000张图像进行微调，作为第一步。
使用分类别采样
在调试最后一层的时候使用dropout和增强
使用伪标签来提高分数
使用Adam在plateau的时候衰减学习率
用SGD使用Cyclic学习率策略
如果验证损失持续2个epochs没有降低，将学习率进行衰减
将10个batches里的最差的batch进行重复训练
使用默认的UNET进行训练
对patch进行重叠，这样边缘像素被覆盖两次
超参数调试：训练时候的学习率，非极大值抑制以及推理时候的分数阈值
将低置信度得分的包围框去掉。
训练不同的卷积网络进行模型集成。
在F1score开始下降的时候就停止训练。
使用不同的学习率。
使用层叠的方法用5 folds的方法训练ANN，重复30次。

评估和验证

按类别非均匀的划分训练和测试集
当调试最后一层的时候，使用交叉验证来避免过拟合。
使用10折交叉验证集成来进行分类。
检测的时候使用5-10折交叉验证来集成。

集成方法

使用简单的投票方法进行集成
对于类别很多的模型使用LightGBM，使用原始特征。
对2层模型使用CatBoost。
使用 ‘curriculum learning’ 来加速模型训练，这种训练模式下，模型先在简单样本上训练，再在困难样本上训练。
使用ResNet50, InceptionV3, and InceptionResNetV2进行集成。
对物体检测使用集成。
对Mask RCNN, YOLOv3, 和Faster RCNN 进行集成。

后处理

使用test time augmentation ，对一张图像进行随机变换多次测试后对结果进行平均。
对测试的预测概率进行均衡化，而不是使用预测的类别。
对预测结果进行几何平均。
在推理的时候分块重叠，因为UNet对边缘区域的预测不是很好。
进行非极大值抑制和包围框的收缩。
在实例分割中使用分水岭算法后处理来分离物体。

#MagicMotion

拒绝“随意运动”! 复旦联合微软提出：视频生成精准轨迹控制新范式

本文共同第一作者为复旦大学研究生李全昊、邢桢，通讯作者为复旦大学吴祖煊副教授。

，时长00:04

近年来，视频生成技术快速发展,显著提升了视频的视觉质量与时间连贯性。在此基础上，轨迹可控的视频生成（trajectory-controllable video generation）涌现了许多工作，使得通过明确定义的路径精确控制生成视频中的物体运动轨迹成为可能。

然而，现有方法在处理复杂的物体运动轨迹和多物体轨迹控制方面仍面临挑战，导致生成的视频物体移动轨迹不够精确，或者整体视觉质量较低。

此外，这些方法通常仅支持单一格式的轨迹控制，限制了其在不同应用场景中的灵活性。不仅如此，目前尚无专门针对轨迹可控视频生成的公开数据集或评价基准，阻碍了该领域的更进一步的深入研究与系统性评估。

为了解决这些挑战，研究人员提出了 MagicMotion，一种创新的图像到视频生成框架，支持三种不同级别的轨迹控制条件——分别为掩码、边界框和稀疏框。

在给定一张输入图像和对应物体轨迹的情况下，MagicMotion 能够精准地控制物体沿着指定轨迹运动，同时保持视频的视觉质量。

此外，本文构建了 MagicData，一个大规模的轨迹控制视频数据集，并配备了一套自动化的标注与筛选流程，以提升数据质量和处理效率。

本文还引入了 MagicBench，一个专为轨迹控制视频生成设计的综合评测基准，旨在评估在控制不同数量物体运动情况下的视频质量及轨迹控制精度。

大量实验表明，MagicMotion 在多个关键指标上均超越现有方法，展现出卓越的性能。

，时长03:04

论文地址：https://arxiv.org/abs/2503.16421
论文主页：https://quanhaol.github.io/magicmotion-site/
论文标题：MagicMotion: Controllable Video Generation with Dense-to-Sparse Trajectory Guidance

方法介绍

MagicMotion 基于 CogVideoX5B-I2V 这一图像到视频生成模型，并引入了额外的轨迹控制网络（Trajectory ControlNet）。该设计能够高效地将不同类型的轨迹信息编码到视频生成模型中，实现轨迹可控的视频生成。

如图所示，本文使用 3D VAE 编码器将轨迹图编码到隐空间，然后将其与编码后的视频拼接，作为轨迹控制网络的输入。轨迹控制网络由所有预训练的 DiT 模块的可训练副本构建而成，用于编码用户提供的轨迹信息。每个轨迹控制网络模块的输出随后会通过一个零初始化的卷积层进行处理，并添加到基础模型中对应的 DiT 模块，以提供轨迹引导。

MagicMotion 采用了从密集轨迹控制到稀疏轨迹控制的渐进式训练过程，其中每个阶段都用前一阶段的权重来初始化其模型。这使得能够实现从密集到稀疏的三种类型的轨迹控制。

本文发现，与使用稀疏条件从头开始训练相比，这种渐进式训练策略有助于模型取得更好的性能。具体来说，本文在各个阶段采用以下轨迹条件：阶段 1 使用分割掩码，阶段 2 使用边界框，阶段 3 使用稀疏边界框，其中少于 10 帧有边界框标注。此外，本文总是将轨迹条件的第一帧设置为分割掩码，以指定应该移动的前景对象。

此外，MagicMotion 还提出了隐分割损失（latent segment loss），它在模型训练过程中引入分割掩码信息，增强了模型对物体细粒度形状的感知能力。研究者使用轻量级分割头直接在隐空间中预测出分割掩码，从而在引入极小计算开销的情况下，无需进行解码操作，帮助模型在生成视频的同时在潜在空间中执行物体分割任务，从而更好地理解物体的细粒度形状。

研究者还提出了一个全新的自动数据处理流程，包括两个主要阶段：数据整理流程（Curation Pipeline）和数据筛选流程（Filtering Pipeline）。数据整理流程负责从大规模的视频-文本数据集中构造轨迹信息，而数据筛选流程则确保在训练前移除不适合的视频。

实验与结果

MagicMotion的每个阶段都在MagicData上训练一个轮次。训练过程包括三个阶段。阶段1从零开始训练轨迹控制网络（Trajectory ControlNet）。在阶段2中，使用阶段1的权重进一步优化轨迹控制网络（Trajectory ControlNet），同时从零开始训练分割头（Segment Head）。

最后，在阶段3中，轨迹控制网络（Trajectory ControlNet）和分割头（Segment Head）都使用阶段2的权重继续训练。研究者采用AdamW作为优化器，所有训练实验均在 4 张 NVIDIA A100-80G GPU 上进行，学习率设为 1e-5。

研究者将 MagicMotion 与7种流行的轨迹可控图像到视频（I2V）方法进行了对比，在MagicBench和DAVIS上对所有方法进行评估。

结果如下表所示，MagicMotion在MagicBench和DAVIS上的所有指标上都优于以往的所有方法，这表明它能够生成更高质量的视频并实现更精确的轨迹控制。

此外，本文根据受控对象的数量评估了每种方法在MagicBench上的性能。如下图所示，MagicMotion方法在所有受控物体数量的类别中都取得了最佳结果，进一步证明了该方法的优越性。

定性对比结果

如下图所示，Tora能够精准控制运动轨迹，但难以精确保持物体的形状。DragAnything 、ImageConductor 和 MotionI2V 在保持主体一致性方面存在困难，导致后续帧中出现明显的形变。同时，DragNUWA、LeviTor 和 SG-I2V生成的结果经常出现视频质量低下和细节不一致的问题。相比之下，MagicMotion能够使移动的物体平滑地沿指定轨迹运动，同时保持高质量的视频生成效果。

#NOVA

不用向量量化也能高质量生成？重新定义自回归视觉建模

一种高效的自回归视频生成方法，通过非量化建模和双向注意力机制，显著降低了训练成本并提升了生成质量，同时在文本到图像和视频任务中展现了强大的zero-shot泛化能力。

自回归视频生成 (Emu3) + Diffusion Loss (MAR)。

NOVA 是一种自回归视频生成技术，而且不涉及 Vector Quantization 的过程。NOVA 在帧间，时序上，采用标准的自回归 frame-by-frame prediction；在帧内，空间上，采用 MAR 式的 set-by-set prediction。

NOVA 在帧间保持了 GPT-style 的 causal 模式，以使得整个模型有灵活的 in-context 能力，那么在帧内有使用 bi-directional attention，效率高。

NOVA 特点：

NOVA 首先按顺序预测 temporal frames，然后预测每一帧内的 spatial sets。
NOVA 第一个把 MAR 的 Non-quantized 思路用在了视频生成。

NOVA 硬指标：

视频生成：VBench 80.1

文生图：GenEval 0.75

下面是对本文的详细介绍。

图1：NOVA 是一个 Non-quantized 的自回归模型，用于高效灵活的视觉生成

1 NOVA：无需矢量量化的自回归视频生成

论文名称：Autoregressive Video Generation without Vector Quantization (ICLR 2025)

论文地址：http://arxiv.org/pdf/2412.14169

项目主页：http://github.com/baaivision/NOVA

1.1 NOVA 模型

在视觉生成领域，基于自回归的方法通常使用矢量量化 (Vector Quantization) 将图像或视频转换为 discrete tokens。然而，vector quantization tokenizer 同时实现高保真度和高压缩比很有挑战性。高质量意味着需要的 token。因此，随着视频中图像分辨率更高，视频更长，成本会大幅增加。

相比之下，视频扩散模型[1][2][3]在紧凑的 Continuous Latent Space 中使用高度压缩的视频序列进行学习。然而，它们中的大多数只学习固定长度的帧的联合分布，缺乏生成不同长度的视频的灵活性。更重要的是，它们不具备自回归模型的 in-context 能力，即使用统一的模型 (例如 GPT) 在 in-context 地解决不同的任务。

NOVA 实现了高效率的自回归视频生成。

NOVA 的做法是：依然使用自回归建模，但不使用 Vector Quantization。同时，把 Video Generation 的问题转化为 frame-by-frame prediction 和 spatial set-by-set prediction 的问题。

NOVA 受 Emu3[4]对于自回归视频生成的启发，以及受 MAR[5]对于non-quantized 自回归图像生成的启发，把视觉 token 表示为 non-quantized 向量，set-by-set 地执行自回归预测。

具体来说，NOVA 在时间维度上 causal 地预测每个 frame，在空间维度上 random 地预测每个 token set。通过 Non-quantized tokenizer 和灵活的自回归框架，NOVA 同时实现：1) 高保真度和紧凑的视觉压缩，使得训练和推理成本较低，2) 在统一模型中集成多个视觉生成任务的 in-context 能力。

1.2 视频生成中的自回归建模

视频生成中的自回归建模主要有 2 种方法。

1) 以 raster-scan order 逐 token 地生成

这种方法在视频帧序列内执行 causal per-token prediction，根据 raster-scan order 依次解码视觉 token，定义如下：

其中，代表所有 video token，为个 video raster－scale tokens 中的第个，为各种各样的 condition 上下文（比如 label，text，image）。

2) 以 random order masked set-by-set 地生成

这种方法平等对待每个视频帧中的所有 token，使用 Bi-directional Transformer[6]的 Decoder 进行 set-by-set 地预测。

但是，这种模型是在很多长度固定的视频帧上训练的，可能导致上下文的可扩展性较差，且在长时间的视频的情况下有连贯性问题。

NOVA 提出了一种新颖的解决方案：在单个视频帧中使用 per-set 生成，对整个视频序列使用 per-frame prediction，把每帧内部生成的范式和帧间生成的范式解耦。这样的做法允许 NOVA 更好地处理时间因果关系和空间关系，提供更灵活和可扩展的自回归框架。

1.3 帧间时序自回归建模：自回归地预测时序的每一帧

NOVA 在帧间执行时序自回归建模，即自回归地预测时序的每一帧，如下图 2 所示。

图2：NOVA 框架和推理过程。使用 text 输入，NOVA 在时序上进行 frame-by-frame prediction，在每一帧进行 spatial set-by-set prediction，都按照自回归的形式。最后，在连续值空间中做 denoising

NOVA 使用 Phi-2 编码 text 信息。为了更好地控制视频动态，使用 OpenCV (cv2) 来计算采样视频帧的光流。平均 flow magnitude 用作 motion score 并与 prompt 集成。

VAE 采用开源的 3D VAE[7]，temporal stride 为 4，spatial stride 为 8，将视频帧编码到 latent space。

Patch Embedding 层的 stride 为 4，将 latent video 的 channel 对齐，使其可以输入后续的 Transformer 中。

视频帧可以自然地被视为 causal 序列，每帧充当自回归生成的 meta unit。

NOVA 实现了图 3 中的 block-wise causal masking attention，确保每一帧只能关注 text prompts，video flow 以及前一帧，同时允许所有当前帧的 token 彼此可见：

其中，代表 video frame 的数量，分别是 text prompts 和 video flow，代表第帧的所有的 tokens，代表 learnable begin－of－video（BOV）embeddings，用于预测初始的 video frame（其数量等于单帧的 patch 数）。根据式 2：

可以把 text－to－image 和 image－to－video 的过程写为和。其中，代表根据 text prompts 和 video flow 和 begin－of－video（BOV）embeddings，来预测第1 帧，代表根据 video flow，begin－of－video（BOV）embeddings 以及前帧来预测第帧。

这种范式可以大大提高训练效率，并允许 KV-cache 在推理过程中快速解码。

图3：NOVA 使用的 Block-wise temporal attention 与常规 Per-token prediction 的对比。与 Per-token generation 不同，NOVA 在时间尺度上以随意的顺序回归预测每一帧

1.4 帧内空间广义的自回归建模：set-by-set 地预测

受 MaskGIT[8]和 MAR[5]的启发，作者使用 MAR 的 generalized 自回归过程来生成每个 frame 的 tokens，并借助高效的并行解码。如图 4 所示是帧内广义的空间自回归过程。作者利用 indicator features 来辅助空间层，逐渐解码图像中所有随机 masked 的 token set。这种方法会导致随着帧数的增加，图像结构崩溃以及视频流畅度不一致。作者觉得这是因为相邻帧的 indicator features 相似，使得在没有显式建模的情况下很难准确地学习连续和难以察觉的运动变化。此外，在训练期间从真实上下文帧导出的 indicator features 有助于空间 AR。

作者引入了一个 Scaling 和 Shift Layer，通过学习统一空间中的相对分布变化来重新制定跨帧运动变化。具体做法是把 temporal layers 的 BOV-attended output 经过 MLP 之后再经过 Scaling 和 Shift Layer。使用 unmasked 的 token，作者 set-by-set 地预测 random masked 的视觉 token：

其中，代表 indicator features，其目的是生成第帧。代表第帧的第个 token set。是这图片一共的 set 数。

图4：NOVA 使用的 Spatial generalized autoregressive attention 与常规 Per-token prediction 的对比。与 Per-token generation 不同，NOVA 在空间尺度上以随机顺序预测每个 token set

在帧内，相当于是做广义的空间自回归预测，可以实现高效的推理，以及并行解码。

值得一提的是，作者为 temporal and spatial AR layers 的残差连接之后增加了 post-norm layers。

1.5 对每个 token 预测使用 Diffusion Loss

在训练期间，NOVA 按照 MAR[5]的做法使用 Diffusion Loss 来估计连续值空间中的 per-token 概率。例如，将 GT token 定义为，NOVA 的输出定义为。损失函数可以表述为：

其中，是从中采样的高斯噪声向量，噪声数据为为 noise schedule。是扩散模型（一个 MLP）。

的意思是以为 condition，以为输入。

NOVA 按照 MAR[5]的做法为每个图像在训练期间将采样 4 次。

在推理过程中，作者从随机高斯噪声中采样，并通过对进行逐步去噪，直到采样获得。其中，是第步的噪声等级，是从随机高斯噪声中采样的。

1.6 NOVA 训练数据集

首先做了 16M image-text pairs，从 DataComp，COYO，Unsplash 以及 JourneyDB。然后把数据集扩展到约 600M image-text pairs，通过从 LAION、DataComp 和 COYO 中选择美学分数最小为 5 的图像。

选择 19M video-text pairs，来自 Panda-70M 的子集。以及内部的 video-text pairs。

从 Pexels 选择 1M 高分辨率 video-text pairs。最大文本长度为 256。

1.7 NOVA 架构和训练

Spatial AR 层和 denoising MLP block：来自 MAR 的设计。

temporal encoder, spatial encoder，decoder：16 层，dimension 分别为 768 (0.3B), 1024 (0.6B) 和 1536 (1.4B)。

denoising MLP：3 层，1280 维度。

Spatial layers 使用 MAR 的 encoder-decoder 架构。

预训练的 VAE 来自 Open-sora plan，时间维度上 4× 压缩，空间维度上实现 8×8 压缩。

masking schedulers 使用 MAR 思路，diffusion schedulers 使用 IDDPM。训练 1000-step noise schedule，推理 100 steps。

从头开始训练 text-to-image 模型，然后加载这些权重来训练 text-to-video模型。

评测：

T2I：T2I-CompBench, GenEval 和 DPG-Bench。

T2V：VBench 来评估文本到视频生成在 16 维方面的能力。

对于给定的文本提示，随机生成 5 个样本，每个样本视频大小为 33×768×480。

采用 classifier-free guidance，值为 7.0，以及 128 个自回归步骤，以提高所有评估实验中生成的图像和视频的质量。

1.8 NOVA 实验结果

NOVA 优于现有的文生图模型，具有卓越的性能和效率。

图 5 将 NOVA 与最近的几个文生图模型进行比较，包括 PixArt-α、SD v1/v2、SDXL、DALL-E2、DALL-E3 、SD3、LlamaGen 和 Emu3。NOVA 在 GenEval Benchmark 中实现了最先进的性能，尤其是在生成指定数量的目标方面。值得注意的是，NOVA 在 T2I-CompBench 和 DPG-Bench 上也取得了领先的结果。VOVA 文生视频模型优于大多数专门文生图模型，例如 SD v1/v2、SDXL 和 DALL-E2。

图5：不同 benchmark 下的 Text-to-image evaluation

NOVA 与文生视频扩散模型性能相当，超过自回归模型。作者进行了一项定量分析，将 NOVA 与开源和专有的文本到视频模型进行比较。如图 6 所示，尽管 NOVA 小得多 (0.6B 与 9B)，但在各种文本到视频评估指标中，NOVA 显著地优于 CogVideo。它还匹配最新的 SOTA 模型 Emu3 的性能 (80.12 vs. 80.96)，且模型尺寸明显更小 (0.6B vs. 8B)。此外，作者将 NOVA 与最先进的扩散模型进行了比较，例如 Gen-2、Kling 和 Gen-3 ，以及 LaVie、Show-1、AnimateDiff-v2、VideoCrafter-v2.0、T2V-Turbo、OpenSora-v1.1、OpenSoraPlan-v1.1/v1.2 和 CogVideoX。NOVA 缩小了自回归架构和扩散模型之间的差距，提高了视频生成的质量和指令跟踪能力。此外，在推理延迟方面，NOVA 比现有模型表现出显著的速度优势。

图6：VBench 的 Text-to-video evaluation

图 7 中展示了定性比较结果。 NOVA 在一系列提示样式中表现出强大的视觉质量和保真度，并且在颜色属性绑定和空间对象关系方面表现出色。图 8 中展示了文生视频的可视化，突出了 NOVA 能够根据提供的文本提示捕获多视图视角、平滑对象运动和稳定的场景转换的能力。

图7：Text-to-image generation 结果

图8：Text-to-video generation 结果

通过预填充参考图像，NOVA 还可以从图像生成视频，无论是否附带文本。图 9 提供了一个示例。我们表明，NOVA 可以在没有文本提示的情况下模拟真实的运动。此外，当包含文本时，透视运动显得更加自然。这表明NOVA 能够捕获基本物理，如相互作用力和流体动力学。

图9：不同上下文的 Zero-shot generalization。NOVA 成功地保持了对象中的时间一致性，无论是否有文本输入

参考

Video generation models as world simulators
Kling ai
Stable video diffusion: Scaling latent video diffusion models to large datasets
Emu3: Next-Token Prediction is All You Need
Autoregressive image generation without vector quantization
Magvit: Masked generative video transformer
Open-sora plan: Open-source large video generation model
Maskgit: Masked generative image transformer

#MMGDreamer

北大&数原提出：混合模态图驱动，几何可控的3D室内场景生成新标杆

本篇分享论文CFG-Zero*: Improved Classifier-Free Guidance for Flow Matching Models，是由南洋理工大学S-Lab 与普渡大学提出的无分类引导新范式，支持所有Flow-Matching的生成模型。

项目主页：https://weichenfan.github.io/webpage-cfg-zero-star/
代码仓库：https://github.com/WeichenFan/CFG-Zero-star
论文地址：https://arxiv.org/abs/2503.18886

随着生成式AI的快速发展，文本生成图像与视频的扩散模型（Diffusion Models）已成为计算机视觉领域的研究与应用热点。近年来，Flow Matching作为一种更具可解释性、收敛速度更快的生成范式，正在逐步取代传统的基于随机微分方程（SDE）的扩散方法，成为主流模型（如Lumina-Next、Stable Diffusion 3/3.5、Wan2.1等）中的核心方案。

然而，在这一技术迭代过程中，一个关键问题依然存在：如何在推理阶段更好地引导生成过程，使模型输出更加符合用户提供的文本描述。Classifier-Free Guidance（CFG）是当前广泛采用的引导策略，但其引导路径在模型尚未充分训练或估计误差较大时，容易导致样本偏离真实分布，甚至引入不必要的伪影或结构崩塌。

对此，南洋理工大学S-Lab与普渡大学的研究者联合提出了创新方法——CFG-Zero⋆，针对传统CFG在Flow Matching框架下的结构性误差进行了理论分析，并设计了两项轻量级但效果显著的改进机制，使生成图像/视频在细节保真度、文本对齐性与稳定性上全面提升。

背景分析：CFG为何失效？

传统的CFG策略通过对有条件与无条件预测结果进行插值来实现引导。然而在Flow Matching模型中，推理过程是通过解常微分方程（ODE）进行的，其每一步依赖于前一步的速度估计。当模型训练不足时，初始阶段的速度往往较为不准确，而CFG此时的引导反而会将样本推向错误轨迹。研究者在高斯混合分布的可控实验中发现，CFG在初始步的引导效果甚至不如“静止不动”，即设速度为0。

方法简介

为此，研究者提出了CFG-Zero⋆，并引入以下两项关键创新：

优化缩放因子（Optimized Scale）：在每个时间步中动态计算有条件速度与无条件速度的内积比值，从而调整CFG中无条件项的强度，避免“过度引导”导致的伪影问题。
零初始化（Zero-init）：将ODE求解器的前K步速度置为零（默认K=1），跳过模型最不可靠的预测阶段，有效降低初始误差传播。

这两项策略可无缝集成至现有的CFG推理流程中，几乎不引入额外计算开销。

实验结果

研究者在多个任务与主流模型上验证了CFG-Zero⋆的有效性，涵盖了文本生成图像（Text-to-Image）与文本生成视频（Text-to-Video）两大方向。在图像生成任务中，研究团队选用了Lumina-Next、SD3、SD3.5、Flux等当前SOTA模型进行对比实验，结果显示CFG-Zero⋆在Aesthetic Score与CLIP Score两项核心指标上均优于原始CFG。

例如在Stable Diffusion 3.5上，美学分有明显提高，不仅图像美感更强，而且语义一致性更好。在T2I-CompBench评测中，CFG-Zero⋆在色彩、纹理、形状等多个维度均取得更优表现，特别适用于需要精准表达复杂语义的生成任务。

在视频生成任务中，研究者将CFG-Zero⋆集成到Wan2.1模型中，评估标准采用VBench基准套件。结果表明，改进后的模型在Aesthetic Quality、Imaging Quality、Motion Smoothness等方面均有所提升，呈现出更连贯、结构更稳定的视频内容。CFG-Zero⋆有效减少了图像跳变与不自然的位移问题。

实际测试

CFG-Zero⋆在开源社区中实现了快速落地。目前，该方法已正式集成至图形化扩展框架ComfyUI，并被纳入视频生成模型Wan2.1GP的推理流程。借助这些集成，普通开发者与创作者也能轻松体验该方法带来的画质与文本对齐提升。

我们使用官方的repo用这张测试图：

输入prompt：“Summer beach vacation style, a white cat wearing sunglasses sits on a surfboard. The fluffy-furred feline gazes directly at the camera with a relaxed expression. Blurred beach scenery forms the background featuring crystal-clear waters, distant green hills, and a blue sky dotted with white clouds. The cat assumes a naturally relaxed posture, as if savoring the sea breeze and warm sunlight. A close-up shot highlights the feline's intricate details and the refreshing atmosphere of the seaside.”

得到的视频如下：（第一个为原始CFG生成的，第二个为CFG-Zero*生成的），效果还是比较明显，值得尝试。

#EasyControl

DiT控制新纪元！"即插即控"，Tiamat AI重磅开源：任意比例出图+推理速度狂飙

一个面向DiT模型的条件生成框架EasyControl，通过条件注入LoRA模块、位置感知训练范式和因果注意力机制等创新，实现了高效、灵活的条件控制，支持任意分辨率图像生成并显著提升推理速度，广泛兼容社区定制模型。

文章链接：https://arxiv.org/abs/2503.07027

项目链接：https://github.com/Xiaojiu-z/EasyControl

亮点直击

提出了EasyControl，一种面向DiT模型的条件生成新范式。EasyControl中，每个条件通过独立的条件分支进行处理，该分支通过条件注入LoRA模块从预训练DiT模型适配而来。此设计实现了与定制模型的无缝集成，支持灵活的条件注入与多条件高效融合。
高效性：框架通过两项关键创新实现高效计算。位置感知训练范式将输入条件标准化为固定分辨率，确保适应性与计算效率；因果注意力机制与KV缓存技术的结合，首次在条件生成任务中成功应用KV缓存，显著降低延迟并提升整体效率。
灵活性：EasyControl支持生成不同分辨率与长宽比的图像，通过平衡高质量生成与多样化需求，确保跨场景的鲁棒性能。

总结速览解决的问题

计算效率瓶颈

DiT架构中，自注意力机制因图像token的引入导致计算复杂度呈平方级增长，增加推理延迟，限制实际应用扩展。

多条件协同控制困难

现有方法在单条件训练范式下难以实现多条件稳定协同，潜在空间中的条件信号表征冲突导致生成质量下降，尤其在零样本多条件组合场景中表现不佳。

模型适配性不足

当前参数高效微调方法（如LoRA）与社区定制模型存在参数冲突，导致风格迁移时特征退化，模块缺乏真正的即插即用特性。

提出的方案

轻量级条件注入模块（Condition Injection LoRA Module）

通过隔离处理条件信号，以并行分支机制注入预训练模型，仅对条件分支token应用低秩投影，冻结文本和噪声分支权重，实现与定制模型的无缝兼容。

位置感知训练范式（Position-Aware Training Paradigm）

标准化输入条件的分辨率，结合位置感知插值技术，保持条件token与噪声token的空间一致性，支持任意长宽比和多分辨率生成。

因果注意力机制与KV缓存（Causal Attention + KV Cache）

在初始扩散步（t=0）预计算条件特征的Key-Value对并缓存，后续时间步（t≥1）直接复用，显著减少重复计算。

应用的技术

低秩自适应（LoRA）

条件分支采用低秩矩阵分解，避免修改基础模型权重，实现高效参数微调。

分辨率归一化与位置感知插值

将输入条件缩放到固定分辨率以减少序列长度，通过插值技术保留空间信息。

因果注意力与KV缓存优化

将传统全注意力替换为因果注意力，结合KV缓存技术复用条件特征，降低计算开销。

达到的效果

高效推理

KV缓存技术减少约30%的推理延迟，支持实时生成；分辨率归一化降低输入序列长度，提升计算效率。

灵活控制

零样本多条件泛化能力：即使仅训练单条件数据，仍可和谐融合多条件（如空间控制+主体驱动）。

广泛兼容性

即插即用设计兼容社区定制模型（如风格化DiT），无需重新训练即可适配多样任务。

高质量生成

在虚拟试穿、图像编辑、多分辨率生成等任务中，生成质量显著优于基线方法（如ControlNet for DiT）。

效果可视化对比多条件生成设置下与身份自定义方法比较

空间控制生成可视化对比

不同分辨率生成设置下与基线方法可视化比较

主题控件生成可视化

方法

本节将详细介绍EasyControl的技术实现，方法整体框架如下图2所示。EasyControl基于FLUX.1开发平台构建，包含以下核心组件：条件注入LoRA模块、因果注意力机制、位置感知训练范式以及推理KV缓存。

条件注入LoRA模块

为高效融合条件信号并保持预训练模型的泛化能力，在FLUX架构中扩展了独立的条件分支。与传统添加独立控制模块的方法不同，本方案通过以下方式实现条件信息的无缝集成，同时避免冗余参数与计算开销：

在基于Transformer的架构中，输入特征表示需先通过（查询），（键），（值）投影才能进入自注意力计算。给定输入表示（去噪分支），（噪声分支）和（条件分支），标准QKV变换定义为：

其中是所有分支共享的投影矩阵。虽然这种设计实现了高效的参数共享，但未能显式优化条件信号的表示。为克服这一局限，引入LoRA（低秩自适应） 技术，在保持其他分支不变的前提下自适应增强条件表示：

因此，条件分支更新后的QKV特征可表示为：

其中（满足）是参数化LoRA变换的低秩矩阵。需特别说明的是，文本分支和噪声分支的参数始终保持不变。

通过仅在条件分支应用基于LoRA的自适应机制，确保条件信号能高效注入模型，同时不破坏预训练的文本和噪声表征。这种定向自适应使模型能灵活整合条件信息，同时保持原始特征空间的完整性，从而实现更具可控性和高保真度的图像生成。

EasyControl 中的因果注意力机制

因果注意力是一种单向注意力机制，通过限制序列模型中的信息流，使每个位置仅能关注其自身及之前的位置，从而强制实现时序因果性。该机制通过在Softmax操作前对注意力logits施加由0 和组成的掩码来实现，其数学表达式为：

其中用于强制因果约束，是来自噪声分支，、文本分支和条件分支的拼接特征。为提高推理效率并有效整合多条件信号，我们设计了两种专用因果注意力机制：条件因果注意力和互因果注意力。这些机制通过不同的掩码策略控制信息流，以平衡条件聚合与隔离。

条件因果注意力

该机制强制两条规则：

各条件分支内部进行条件内计算
采用注意力掩码防止训练期间条件token查询去噪（文本&噪声）token

形式化定义单条件训练时的输入序列为：

其中表示噪声和文本token，代表条件token。我们定义一个注意力 mask 来调节注意力流。具体而言，该 mask 的数学表达式为：

该设计通过阻断条件分支到去噪分支（噪声&文本）的单向注意力，同时允许去噪分支token自由聚合条件信号。通过严格隔离条件到去噪的查询操作，该方案在推理时可实现各分支解耦的KV缓存状态，从而减少冗余计算并显著提升图像生成效率。

互因果注意力

本文模型仅使用单条件输入训练，每个条件token学习与去噪token的优化交互。在多条件推理时，虽然所有条件都与去噪token正常交互，但由于未训练的跨条件token交互会导致条件间干扰（见下图5）。

该机制通过以下形式化定义实现多条件推理时的输入序列：

其中表示噪声与文本token，对应第个条件的token。定义注意力mask 来调控注意力流，其具体形式化表达为：

其中表示总序列长度。这种结构化掩码确保：图像token能聚合所有条件信息，同时保持不同条件间的隔离，避免相互干扰。

位置感知训练范式

为提升条件图像生成的计算效率和分辨率灵活性，提出位置感知训练范式。该范式基于基础方法：将高分辨率控制信号从原始尺寸下采样至目标分辨率（实验设定）。缩放后的图像通过VAE编码器映射到潜空间，经Patchify操作提取条件token后，与原始DiT模型的噪声token和文本token共同进行迭代去噪。

虽然这种基础下采样方法对主体条件（如人脸图像）有效，但会破坏空间条件（如Canny边缘图）的几何对齐性，限制模型生成任意分辨率图像的能力。为此，引入两种定制策略：

位置感知插值（PAI）：针对空间条件，在缩放时保持像素级对齐；
位置编码偏移策略（详见附录B）：针对主体条件，在高度维度施加固定位移。

位置感知插值

为保持条件token与噪声token的空间一致性，提出位置感知插值（PAI） 策略，在条件信号缩放过程中对位置编码进行插值。该方法确保模型能精确捕捉控制条件与生成图像像素间的空间关系。

给定原始条件图像尺寸和目标尺寸，缩放因子计算如下：

其中和分别表示高度和宽度方向的缩放因子。

对于调整后的条件图像中的给定块，其在原始图像中的对应位置通过下式映射：

其中和。该映射将调整后图像中的任意块对齐到原始图像中的对应位置。

原始图像中的位置编码序列表示为：

而调整大小后的图像的插值序列为：

这确保了调整大小后的图像中空间关系的保留。

损失函数

本文损失函数使用流匹配损失。其数学表达式如下：

其中，表示时间的图像特征，是输入条件，表示速度场，指原始图像特征，是预测噪声。

通过KV缓存实现高效推理

通过利用因果注意机制，本文框架将条件分支隔离为一个与去噪时间步无关的计算模块。这种独特设计使得在推理过程中能够新颖地应用KV缓存技术。由于条件分支的计算与去噪时间步无关，在初始时间步只需预计算并存储所有条件特征的键值（KV）对一次。这些缓存的KV对在所有后续时间步中重复使用，消除了相同条件特征的冗余重新计算。这种方法通过避免N次重新计算（针对N个去噪步骤）来减少推理延迟，同时保持生成质量和模型灵活性。

实验

本节首先描述EasyControl的实现细节，然后概述评估指标。接下来，展示实验结果，包括定性和定量分析，以及消融实验。

实现细节

采用FLUX.1 dev作为预训练的DiT。对于每个空间或主题条件训练，我们使用4个A100 GPU（80GB），每个GPU的批量大小为1，学习率为1e-4，训练100,000步。在推理期间，应用流匹配采样进行25个采样步骤。

实验设置

视觉比较： 我们评估以下设置：(1) 单条件生成，(2) 使用定制模型的单条件适应，(3) 多条件集成（如下图3和下图4所示），以及(4) 分辨率适应性。定量比较：我们评估以下方面：(1) 单条件和双条件生成下的推理时间和模型参数数量（以评估效率，如下表1所示），(2) 使用面部+OpenPose作为多条件的可控性、生成质量和文本一致性，以及(3) 单条件设置下的可控性、生成质量和文本一致性。

比较方法： 对于单条件，与Controlnet、OminiControl和Uni-ControlNet进行比较。对于多条件设置，评估本文方法与几个即插即用基线方法，包括Controlnet+IP-Adapter、Controlnet+Redux和Uni-Controlnet。还比较了与ControlNet集成的几种ID定制方法[15, 35, 71]。

实验结果

定性比较

上图3 (a)比较了不同方法在单控制条件下的性能。在Canny控制下，Uni-ControlNet和ControlNet表现出颜色不一致，导致与输入文本偏离。在深度控制下，Uni-ControlNet未能生成连贯的图像，而ControlNet和OmniControl引入了伪影，例如狗和沙发的融合。在OpenPose控制下，本文方法保留了文本渲染，而其他方法则削弱或失去了这种能力。在主题控制下，IP-Adapter和Uni-ControlNet未能与参考对齐。总体而言，本文方法确保了文本一致性和在不同控制条件下的高质量生成。

上图3 (b)比较了不同方法在四个定制模型上生成图像的即插即用能力。最左列显示了来自LoRA微调的Flux.1 Dev模型的原始文本到图像（T2I）结果。ControlNet和OmniControl都牺牲了风格化，并遭受质量下降。相比之下，本文方法展示了在不失去可控性的情况下最小化风格化损失的能力，体现了我们方法的即插即用能力。

上图4展示了不同方法在多条件控制下的视觉比较。对于OpenPose和面部控制，本文方法在身份一致性和可控性方面表现优异。相比之下，其他方法在控制条件之间表现出冲突。虽然ControlNet和IP-Adapter的组合保持了可控性，但却损害了身份一致性。ControlNet+Redux和Uni-ControlNet未能同时保持身份一致性和可控性，这在主题-深度控制场景中也有所体现（右侧第三/第四行）。对于OpenPose-Canny和Depth-Canny组合，本文方法和Uni-ControlNet都生成了符合控制条件的图像。然而，Uni-ControlNet难以与文本输入对齐，并产生质量较低的图像。Multi-ControlNet未能同时满足两个条件。这些结果展示了我们方法在无缝整合多种条件方面的灵活性。

定量比较

上表1展示了在单个A100 GPU上进行20次采样步骤时各种算法的推理时间和相应的模型参数数量。在单条件设置下，本文完整模型实现了最佳性能，推理时间为16.3秒，比没有位置感知训练范式（PATP）和KV缓存的版本减少了58%。值得注意的是，本文方法在保持最小参数数量15M的同时实现了这一效率，明显低于ControlNet的3B参数。对于双条件任务，本文完整模型实现了18.3秒的推理时间，比没有PATP和KV缓存的版本快75%。这一性能与ControlNet+IPA（16.8秒）竞争，同时保持了更小的模型大小（30M参数相比于ControlNet+IPA的4B）。结果突出了我们提出的PATP和KV缓存机制在提高推理效率方面的有效性，而不影响模型的紧凑性。

消融研究

在本文消融研究中，我们分析了去除各个模块的影响。首先，将条件注入LoRA（CIL）替换为标准LoRA结构（W.O. CIL）允许单条件控制，但无法以零样本方式推广到多条件控制。对于位置感知训练范式（PATP），我们训练了一个没有PATP的模型，其中控制信号和噪声固定在512×512分辨率，同时保持其他训练设置不变。该模型在生成高分辨率（例如1024×1024）或非正方形纵横比（例如1024×768）图像时表现出伪影和质量下降。相比之下，基于PATP的训练有效地缓解了这些问题。对于因果注意，去除因果互注意（CMA）仍允许图像生成，这得益于注意力的自适应性质。然而，条件之间的冲突降低了控制精度，导致诸如在多控制场景中改变人体姿势和移动物体位置（例如月亮）等偏差。当所有模块一起使用时，本文方法实现了最高的可控性、生成质量以及对不同分辨率和纵横比的适应性。

结论

EasyControl，一个高效且灵活的统一条件引导扩散模型框架。本文框架利用了三个关键创新：(1) 一个轻量级的条件注入LoRA模块，能够无缝整合多样的条件信号而不改变核心模型的功能。(2) 一个位置感知训练范式，确保对各种分辨率和纵横比的适应性。(3) 一个新颖的因果注意机制结合KV缓存技术，显著提高了效率。这些组件共同解决了可控图像生成中的效率和灵活性挑战。EasyControl在广泛的视觉任务中实现了强大的可控性和高质量结果。广泛的实验展示了其处理复杂的多条件场景的能力，同时扩展到多样的分辨率和纵横比。本文框架为条件图像生成提供了一个强大且可适应的解决方案。

参考文献

[1] EasyControl: Adding Efficient and Flexible Control for Diffusion Transformer