Deep Guided Learning for Fast Multi-ExposureImage Fusion

Abstract

我们提出了一种快速多重曝光图像融合（MEF）方法，即 MEF-Net，用于任意空间分辨率和曝光次数的静态图像序列。 我们首先将输入序列的低分辨率版本提供给全卷积网络以进行权重图预测。 然后，我们使用引导滤波器联合对权重图进行上采样。 最终图像通过加权融合计算。 与传统的 MEF 方法不同，MEF-Net 通过在全分辨率训练序列数据库上优化感知校准 MEF 结构相似性 (MEF-SSIM) 索引来进行端到端训练。 在一组独立的测试序列中，我们发现优化后的 MEF-Net 在大多数序列的视觉质量上实现了一致的改进，并且运行速度比最先进的方法快 10 到 1000 倍。 该代码已在 https://github.com/makedede/MEFNet 上公开发布。

I. INTRODUCTION

多重曝光图像融合 (MEF) 为高动态范围 (HDR) 成像提供了一种经济高效的解决方案 [1]。 它采用不同曝光级别的图像序列作为输入，并生成高质量和低动态范围的图像，准备显示 [2]。 MEF 的研究已经产生了许多方法 [2]-[8]，它们生成具有忠实的细节保留和生动的色彩外观的融合图像。 这主要是通过加权求和框架来完成的。

其中 表示 Hadamard 产品。 Wk和Xk分别表示第k个权重图和对应的曝光图像，Y是融合图像，K是输入序列中的曝光次数。 该框架值得注意的例外是基于优化的方法[6]、[8]，其中融合过程由感知图像质量度量[9]监督。

尽管取得了成功，但商业相机和移动设备捕获的高分辨率曝光序列对现有的 MEF 方法提出了巨大的挑战，这可能需要大量的计算资源，并且需要几秒钟（甚至几分钟）才能生成融合结果。 随着接触次数的增加，情况变得更加糟糕。 通过代码优化实现算法加速是可能的[10]、[11]，但它可能无法推广到不同的 MEF 方法。 加速 MEF 方法 [12]-[14] 的另一种通用方法是对输入序列进行下采样，以低分辨率执行 MEF 运算符，并对融合图像进行上采样。 这种方法的一个缺点是 MEF 方法永远看不到高分辨率序列，因此无法完全再现精细细节，限制了融合图像的视觉清晰度。

我们的目标是开发一种适用于静态场景的 MEF 方法，具有三个理想的属性：

• 灵活性。 它必须接受任意空间分辨率和曝光次数的输入序列。

• 速度。 它必须速度快，能够以高分辨率促进实时移动应用程序。

• 质量。 它必须在广泛的内容和亮度变化范围内生成高质量的融合图像。

为了实现灵活性，我们利用全卷积网络[15]，它接受任意大小的输入并产生相应大小的输出（称为密集预测）。 该网络由不同的曝光图像共享，使其能够处理任意数量的曝光。 为了提高速度，我们遵循下采样-执行上采样方案，并向网络提供输入序列的低分辨率版本。 网络不是像[6]、[16]、[17]那样生成融合图像，而是学习生成等式1中的低分辨率权重图。 (1) 并使用引导滤波器 [18] 联合对它们进行上采样以进行最终的加权融合。 通过这样做，我们利用权重图的平滑特性并利用输入序列作为指导[19]。 由于高分辨率序列中存在丰富的高频信息并且缺乏适当的指导，直接对融合图像进行上采样是很困难的。 为了实现质量，我们将可微分引导滤波器与前面的网络[19]集成，并通过大量训练针对受试者校准的 MEF 结构相似性（MEF-SSIM）指数 [9] 端到端优化整个模型 序列[6]、[20]-[23]。 尽管我们的大部分推理和学习都是在低分辨率下进行的，但目标函数 MEF-SSIM [9] 是在全分辨率下测量的，这鼓励引导滤波器与卷积网络配合，生成高质量的融合图像。 大量实验表明，与大多数序列的最先进的 MEF 方法相比，所得到的 MEF-Net 在视觉质量方面取得了一致的改进。 更重要的是，MEF-Net 的运行速度快了 10 到 1000 倍，并且有望近似和加速计算密集型的 MEF 方法。

II. RELATED WORK

在本节中，我们将简要概述现有的 MEF 方法和快速图像处理的一般方法，重点介绍与我们的工作密切相关的先前方法。

A. Existing MEF Algorithms

Burt和Adelson于1983年提出的拉普拉斯金字塔[24]对图像融合研究[25]产生了持久的影响。 与高斯[2]、[3]或边缘保留[4]、[7]滤波器相结合，拉普拉斯金字塔提供了一个方便的多分辨率框架来细化权重图Wk，它携带了Xk的感知重要信息。 默滕斯等人。 [2]采用了该框架并提出了第一个像素级MEF方法，该方法在视觉质量和计算复杂度之间保持了良好的平衡。 从那时起，大量的像素级MEF方法[26]被开发出来，主要是为了提高视觉质量，但代价是增加计算复杂度。 与逐像素 MEF 相比，逐补丁方法通常会产生更平滑的 Wk，需要更少的后处理，但承担更重的计算负担。 Goshtasby [27] 提出了第一个补丁式 MEF 方法。 Ma 和 Wang [28] 扩展了 [27] 的思想，并开发了 MEF 的结构补丁分解。 影响 Wk 的典型感知因素包括梯度 [29]、对比度 [2]、色彩饱和度 [2]、[7]、熵 [27]、结构 [28]、曝光度 [2]、[3] 和 显着性[4]。

B. Fast Image Processing

随着移动设备成为人们拍照的主要相机，对于照片编辑、面部处理和增强现实等新型移动应用程序的图像处理操作员的加速需求不断增长。 一个很好的例子是双边滤波[30]-[32]，由于边缘保留图像处理的普遍存在，它受益于多年的代码优化。 然而，这种加速技巧可能无法推广到其他操作员。 一种对移动硬件友好的系统级加速解决方案是将图像发送到云服务器，在云端执行图像处理算子，并将处理后的图像发送回[33]。 由于高分辨率图像的码率较大，这可能会带来明显的延迟，尤其是在网络状况不稳定的情况下。 下采样-执行-上采样方案是算法加速的另一种通用方法，它有两个限制。 首先，底层运算符在低分辨率下运行可能仍然很慢。 其次，上采样技术很难恢复高分辨率图像中的高频信息，特别是当它们具有复杂结构时。 最近，由于有效的前馈推理，卷积网络[14]、[19]已被用来近似和加速流行的图像处理算子，包括边缘保留滤波、细节处理、非局部去雾和风格转移。

C. Closely Related Work

我们的工作与之前的几种方法密切相关。 李等人。 [4]首先将引导过滤引入MEF。 权重图 Wk 是基于像素显着性和空间一致性测量构建的，并通过引导滤波器进行细化。 寇等人。 [7] 在 [2] 的基础上建立了他们的工作，并用梯度域引导滤波取代了高斯平滑。 上述两种方法的三个组成部分——权重图构建、引导过滤和加权融合——是分别优化的（通常通过手动调整）。 我们的方法与他们不同，它采用端到端解决方案，其中三个组件以数据驱动的方式联合优化。 Ma 等人没有为 MEF 预先定义计算图。 [8]将其表述为优化问题

由于MEF-SSIM[9]的非凸性和优化问题的高维性，封闭式解决方案很困难。 因此，采用基于梯度的迭代求解器[8]，其计算成本较高。 另一项与我们密切相关的工作来自 Prabhakar 等人。 [6]，他训练了一个前馈卷积网络来解决（2）中的优化问题。 该方法在极端情况下效果相当好，但没有达到我们寻求的灵活性、速度和质量。 我们将证明所提出的 MEF-Net 实现了更高的质量，同时速度更快、更灵活。

陈等人。 [14]研究了许多卷积网络架构在加速图像处理算子时的近似精度、速度和紧凑性。 他们发现，以扩张卷积为特征的多尺度上下文聚合网络（CAN）[34]满足这三个标准，并且显着优于先前的方法[13]。 我们将采用 CAN 作为我们的默认网络架构。 吴等人。 [19]将引导滤波器视为一组空间变化的可微变换，并将其与卷积网络集成以进行端到端训练。 尽管他们的方法[19]在一些输出相对平滑的应用中实现了卓越的性能（例如，风格迁移[35]），但它无法准确地近似处理高频图像内容的算子（例如，多尺度色调处理[36]） ）。 我们的方法通过在 Wk 上应用引导滤波器来规避这个问题，它比 Y 更平滑且更容易上采样。

III. MEF-NET

我们描述了 MEF-Net，一种灵活、快速且高质量的 MEF 方法。 MEF-Net由双线性下采样器、CAN、引导滤波器和加权融合模块组成。 该架构如图 1 所示。我们首先对输入序列 {Xk} 进行下采样，并向 CAN 提供低分辨率版本 {Xl k} 来预测低分辨率权重图 {Wl k}。取 {Wl k}，{ Xl k} 和 {Xk} 作为输入，我们使用引导滤波器获得高分辨率权重图 {Wk}，该操作在计算机视觉中也称为联合上采样[37]。 最后，我们使用等式计算融合图像 Y。 (1). MEF-Net 可以通过高分辨率评估的目标函数 MEF-SSIM [9] 进行端到端训练。

A. CAN for Low-Resolution Weight Map Prediction

MEF-Net的核心模块是一个卷积网络，它将低分辨率输入序列{Xl k}转换为相应的权重映射{Wl k}。 网络必须允许任意空间尺寸和曝光数量的{Xl k}，并产生相应尺寸和数量的{Wl k}。 为了实现这一点，我们利用全卷积网络来处理所有曝光（即不同曝光的图像共享相同的权重生成网络），这可以通过沿批量维度分配 {Xl k} 来有效实现。 从许多替代网络[15]、[38]中，我们选择了Chen等人提倡的CAN[34]。 [14] 和吴等人。 [19]用于近似图像处理算子。 CAN 的主要优势是其较大的感受野，且不牺牲空间分辨率。 它逐渐聚合更深层次的上下文信息，并完成全局图像统计的计算，以实现更好的图像建模。 表 I 指定了我们的 CAN 配置。 它有七个卷积层，其响应具有与输入相同的分辨率。 与[14]类似，我们在卷积后立即采用自适应归一化

其中 λn,λ n ∈ R 是可学习的标量权重，Z 表示中间表示，IN(·) 代表实例归一化算子[39]。 我们在这里选择不使用批量归一化[40]，因为批量大小（即曝光次数）通常很小，这可能会由于批量统计估计不准确而在训练过程中引入问题。 此外，为了更好地保留 Xl k [20] 的局部结构信息，我们采用泄漏修正线性单元（LReLU）作为逐点非线性

B. Guided Filter for High-Resolution Weight Map Upsampling

算法1总结了MEF-Net中用于联合上采样的引导滤波器，其中fmean和f↑分别表示盒式滤波和双线性上采样。 通过将引导滤波器解释为一组空间变化的可微变换[19]，我们将其与前面的 CAN 集成，并以全分辨率端到端优化 MEF-Net。 我们可以将引导滤波器作为后处理步骤而无需任何训练，但这会损害融合性能，这一点将在第 IV-B 节中清楚地体现出来。

为了在训练期间稳定梯度并获得一致的结果，我们取 {Wk} 的绝对值，然后进行归一化，以便它们在每个空间位置的曝光中总和为 1

C. MEF-SSIM as Objective Function

在本小节中，我们详细介绍了 MEF-SSIM 指数 [9] 作为 MEF-Net 的目标函数。 MEF 的其他感知质量指标（例如 [41]、[42]）也可以达到此目的。 具体来说，MEF-SSIM 将图像块 xk 分解为三个概念上独立的组件

MEF-SSIM [9] 的普通版本不包括强度比较，已被 Prabhakar 等人采用。[6] 推动 MEF 卷积网络的学习。 在我们的实验中，我们发现在没有强度信息的情况下优化 MEF-SSIM 是不稳定的，导致融合图像的外观相对苍白（见图 6）。 MEF-SSIM [8] 的改进版本增加了方程（1）中的强度比较。 (15) 并直接使用颜色序列。 然而，在某些情况下它可能会产生过饱和的颜色[8]。 为了获得更保守且几乎没有伪影的融合图像，我们选择按照[6]中的建议单独处理色度分量。 具体来说，我们使用 Y'CbCr 格式，并仅在 {Xk} 和 Y 的亮度分量上评估 MEF-SSIM。换句话说，MEF-Net 中的 CAN 经过优化以融合亮度分量。 对于 Cb 色度分量，我们采用[6]中建议的简单加权求和

D. Training

我们为 MEF-Net 收集了一个大规模数据集。 最初，我们主要从五个来源收集了 1, 000 多个曝光序列 [6]、[20]–[23]。 我们首先消除包含可见物体运动的序列。 对于相机运动，我们保留那些已通过现有图像配准算法成功对齐的序列[44]。 放映后，总共留下了690个静态序列，涵盖了大量的HDR内容，包括室内和室外、人物和静物、白天和晚上的场景。 一些代表性的序列如图3所示。空间分辨率范围从0.2到20兆像素，而曝光次数在3到9之间。 我们在 600 个序列上训练 MEF-Net，剩下的 90 个用于测试。

在训练过程中，我们仅在最精细的规模上应用 MEF-SSIM，以降低 GPU 内存成本。 MEF-SSIM的参数继承自[8]、[9]。 我们将曝光序列的大小分别调整为 128s 和 512s，作为 MEF-Net 的低分辨率和高分辨率输入，其中 128s 意味着短尺寸调整为 128，同时保持宽高比。 LReLU的泄漏参数λr固定为0.2。 引导滤波器的半径r和正则化参数λa分别设置为1和10−4。 λa 是 MEFNet 中的一个关键参数，这将在第 IV-B 节中清楚地说明。 训练使用 Adam 求解器 [45]，学习率为 10−4。 Adam 中的其他参数均采用默认设置。 批量大小等于当前序列中的曝光数量。 当达到最大 epoch 数 100 时，学习停止。 我们尝试在大于 512 秒的不同高分辨率序列上进一步训练 MEF-Net [19]，但这并没有产生明显的改进。 最后，我们在测试期间以全分辨率评估 MEF-Net。

IV. EXPERIMENTS

在本节中，我们首先在视觉质量和计算复杂度方面将 MEF-Net 与经典和最新的 MEF 方法进行比较。 然后我们进行了一系列的消融实验来确定 MEF-Net 的核心组件。 最后，我们将 MEF-Net 视为通用 MEF 近似器，并用它来加速现有的 MEF 方法。

A. Main Results

1) Qualitative Comparison:

我们将 MEF-Net 与之前的六种 MEF 方法进行比较，包括 Mertens09 [2]、Li13 [4]、SPD-MEF [5]、GGIF [7]、DeepFuse [6] 和 MEF-Opt [8]。 Mertens09 [2] 是 MEF 的主要基线。 Li13[4]将引导滤波[18]引入MEF，而GGIF[7]在梯度域中应用引导滤波，并在最近的主观实验中获得了最佳性能[20]。 SPD-MEF是一种受MEF-SSIM启发的非迭代方法，在同一主观研究中排名第二[20]。 MEF-Opt [8] 是一种基于梯度的迭代方法，在所有图像的空间中优化 MEF-SSIM [9]。 DeepFuse [6] 是一种密切相关的方法，为 MEF 训练卷积网络。 原则上，MEF-Opt可以被认为是MEF-SSIM方面所有MEF方法的上限。 融合图像是由原作者使用默认设置的实现生成的。 由于 DeepFuse 仅进行两次曝光，因此我们尝试了几种曝光不足和曝光过度的组合，并选择实现最佳 MEF-SSIM 的融合图像进行比较。

图 4 将 Mertens09 [2] 和 SPD-MEF [5] 与源序列“Studio”上的 MEF-Net 进行了比较。 可以看出，由于场景的极端动态范围和权重图的过度高斯平滑，Mertens09 没有恢复灯的细节。 此外，外部地面显得过度暴露。 SPD-MEF 在室内场景的细节和色彩保留方面做得很好，但在窗外引入了恼人的色彩和光晕伪影。 我们认为，扭曲的出现是因为 SPD-MEF 更喜欢强烈甚至过度饱和的颜色，其权重图无法在强边缘附近的曝光之间实现平滑过渡。 相比之下，MEF-Net 可产生更自然的外观，并具有忠实的细节和色彩再现。

图 5 将 Li13 [4] 和 GGIF [7] 与 MEF-Net 在源序列“Lake Forest”上进行了比较。 通过使用高斯滤波将输入序列分解为基础层和细节层，Li13 仅专注于精细细节增强，无法捕获大范围的亮度变化。 因此，出现了明显的光晕伪影。 此外，融合图像的全局强度突然变化，导致外观不自然且不舒服。 GGIF 继承了 Mertens09 [2] 的多尺度拉普拉斯分解，将光晕伪影减轻到了刚刚可察觉的水平，但同时降低了全局对比度。 融合后的图像看起来相对苍白且细节较少。 与 GGIF 相比，MEF-Net 更好地保留了全局对比度，并且融合图像的整体外观更加自然和吸引人。

图 6 在源序列“Archway”上将 DeepFuse [6] 和 MEF-Opt [8] 与 MEF-Net 进行了比较。 DeepFuse 的融合性能很大程度上取决于输入图像对的质量。 如果曝光不足和过度曝光的图像不完全互补，DeepFuse 可能会生成感知质量低于正常曝光照片的融合图像。 仅两次曝光，DeepFuse 很难确定场景的光照条件。 优化期间 MEF-SSIM 缺失的强度分量使情况变得更糟。 因此，我们观察到两盏灯周围的颜色不自然，墙壁和地板上的细节也减少了。 通过在所有图像的空间中进行操作，MEF-Opt 比 MEF-Net 具有更大的自由度来生成具有更精细细节的融合图像，这是由更高的 MEF-SSIM 值支持的。 凭借合理的网络架构，MEF-Net 与 MEF-Opt 的结果非常接近。

2) Quantitative Comparison:

我们在表II中列出了MEF-SSIM[9]的定量比较结果。 MEF-Opt [8] 获得最佳性能并不奇怪，因为它在所有图像的空间中优化了 MEF-SSIM。 在其余方法中，MEF-Net 最接近这个上限，这表明训练非常有效，并且 MEF-Net 可以很好地泛化到新颖的内容。 尽管与 MEF-SSIM 优化的精神相同，但 DeepFuse [6] 由于对输入序列的极其严格的约束，表现最差。 我们还采用了另一种专门针对 MEF 的主题校准质量模型，即 MEF-VIF [42]，来量化相同 90 个测试序列的融合性能。 从表 II 中，我们看到 MEF-Net 是性能最好的方法之一。 所提出的 MEF-Net 非常灵活，可以经过训练直接优化 MEF-VIF。

我们仔细研究了 MEF-Net 的跨分辨率泛化能力。 具体来说，如果可能的话，我们将 90 个测试序列下采样到 7 个分辨率，范围从 512 秒到 2048 秒，并在图 7 中报告平均 MEF-SSIM 分数。尽管 MEF-Net 是在 512 秒的分辨率上进行训练的，但它概括了 在各种未见的分辨率上表现出色，MEF-SSIM 略有下降。 同时，我们观察到随着分辨率的提高，针对 MEF-SSIM 优化的 MEF-Opt [8] 呈稳定上升趋势。 出现这种情况的原因可能是，对于包括 MEF-Opt 在内的大多数 MEF 算法，融合平坦区域比融合结构化区域更容易； 当空间分辨率增加时，平坦区域比结构化区域增长得更快（考虑不同尺寸的阶梯边缘图像）。 除了 Mertens09 [2] 不是尺度不变的之外，其他 MEF 方法的性能同样出色。 Mertens09 采用拉普拉斯金字塔 [24] 来避免融合过程中出现不需要的伪影。 拉普拉斯金字塔的标准实现使用 5×5 低通滤波器，它可能无法在下采样（两倍）之前消除高频信息，从而导致跨尺度可能出现混叠伪影。 因此，当图像分辨率与 2 的乘数相关时，我们可能仅观察到尺度不变性，这通过图 7 中的 512s、1024s 和 2048s 计算的大致相同的 MEF-SSIM 分数进行了验证。通过用引导替换高斯滤波 通过过滤，GGIF [7] 在同一框架内实现了所需的尺度不变性。

3) Computational Complexity and Running Time:

我们在浮点运算数量方面对 MEF 方法的计算复杂度进行了比较。 我们假设输入通道的数量为 K，每个通道包含 M 个像素，用于计算局部统计数据的窗口大小为 N2。 所有竞争的 MEF 算法的复杂度都是 O(KMN2)，除了 MEF-Opt [8]，它的复杂度是 O(IKMN2)，其中 I 是迭代次数。 理想情况下，跨通道维度的计算可以并行化，并且 K 的值对运行时间的影响应该很小（假设有足够的代码优化）。 由于 N2 M，空间分辨率 M 是主导项。 MEF-Net 具有最低的计算复杂度，因为它将大部分计算限制在固定的低分辨率下，而竞争的 MEF 算法需要以全分辨率执行所有计算。

我们将 MEF-Net 与现有 MEF 方法在不同空间分辨率或不同曝光次数的输入序列上的运行时间进行比较。 测试平台是一台配备 Intel i7-6900K 3.2GHz CPU 和 Nvidia Titan X GPU 的计算机。 Mertens09 [2]、Li13 [4]、SPD-MEF [5] 和 GGIF [7] 利用 CPU，而 DeepFuse [6] 和 MEFOpt [8] 利用 GPU。 由于严格的输入限制，我们不报告 DeepFuse 在不同曝光次数序列上的运行时间。 为了便于绘图，我们将 MEF-Opt 的最大迭代次数减少到 100。 结果如图8所示。在GPU上，MEF-Net处理分辨率从512秒到2048秒、曝光次数从3到9的序列的时间不到10毫秒，比DeepFuse快10倍和1000倍 和SPD-MEF，分别。 更重要的是，尽管空间分辨率和曝光次数不断增加，MEF-Net 的运行时间大致恒定。 在 CPU 上，MEF-Net 仍然明显快于大多数 MEF 方法（GPU 模式 DeepFuse 除外）。

总之，我们凭经验证明，所提出的 MEF-Net 以 CAN 和引导过滤为特征，经过端到端训练，在 MEF 中实现了三个理想的特性：灵活性、速度和质量。

B. Ablation Experiments

我们进行了全面的消融实验，以找出 MEF-Net 中每个组件的贡献。 我们首先仅在低分辨率序列上训练 MEF-Net。 训练后，采用引导滤波器作为后处理步骤，对低分辨率权重图进行联合上采样以进行最终融合。 然后，我们用简单的双线性上采样器替换引导滤波器来训练 MEF-Net。 MEF-SSIM [9] 结果列于表 III，我们看到将上采样技术与前面的 CAN 集成进行端到端训练可以显着增强 MEF-SSIM。 这验证了端到端训练的能力，其中 MEF-Net 直接由高分辨率输入序列监督。 通过双线性上采样的引导滤波可以获得额外的性能增益。 我们还在图 9 中提供了视觉演示，发现作为后处理的引导过滤表现出窗口外的过度曝光，而经过端到端训练的双线性上采样由于权重图过于粗糙而显示出黑色条带伪影。 经过端到端联合上采样训练的引导过滤可实现最佳视觉质量，是 MEF-Net 的关键组成部分。

接下来我们评估 CAN 的输入分辨率、深度和宽度对 MEF-Net 性能的影响。 深度和宽度分别表示卷积层的数量和每个中间层中特征图的数量。 CAN 越浅意味着感受野越小。 结果列于表四，从中我们得到了一些有趣的观察结果。 首先，MEF-SSIM 正如预期的那样随着输入分辨率、深度和宽度的增加而增加。 其次，通过将输入分辨率从 128 秒更改为 256 秒，我们观察到 MEF-SSIM 的边际改进为 0.003。 第三，MEF-Net 通过相当浅且紧凑的架构实现了令人满意的性能（例如，每层 16 个特征图或深度为 5）

我们还评估了引导滤波器中正则化参数 λa 和半径 r 的作用。 λa 控制 Ak 的平滑度，这在式（1）中很明显。 （6）。 r 还以不太直接的方式影响 Ak 的平滑度。 大的 λa（或 r）会生成平滑的 Wˆ k，并且可能不擅长保留精细细节，导致表 V 中的 MEF-SSIM 下降。小 λa 会产生相对嘈杂的 Wˆ k，并可能引入点伪影，如下所示 如图 10 所示。我们的默认设置实现了最佳性能

C. MEF-Net as a Universal MEF Approximator

在本小节中，我们利用 MEF-Net 的快速速度，并将其用作通用逼近器来加速现有的 MEF 方法。 具体来说，我们首先将目标 MEF 方法应用于我们的数据集。 生成的融合图像被视为基本事实。 然后，我们在包含曝光序列和相应融合图像的输入/输出对上训练 MEF-Net。 训练过程与第 III-D 节相同，只是我们在 RGB 空间中优化了感知图像质量度量 SSIM [43]。 我们还尝试了[14]、[19]中建议的均方误差（MSE），但获得的近似精度较低。

图11显示了MEF-Net在源序列“Stone house”上近似SPD-MEF [5]和GGIF [7]的视觉结果。 尽管两种 MEF 方法产生不同的整体外观，但 MEF-Net 能够紧密匹配它们。 在 90 个测试序列上，SPD-MEF 和 GGIF 的 SSIM 逼近精度分别为 0.961 和 0.976，证明了 MEF-Net 作为通用 MEF 逼近器的前景。 在分辨率为 1024 秒的序列上，我们分别将 SPD-MEF 和 GGIF 加速超过 1000 倍和 100 倍。

V. CONCLUSION AND DISCUSSION

我们引入了 MEF-Net，一种基于深度引导学习的快速 MEF 方法。 MEF-Net 的核心思想是使用 CAN 预测低分辨率权重图，并使用引导滤波器对其进行联合上采样，以实现最终的加权融合。 MEF-Net 的高速是通过将主要计算限制在固定的低分辨率并跨曝光并行计算来实现的。 融合图像的视觉改进是通过使用全分辨率测量的 MEFSSIM 进行端到端训练来实现的。 此外，我们还展示了 MEF-Net 作为通用 MEF 近似器的前景，可加速现有和未来的 MEF 方法。

当前的 MEF-Net 仅适用于静态场景。 如何将其扩展到动态场景是一个有待探索的有趣且具有挑战性的问题。 这里的主要障碍是缺乏动态场景的感知图像质量指标[46]或用于监督的基本事实。 Kalantari 和 Ramamoorthi [16] 投入了大量精力来捕捉同一场景的静态和动态曝光范围，并将静态序列视为地面事实的一种形式。 蔡等人。 [20]利用 13 种现有的 MEF 和 HDR 去鬼影方法来生成一组候选方法，并手动选择最好的方法作为基本事实。 这两个过程既昂贵又耗时，限制了收集的序列数量。 此外，我们希望针对动态场景使用更灵活、更快速的 MEF 方法。

code

e2emef.py

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
from guided_filter_pytorch.guided_filter import FastGuidedFilter, GuidedFilter


EPS = 1e-8


def weights_init_identity(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1:
        init.xavier_uniform_(m.weight.data)
    elif classname.find('InstanceNorm2d') != -1:
        init.constant_(m.weight.data, 1.0)
        init.constant_(m.bias.data,   0.0)


class AdaptiveNorm(nn.Module):
    def __init__(self, n):
        super(AdaptiveNorm, self).__init__()

        self.w_0 = nn.Parameter(torch.Tensor([1.0]))
        self.w_1 = nn.Parameter(torch.Tensor([0.0]))

        self.in_norm = nn.InstanceNorm2d(n, affine=True, track_running_stats=False)

    def forward(self, x):
        return self.w_0 * x + self.w_1 * self.in_norm(x)


def build_lr_net(norm=AdaptiveNorm, layer=5, width=24):#lr = low resolution
    layers = [
        nn.Conv2d(1, width, kernel_size=3, stride=1, padding=1, dilation=1, bias=False),
        norm(width),
        nn.LeakyReLU(0.2, inplace=True),
    ]

    for l in range(1, layer):
        layers += [nn.Conv2d(width,  width, kernel_size=3, stride=1, padding=2**l,  dilation=2**l,  bias=False),
                   norm(width),
                   nn.LeakyReLU(0.2, inplace=True)]

    layers += [
        nn.Conv2d(width, width, kernel_size=3, stride=1, padding=1, dilation=1, bias=False),
        norm(width),
        nn.LeakyReLU(0.2, inplace=True),
        nn.Conv2d(width,  1, kernel_size=1, stride=1, padding=0, dilation=1)
    ]

    net = nn.Sequential(*layers)
    net.apply(weights_init_identity)

    return net


class E2EMEF(nn.Module):
    # end-to-end mef model
    def __init__(self, radius=1, eps=1e-4, is_guided=True):
        super(E2EMEF, self).__init__()
        self.lr = build_lr_net()
        self.is_guided = is_guided
        if is_guided:
            self.gf = FastGuidedFilter(radius, eps)

    def forward(self, x_lr, x_hr):
        w_lr = self.lr(x_lr)

        if self.is_guided:
            w_hr = self.gf(x_lr, w_lr, x_hr)
        else:
            w_hr = F.upsample(w_lr, x_hr.size()[2:], mode='bilinear')

        w_hr = torch.abs(w_hr)
        w_hr = (w_hr + EPS) / torch.sum((w_hr + EPS), dim=0)

        o_hr = torch.sum(w_hr * x_hr, dim=0, keepdim=True).clamp(0, 1)

        return o_hr, w_hr

    def init_lr(self, path):
        self.lr.load_state_dict(torch.load(path))

guided_filter.py

from torch import nn
from torch.nn import functional as F
from torch.autograd import Variable

from .box_filter import BoxFilter

class FastGuidedFilter(nn.Module):
    def __init__(self, r, eps=1e-8):
        super(FastGuidedFilter, self).__init__()

        self.r = r
        self.eps = eps
        self.boxfilter = BoxFilter(r)


    def forward(self, lr_x, lr_y, hr_x):
        n_lrx, c_lrx, h_lrx, w_lrx = lr_x.size()
        n_lry, c_lry, h_lry, w_lry = lr_y.size()
        n_hrx, c_hrx, h_hrx, w_hrx = hr_x.size()

        assert n_lrx == n_lry and n_lry == n_hrx
        assert c_lrx == c_hrx and (c_lrx == 1 or c_lrx == c_lry)
        assert h_lrx == h_lry and w_lrx == w_lry
        assert h_lrx > 2*self.r+1 and w_lrx > 2*self.r+1

        ## N
        N = self.boxfilter(Variable(lr_x.data.new().resize_((1, 1, h_lrx, w_lrx)).fill_(1.0)))

        ## mean_x
        mean_x = self.boxfilter(lr_x) / N
        ## mean_y
        mean_y = self.boxfilter(lr_y) / N
        ## cov_xy
        cov_xy = self.boxfilter(lr_x * lr_y) / N - mean_x * mean_y
        ## var_x
        var_x = self.boxfilter(lr_x * lr_x) / N - mean_x * mean_x

        ## A
        A = cov_xy / (var_x + self.eps)
        ## b
        b = mean_y - A * mean_x

        ## mean_A; mean_b
        mean_A = F.upsample(A, (h_hrx, w_hrx), mode='bilinear')
        mean_b = F.upsample(b, (h_hrx, w_hrx), mode='bilinear')

        return mean_A*hr_x+mean_b


class GuidedFilter(nn.Module):
    def __init__(self, r, eps=1e-8):
        super(GuidedFilter, self).__init__()

        self.r = r
        self.eps = eps
        self.boxfilter = BoxFilter(r)


    def forward(self, x, y):
        n_x, c_x, h_x, w_x = x.size()
        n_y, c_y, h_y, w_y = y.size()

        assert n_x == n_y
        assert c_x == 1 or c_x == c_y
        assert h_x == h_y and w_x == w_y
        assert h_x > 2 * self.r + 1 and w_x > 2 * self.r + 1

        # N
        N = self.boxfilter(Variable(x.data.new().resize_((1, 1, h_x, w_x)).fill_(1.0)))

        # mean_x
        mean_x = self.boxfilter(x) / N
        # mean_y
        mean_y = self.boxfilter(y) / N
        # cov_xy
        cov_xy = self.boxfilter(x * y) / N - mean_x * mean_y
        # var_x
        var_x = self.boxfilter(x * x) / N - mean_x * mean_x

        # A
        A = cov_xy / (var_x + self.eps)
        # b
        b = mean_y - A * mean_x

        # mean_A; mean_b
        mean_A = self.boxfilter(A) / N
        mean_b = self.boxfilter(b) / N

        return mean_A * x + mean_b