RDGAN Retinex Decomposition Based Adversarial Learning for Low-Light Enhancement（论文阅读笔记）

最新推荐文章于 2022-09-07 15:10:37 发布

xingS1992

最新推荐文章于 2022-09-07 15:10:37 发布

阅读量1.3k

点赞数 3

CC 4.0 BY-SA版权

分类专栏：机器学习 python 文章标签：深度学习计算机视觉机器学习

本文链接：https://blog.youkuaiyun.com/shengxing_stu/article/details/110425168

python 同时被 2 个专栏收录

44 篇文章

订阅专栏

机器学习

24 篇文章

订阅专栏

本文是《RDGAN Retinex Decomposition Based Adversarial Learning for Low-Light Enhancement》论文阅读笔记。介绍了基于端到端学习的框架，包括分解网络和融合增强网络，还提出对抗增强损失函数。对比过去研究，指出其不足，阐述了论文主要贡献，该方法在颜色和细节恢复方面效果较好。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

RDGAN Retinex Decomposition Based Adversarial Learning for Low-Light Enhancement（论文阅读笔记）

最近学习了一篇论文《RDGAN Retinex Decomposition Based Adversarial Learning for Low-Light Enhancement》，记录一下

概括

在本文提出了一种基于端到端学习的框架，该框架首先对弱光图像进行分解，然后学习融合分解结果，得到高质量的增强结果。框架可以分为用于分解的RDNet (Retinex分解网络)和用于融合的FENet(融合增强网络)。针对这两个网络分别设计了具体的多项损耗。还提出了一种基于视神经分解的生成对抗网络损失算法，该算法是根据对增强图像和参考图像的反射率分量进行分解计算得到的。实验表明，该方法在颜色和细节恢复方面有较好的效果，优于其他最新的方法。

过去的研究

传统的单次微光图像增强方法包括基于直方图的方法、基于去雾的方法和基于视网膜的方法。基于直方图的方法[1]将直方图重新分布到均匀分布，并调整伽马曲线指数。基于去雾的方法[2]利用了弱光增强和去雾在反图像上的相似性。基于retinx的方法[3,4,5,6,7,8,9]通常将弱光图像分解为光照和反射分量，可以重构出更好的增强结果。简单的基于学习的w/o分解的微光增强方法[10,11]限制了增强结果。SID[12]只改进原始图像，不能作为普通sRGB图像的后处理。SICE[13]将低光图像分解为平滑和纹理组件，而不考虑噪声。RetinexNet[14]也学习了Retinex分解，但主要处理分解后的光照，仅使用BM3D[15]去噪分解后的反射率，增强效果不理想。

研究中的不足

大多数基于视神经网络的方法假设在增强过程中，反射率成分保持不变，而不考虑颜色失真和细节丢失。

本文的主要贡献

(1).提出了一种RDNet (Retinex分解网络)将输入的弱光图像分解为光照分量和反射率分量。RDNet训练的多项分解损失，包括四个损失:Liniloss, Lwtvloss, Lcomloss和Lerrloss。与传统方法不同，RDNet可以通过迭代次数直接预测分解结果。
(2).提出了融合增强网络(FENet，融合增强网络)，将输入的弱光图像与分解结果相结合，生成最终增强结果，优于其他只处理光照分量的方法。我们采用CRM (Camera Response Model)函数将分解的光照映射到一个粗略的良好曝光结果。
(3).还为FENet提出了一个多期对抗性损失。基于vggr的内容损失保证了感知质量，新的RDGAN损失是根据增强图像和参考图像的分解反射率分量计算的。RDGAN的丢失有助于颜色和细节的.恢复.

具体方法

分解网络

如图1所示，RDNet对于弱光和参考图像的Retinex分解采用了相同的模型权值，其分解结果为ini&inrand LbI& LbR。受[6]启发，在HSV域中用P的V通道初始化估计光照pvv，等于每个像素x上RGB通道的最大值:
在这里插入图片描述
为了融合狭窄的断口并填充轮廓上的间隙，进一步对初始PV应用了形态学上的闭合操作。具体来说，首先执行一个3x3的最大池操作，然后执行另一个最小池操作(逆向图像上的最大池)。有了最终的PV。
将RDNet中的反卷积层替换为最近邻上采样层和3x3卷积层，消除了棋盘效应[16]。考虑负系数，采用PReLU[17]作为激活。
这里贴上作者的源码，里面详细记录了RDNet和FENet的卷积、上采样、池化、全连接的具体操作：

def rdnet(img_v, img, hei, wid, reuse=False):
    input = tf.concat([img_v, img], -1)
    with tf.variable_scope('retinex', reuse=reuse):
        n = InputLayer(input, name='in')
        n11 = conv_k3(n, 32, name='l1/cv1')
        n12 = conv_k3(n11, 32, name='l1/cv2')

        n21 = conv_k3(n12, 64, s=2, name='l2/cv1')
        n22 = conv_k3(n21, 64, name='l2/cv2')

        n31 = conv_k3(n22, 128, s=2, name='l3/cv1')
        n32 = conv_k3(n31, 128, name='l3/cv2')
        n33 = conv_k3(n32, 128, name='l3/cv3')
        n34 = conv_k3(n33, 128, name='l3/cv4')

        n23 = upsample_and_concat(n34, n22, 64, hei // 2, wid // 2, name='l2/cv3')
        n24 = conv_k3(n23, 64, name='l2/cv4')

        n24.outputs = tf.image.resize_nearest_neighbor(n24.outputs, [hei, wid])
        n13 = conv_k3(n24, 32, name='l1/cv3')
        n14 = conv_k3(n13, 32, name='l1/cv4')
        n14 = ConcatLayer([n14, n13, n12, n11], -1)
        n15 = conv_k1(n14, 64, name='l1/cv5')

        n = conv_k3(n15, 4, act='none', name='out')
        img_i = tf.expand_dims(tf.sigmoid(n.outputs[:, :, :, 0]), -1)
        img_r = tf.sigmoid(n.outputs[:, :, :, 1:4])
    return img_i, img_r

# FENet
def fenet(crm, img, img_r, hei, wid, reuse=False):
    input = tf.concat([crm, img, img_r], -1)
    with tf.variable_scope('fusion', reuse=reuse):
        n = InputLayer(input, name='in')
        # 两次卷积操作
        n11 = conv_k3(n, 32, name='l1/cv1')
        n12 = conv_k3(n11, 32, name='l1/cv2')
        # 两次卷积操作
        n21 = conv_k3(n12, 64, s=2, name='l2/cv1')
        n22 = conv_k3(n21, 64, name='l2/cv2')
        # 四次卷积操作
        n31 = conv_k3(n22, 128, s=2, name='l3/cv1')
        n32 = conv_k3(n31, 128, name='l3/cv2')
        n33 = conv_k3(n32, 128, name='l3/cv3')
        n34 = conv_k3(n33, 128, name='l3/cv4')

        # 上采样和连接
        n23 = upsample_and_concat(n34, n22, 64, hei // 2, wid // 2, name='l2/cv3')

        # 两次卷积操作
        n24 = conv_k3(n23, 128, name='l2/cv4')
        n25 = conv_k3(n24, 64, name='l2/cv5')

        # 上采样和连接
        n13 = upsample_and_concat(n25, n12, 32, hei, wid, name='l1/cv3')

        # 两次卷积操作
        n14 = conv_k3(n13, 64, name='l1/cv4')
        n15 = conv_k3(n14, 64, name='l1/cv5')

        # 最后一次卷积操作
        n = conv_k3(n15, 3, act='none', name='out')
    return n.outputs


# 3x3 conv
def conv_k3(x, c, s=1, act='prelu', name=''):
    if s == 1:
        n = PadLayer(x, [[0, 0], [1, 1], [1, 1], [0, 0]], 'SYMMETRIC')
        n = Conv2d(n, c, padding='valid', W_init=w_init, name=name)
    else:
        assert s == 2  # stride = 1 or 2
        n = PadLayer(x, [[0, 0], [1, 0], [1, 0], [0, 0]], 'SYMMETRIC')
        n = Conv2d(n, c, (3, 3), (2, 2), padding='valid', W_init=w_init, name=name)

    if act == 'prelu':
        n = PReluLayer(n, a_init=a_init, name=name + '/pr')
    elif act == 'lrelu':
        n.outputs = tf.nn.leaky_relu(n.outputs)
    elif act == 'relu':
        n.outputs = tf.nn.relu(n.outputs)
    return n


# 1x1 conv
def conv_k1(x, c, act='none', name=''):
    n = Conv2d(x, c, (1, 1), W_init=w_init, name=name)

    if act == 'prelu':
        n = PReluLayer(n, a_init=a_init, name=name + '/pr')
    elif act == 'lrelu':
        n.outputs = tf.nn.leaky_relu(n.outputs)
    elif act == 'relu':
        n.outputs = tf.nn.relu(n.outputs)
    return n


# NN + 3x3 conv + concat
def upsample_and_concat(x1, x2, c, hei, wid, act='prelu', name=''):
    x1.outputs = tf.image.resize_nearest_neighbor(x1.outputs, [hei, wid])
    n = conv_k3(x1, c, act=act, name=name)
    n = ConcatLayer([n, x2], -1)
    return n

融合增强网络

为了简化融合过程，使用[8]中的CRM (Camera Response Model)函数将低光图像分解后的照度映射为一个粗略的良好曝光结果。
由于CRM功能忽略了反射成分，因此还有进一步增强的空间。如图1所示，FENet学会将输入的微光图像、分解的基于光照的CRM[8]结果和分解的反射率相结合，得到最终的增强结果。

对抗增强损失函数

在FENet的预训练过程中，只使用基于VGGbased[18]内容损失，另一方面，对于交替训练过程，提出了一种新的RDGAN损失，它是对增强图像和参考图像分解后的反射率分量计算的对抗式损失。

# weighted TV loss for I
def wtv_loss(img_v, img_i, size):
    dy = img_i[:, 1:, :, :] - img_i[:, :size - 1, :, :]
    vdy = img_v[:, 1:, :, :] - img_v[:, :size - 1, :, :]
    vdy = tf.layers.average_pooling2d(vdy, pool_size=(3, 1), strides=1, padding='SAME') * 3

    dx = img_i[:, :, 1:, :] - img_i[:, :, :size - 1, :]
    vdx = img_v[:, :, 1:, :] - img_v[:, :, :size - 1, :]
    vdx = tf.layers.average_pooling2d(vdx, pool_size=(1, 3), strides=1, padding='SAME') * 3

    wy = tf.divide(tf.square(dy), tf.abs(vdy) * tf.abs(dy) + 1e-3)
    wx = tf.divide(tf.square(dx), tf.abs(vdx) * tf.abs(dx) + 1e-3)
    return tf.reduce_mean(wy) + tf.reduce_mean(wx)