微光图像增强的零参考深度曲线估计
⽂章⽬录
思路总结
亮点：不需要成对训练数据；仅训练每个像素的增强⾼阶⽅程参数；⽹络损失函数考虑了图像空间⼀致性，曝光，颜⾊⼀致性和亮度
在这篇论⽂中，我们呈现了⼀种新的深度学习⽅法，零参考深度曲线估计，来进⾏微光图像增强。它可以在各种各样的灯光条件包括不均匀和弱光情况进⾏处理。不同于执⾏图像到图像的映射，我们把任务重新设定为⼀个特定图像曲线估计问题。特别地，提出的这种⽅法把⼀个⼈微光图像作为输⼊，并把产⽣的⾼阶曲线作为它的输出。然后这些曲线被⽤作对输⼊的变化范围的像素级调整，从⽽获得⼀个增强的图像。曲线估计是精⼼制定的以便于它保持图像增强的范围并保留相邻像素的对⽐度。重要的是，它是可微的，因此，我们可以通过⼀个深度卷积神经⽹络来了解曲线的可调参数。所提出的⽹络是轻量级的，它可以迭代地应⽤于近似⾼阶曲线，以获得更稳健和更精确的动态范围调整。near
⼀个特别的优势是我们的深度学习给予的⽅法是零参考。与现有的基于CNN和GAN的⽅法⼀样，它在训练过程中不需要任何成对的或者甚⾄不成对的数据。这是通过⼀组特别设计的⾮参考损失函数实现的，
这些函数包括空间⼀致性损失、曝光控制损失、颜⾊恒定性损失和光照平滑度损失，所有这些都考虑了光增强的多因素。我们发现，即使使⽤零参考训练，zero-DCE仍然可以与其他需要成对或不成对数据进⾏训练的⽅法相⽐具有竞争⼒。图1⽰出了增强包含⾮均匀照明的微光图像的⽰例。与最新的⽅法相⽐，零DCE在保持固有颜⾊和细节的同时使图像变亮。相⽐之下，基于CNN的⽅法[28]和基于GAN的EnightGan都产⽣了低于（⾯部）和过度（内阁）的增强。
典型微光图像的视觉⽐较。所提出的零DCE在亮度、颜⾊、对⽐度和⾃然度⽅⾯都达到了令⼈满意的效果，⽽现有的⽅法要么⽆法处理极端的背光，要么产⽣颜⾊伪影。与其他基于深度学习的⽅法相⽐，我们的⽅法在没有任何参考图像的情况下进⾏训练。
我们的贡献总结如下。
1） 我们提出了第⼀个弱光增强⽹络，它独⽴于成对和不成对的训练数据，从⽽避免了过度拟合的风险。结果表明，该⽅法能很好地推⼴到各种照明条件下。
2） 我们设计了⼀个特定于图像的曲线，它能够通过迭代应⽤⾃⾝来近似像素级和⾼阶曲线。这种特定于图像的曲线可以在较宽的动态范围内有效地进⾏映射。
3） 我们展⽰了在没有参考图像的情况下，通过任务特定的⾮参考损失函数（间接评估增强质量）训练深度图像增强模型的潜⼒。英语口语训练
我们的零DCE⽅法在定性和定量度量⽅⾯都取代了最先进的性能。更重要的是，它能够改进⾼级视觉任务，例如⼈脸检测，⽽不会造成很⾼的计算负担。它能够实时处理图像（在GPU上，640×480×3⼤⼩的图像约为500fps），训练只需30分钟。
英语教育专业难点：
1.确定怎样的⽅程式⼦？
增强映射⽅程式如下：
该⽅程式需要满⾜三个条件：输出值【0，1】，避免计算过程中值溢出；简单且可微；保证图像相邻相邻像素的差异，其中阿尔法就是需要学习的参数，不但可以增强图像，也可以控制曝光
2. 如何迭代？
迭代⽅式如下：
原理类似于递归调⽤，上⼀次计算的输出作为本次的输⼊，不断迭代，可以理解为对输⼊图像不断进⾏这样的迭代，不断尝试，直到找到最优图像，也即loss最⼩。不过迭代多少次，本⽂从实验获取为8次。
3. 怎样与CNN结合？
⽹络架构如下：
对输⼊图像的每个信道分别做迭代操作，每次迭代操作的输出和输⼊图像map层再次结合作为下层输⼊。loss的计算实际就是计算最后增强的图像和原始输⼊图像之间的gap最⼤。
损失函数如何设计？
本⽂loss包含四种，分别为：
空间⼀致性loss:
曝光控制loss:
六级考试时间2020 九月
⾊彩恒定性loss:
光照平滑度loss:
考研政治答案
总loss：
我们在图4中给出了由各种损失组合训练的零度误差的结果。
fgf-没有空间⼀致性损失的结果与完整结果相⽐，对⽐度相对较低（例如，云区域）。这说明了Lspa在保持输⼊图像和增强图像之间相邻区域的差异⽅⾯的重要性。
移除曝光控制损失Lexp⽆法恢复低光区域。
当颜⾊恒定性损失Lcol被丢弃时，会出现严重的颜⾊投射。应⽤曲线映射时，此变量忽略三个通道之间的关系。
去除光照平滑度损失Ltva会阻碍相邻区域之间的相关性，从⽽导致明显的伪影。
损失函数代码实现(Myloss)：
import torch
as nn
functional as F
import math
dels.vgg import vgg16
import pytorch_colors as colors
import numpy as np
class L_color(nn.Module):
颜色搭配 英文
def__init__(lf):
super(L_color, lf).__init__()
def forward(lf, x ):
b,c,h,w = x.shape
mean_rgb = an(x,[2,3],keepdim=True)
mr,mg, mb = torch.split(mean_rgb,1, dim=1)
Drg = torch.pow(mr-mg,2)
Drb = torch.pow(mr-mb,2)
Dgb = torch.pow(mb-mg,2)
k = torch.pow(torch.pow(Drg,2)+ torch.pow(Drb,2)+ torch.pow(Dgb,2),0.5)
东莞北大青鸟
return k
class L_spa(nn.Module):
def__init__(lf):
super(L_spa, lf).__init__()
# print(1)kernel = torch.FloatTensor(kernel).unsqueeze(0).unsqueeze(0)
kernel_left = torch.FloatTensor([[0,0,0],[-1,1,0],[0,0,0]]).cuda().unsqueeze(0).unsqueeze(0)
kernel_right = torch.FloatTensor([[0,0,0],[0,1,-1],[0,0,0]]).cuda().unsqueeze(0).unsqueeze(0)
kernel_up = torch.FloatTensor([[0,-1,0],[0,1,0],[0,0,0]]).cuda().unsqueeze(0).unsqueeze(0)
kernel_down = torch.FloatTensor([[0,0,0],[0,1,0],[0,-1,0]]).cuda().unsqueeze(0).unsqueeze(0)
lf.weight_left = nn.Parameter(data=kernel_left, requires_grad=Fal)
lf.weight_right = nn.Parameter(data=kernel_right, requires_grad=Fal)
lf.weight_up = nn.Parameter(data=kernel_up, requires_grad=Fal)
lf.weight_down = nn.Parameter(data=kernel_down, requires_grad=Fal)
lf.pool = nn.AvgPool2d(4)
def forward(lf, org , enhance ):
b,c,h,w = org.shape
org_mean = an(org,1,keepdim=True)
enhance_mean = an(enhance,1,keepdim=True)
org_pool = lf.pool(org_mean)
enhance_pool = lf.pool(enhance_mean)
weight_diff =torch.max(torch.FloatTensor([1]).cuda()+10000*torch.min(org_pool - torch.FloatTensor([0.3]).cuda(),torch.FloatTensor([0]).cuda()),torc h.FloatTensor([0.5]).cuda())
呆若木鸡翻译E_1 = torch.mul(torch.sign(enhance_pool - torch.FloatTensor([0.5]).cuda()),enhance_pool-org_pool)
D_org_letf = F.conv2d(org_pool , lf.weight_left, padding=1)
D_org_right = F.conv2d(org_pool , lf.weight_right, padding=1)
D_org_up = F.conv2d(org_pool , lf.weight_up, padding=1)
D_org_down = F.conv2d(org_pool , lf.weight_down, padding=1)
D_enhance_letf = F.conv2d(enhance_pool , lf.weight_left, padding=1)
D_enhance_right = F.conv2d(enhance_pool , lf.weight_right, padding=1)
D_enhance_up = F.conv2d(enhance_pool , lf.weight_up, padding=1)
D_enhance_down = F.conv2d(enhance_pool , lf.weight_down, padding=1)
D_left = torch.pow(D_org_letf - D_enhance_letf,2)
D_right = torch.pow(D_org_right - D_enhance_right,2)
D_up = torch.pow(D_org_up - D_enhance_up,2)
D_down = torch.pow(D_org_down - D_enhance_down,2)
E =(D_left + D_right + D_up +D_down)
# E = 25*(D_left + D_right + D_up +D_down)
return E
class L_exp(nn.Module):
def__init__(lf,patch_size,mean_val):
super(L_exp, lf).__init__()
# print(1)
lf.pool = nn.AvgPool2d(patch_size)
def forward(lf, x ):
b,c,h,w = x.shape
x = an(x,1,keepdim=True)
mean = lf.pool(x)
d = an(torch.pow(mean- torch.FloatTensor([lf.mean_val]).cuda(),2))
袁腾飞 mp3return d
class L_TV(nn.Module):
def__init__(lf,TVLoss_weight=1):
super(L_TV,lf).__init__()
lf.TVLoss_weight = TVLoss_weight
def forward(lf,x):
batch_size = x.size()[0]
h_x = x.size()[2]
w_x = x.size()[3]
count_h =(x.size()[2]-1)* x.size()[3]
count_w = x.size()[2]*(x.size()[3]-1)
h_tv = torch.pow((x[:,:,1:,:]-x[:,:,:h_x-1,:]),2).sum()
w_tv = torch.pow((x[:,:,:,1:]-x[:,:,:,:w_x-1]),2).sum()
return lf.TVLoss_weight*2*(h_tv/count_h+w_tv/count_w)/batch_size
class Sa_Loss(nn.Module):
def__init__(lf):
super(Sa_Loss, lf).__init__()
# print(1)
def forward(lf, x ):
# lf.grad = np.ones(x.shape,dtype=np.float32)
b,c,h,w = x.shape
# x_de = x.cpu().detach().numpy()
r,g,b = torch.split(x ,1, dim=1)
mean_rgb = an(x,[2,3],keepdim=True)
mr,mg, mb = torch.split(mean_rgb,1, dim=1)
Dr = r-mr
Dg = g-mg
Db = b-mb
k =torch.pow( torch.pow(Dr,2)+ torch.pow(Db,2)+ torch.pow(Dg,2),0.5) # print(k)
k = an(k)
return k
class perception_loss(nn.Module):
def__init__(lf):
super(perception_loss, lf).__init__()
features = vgg16(pretrained=True).features
<_relu_1_2 = nn.Sequential()
<_relu_2_2 = nn.Sequential()
<_relu_3_3 = nn.Sequential()
<_relu_4_3 = nn.Sequential()
for x in range(4):
<_relu_1_2.add_module(str(x), features[x])
for x in range(4,9):
<_relu_2_2.add_module(str(x), features[x])
for x in range(9,16):
<_relu_3_3.add_module(str(x), features[x])
for x in range(16,23):
<_relu_4_3.add_module(str(x), features[x])
# don't need the gradients, just want the features
for param in lf.parameters():
def forward(lf, x):
h = lf.to_relu_1_2(x)
h_relu_1_2 = h
