0
0

基于深度学习神经网络的AI图像PSD去雾系统源码

第一步：PSD介绍

  1.     以往的研究主要集中在具有合成模糊图像的训练模型上，当模型用于真实世界的模糊图像时，会导致性能下降。
  3.     为了解决上述问题，提高去雾的泛化性能，作者提出了一种Principled Synthetic-to-real Dehazing (PSD)框架。
  5.     本文提出的PSD适用于将现有的去雾模型推广到实际领域，包括两个阶段：**有监督的预训练**和**无监督的微调**。

** 预训练阶段**，作者将选定的去雾模型主干修改为一个基于物理模型的网络，并用合成数据训练该网络。利用设计良好的主干，我们可以得到一个预先训练的模型，在合成域上具有良好的去雾性能。

** 微调阶段，作者利用真实的模糊图像以无监督**的方式训练模型。

本文的贡献：

  1. 作者将真实世界的去雾任务重新定义为一个合成到真实的泛化框架：首先一个在合成配对数据上预先训练的去雾模型主干，真实的模糊图像随后将被利用以一种无监督的方式微调模型。PSD易于使用，可以以大多数深度去雾模型为骨干。
  2. 由于没有清晰的真实图像作为监督，作者利用几个流行的、有充分根据的物理先验来指导微调。作者将它们合并成一个预先的损失committee，作为具体任务的代理指导，这一部分也是PSD的核心。
  3. 性能达到SOTA

第二步：PSD网络结构

  1.     首先对两个框架大的方向做一个整体概述：

** Pre-training**

  1.     首先采用目前性能最好的框架之一作为网络的主干
  3.     然后我们将主干修改为一个基于物理的网络，根据一个单一的雾图同时生成干净的图像 J，传输图 t 和大气光 A，为了共同优化这三个分量，作者加入了一个重建损失，它引导网络输出服从物理散射模型。
  5.     在这个阶段，只使用标记的合成数据进行训练，最终得到一个在合成域上预训练的模型。

** Fine-tuning**

  1.     作者利用**未标记的真实数据**将预训练模型从合成域推广到真实域。受去雾强物理背景的启发，作者认为一个高质量的无雾图像应该**遵循一些特定的统计规则**，这些规则可以从图像先验中推导出来。此外，**单一先验提供的物理知识并不总是可靠的**，所以作者的目标是找到多个先验的组合，希望它们能够相互补充。
  3.     基于上述，作者设计了一个先验损失committee来作为任务特定的代理指导，用于**训练未标记的真实数据**。
  5.     此外，作者应用了一种learning without forgetting (LwF)的方法，该方法通过将原始任务的训练数据(即合成的模糊图像)通过网络运转到同真实的模糊数据一起，从而强行使得模型记忆合成领域的知识。

第三步：模型代码展示

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  5. class BlockUNet1(nn.Module):
  6.     def __init__(self, in_channels, out_channels, upsample=False, relu=False, drop=False, bn=True):
  7.         super(BlockUNet1, self).__init__()
  9.         self.conv = nn.Conv2d(in_channels, out_channels, 4, 2, 1, bias=False)
  10.         self.deconv = nn.ConvTranspose2d(in_channels, out_channels, 4, 2, 1, bias=False)
  12.         self.dropout = nn.Dropout2d(0.5)
  13.         self.batch = nn.InstanceNorm2d(out_channels)
  15.         self.upsample = upsample
  16.         self.relu = relu
  17.         self.drop = drop
  18.         self.bn = bn
  20.     def forward(self, x):
  21.         if self.relu == True:
  22.             y = F.relu(x)
  23.         elif self.relu == False:
  24.             y = F.leaky_relu(x, 0.2)
  25.         if self.upsample == True:
  26.             y = self.deconv(y)
  27.             if self.bn == True:
  28.                 y = self.batch(y)
  29.             if self.drop == True:
  30.                 y = self.dropout(y)
  32.         elif self.upsample == False:
  33.             y = self.conv(y)
  34.             if self.bn == True:
  35.                 y = self.batch(y)
  36.             if self.drop == True:
  37.                 y = self.dropout(y)
  39.         return y
  41. class G2(nn.Module):
  42.     def __init__(self, in_channels, out_channels):
  43.         super(G2, self).__init__()
  45.         self.conv = nn.Conv2d(in_channels, 8, 4, 2, 1, bias=False)
  46.         self.layer1 = BlockUNet1(8, 16)
  47.         self.layer2 = BlockUNet1(16, 32)
  48.         self.layer3 = BlockUNet1(32, 64)
  49.         self.layer4 = BlockUNet1(64, 64)
  50.         self.layer5 = BlockUNet1(64, 64)
  51.         self.layer6 = BlockUNet1(64, 64)
  52.         self.layer7 = BlockUNet1(64, 64)
  53.         self.dlayer7 = BlockUNet1(64, 64, True, True, True, False)
  54.         self.dlayer6 = BlockUNet1(128, 64, True, True, True)
  55.         self.dlayer5 = BlockUNet1(128, 64, True, True, True)
  56.         self.dlayer4 = BlockUNet1(128, 64, True, True)
  57.         self.dlayer3 = BlockUNet1(128, 32, True, True)
  58.         self.dlayer2 = BlockUNet1(64, 16, True, True)
  59.         self.dlayer1 = BlockUNet1(32, 8, True, True)
  60.         self.relu = nn.ReLU()
  61.         self.dconv = nn.ConvTranspose2d(16, out_channels, 4, 2, 1, bias=False)
  62.         self.lrelu = nn.LeakyReLU(0.2)
  64.     def forward(self, x):
  65.         y1 = self.conv(x)
  66.         y2 = self.layer1(y1)
  67.         y3 = self.layer2(y2)
  68.         y4 = self.layer3(y3)
  69.         y5 = self.layer4(y4)
  70.         y6 = self.layer5(y5)
  71.         y7 = self.layer6(y6)
  72.         y8 = self.layer7(y7)
  74.         dy8 = self.dlayer7(y8)
  75.         concat7 = torch.cat([dy8, y7], 1)
  76.         dy7 = self.dlayer6(concat7)
  77.         concat6 = torch.cat([dy7, y6], 1)
  78.         dy6 = self.dlayer5(concat6)
  79.         concat5 = torch.cat([dy6, y5], 1)
  80.         dy5 = self.dlayer4(concat5)
  81.         concat4 = torch.cat([dy5, y4], 1)
  82.         dy4 = self.dlayer3(concat4)
  83.         concat3 = torch.cat([dy4, y3], 1)
  84.         dy3 = self.dlayer2(concat3)
  85.         concat2 = torch.cat([dy3, y2], 1)
  86.         dy2 = self.dlayer1(concat2)
  87.         concat1 = torch.cat([dy2, y1], 1)
  88.         out = self.relu(concat1)
  89.         out = self.dconv(out)
  90.         out = self.lrelu(out)
  92.         return F.avg_pool2d(out, (out.shape[2], out.shape[3]))
  93.     
  94. def default_conv(in_channels, out_channels, kernel_size, bias=True):
  95.     return nn.Conv2d(in_channels, out_channels, kernel_size,padding=(kernel_size//2), bias=bias)
  96.     
  97. class PALayer(nn.Module):
  98.     def __init__(self, channel):
  99.         super(PALayer, self).__init__()
  100.         self.pa = nn.Sequential(
  101.                 nn.Conv2d(channel, channel // 8, 1, padding=0, bias=True),
  102.                 nn.ReLU(inplace=True),
  103.                 nn.Conv2d(channel // 8, 1, 1, padding=0, bias=True),
  104.                 nn.Sigmoid()
  105.         )
  106.     def forward(self, x):
  107.         y = self.pa(x)
  108.         return x * y
  110. class CALayer(nn.Module):
  111.     def __init__(self, channel):
  112.         super(CALayer, self).__init__()
  113.         self.avg_pool = nn.AdaptiveAvgPool2d(1)
  114.         self.ca = nn.Sequential(
  115.                 nn.Conv2d(channel, channel // 8, 1, padding=0, bias=True),
  116.                 nn.ReLU(inplace=True),
  117.                 nn.Conv2d(channel // 8, channel, 1, padding=0, bias=True),
  118.                 nn.Sigmoid()
  119.         )
  121.     def forward(self, x):
  122.         y = self.avg_pool(x)
  123.         y = self.ca(y)
  124.         return x * y
  126. class Block(nn.Module):
  127.     def __init__(self, conv, dim, kernel_size,):
  128.         super(Block, self).__init__()
  129.         self.conv1=conv(dim, dim, kernel_size, bias=True)
  130.         self.act1=nn.ReLU(inplace=True)
  131.         self.conv2=conv(dim,dim,kernel_size,bias=True)
  132.         self.calayer=CALayer(dim)
  133.         self.palayer=PALayer(dim)
  134.     def forward(self, x):
  135.         res=self.act1(self.conv1(x))
  136.         res=res+x 
  137.         res=self.conv2(res)
  138.         res=self.calayer(res)
  139.         res=self.palayer(res)
  140.         res += x 
  141.         return res
  142. class Group(nn.Module):
  143.     def __init__(self, conv, dim, kernel_size, blocks):
  144.         super(Group, self).__init__()
  145.         modules = [ Block(conv, dim, kernel_size)  for _ in range(blocks)]
  146.         modules.append(conv(dim, dim, kernel_size))
  147.         self.gp = nn.Sequential(*modules)
  148.     def forward(self, x):
  149.         res = self.gp(x)
  150.         res += x
  151.         return res
  153. class FFANet(nn.Module):
  154.     def __init__(self,gps,blocks,conv=default_conv):
  155.         super(FFANet, self).__init__()
  156.         self.gps=gps
  157.         self.dim=64
  158.         kernel_size=3
  159.         pre_process = [conv(3, self.dim, kernel_size)]
  160.         assert self.gps==3
  161.         self.g1= Group(conv, self.dim, kernel_size,blocks=blocks)
  162.         self.g2= Group(conv, self.dim, kernel_size,blocks=blocks)
  163.         self.g3= Group(conv, self.dim, kernel_size,blocks=blocks)
  164.         self.ca=nn.Sequential(*[
  165.             nn.AdaptiveAvgPool2d(1),
  166.             nn.Conv2d(self.dim*self.gps,self.dim//16,1,padding=0),
  167.             nn.ReLU(inplace=True),
  168.             nn.Conv2d(self.dim//16, self.dim*self.gps, 1, padding=0, bias=True),
  169.             nn.Sigmoid()
  170.             ])
  171.         self.palayer=PALayer(self.dim)
  173.         self.conv_J_1 = nn.Conv2d(64, 64, 3, 1, 1, bias=False)
  174.         self.conv_J_2 = nn.Conv2d(64, 3, 3, 1, 1, bias=False)
  175.         self.conv_T_1 = nn.Conv2d(64, 16, 3, 1, 1, bias=False)
  176.         self.conv_T_2 = nn.Conv2d(16, 1, 3, 1, 1, bias=False)
  177.         
  178.         post_precess = [
  179.             conv(self.dim, self.dim, kernel_size),
  180.             conv(self.dim, 3, kernel_size)]
  182.         self.pre = nn.Sequential(*pre_process)
  183.         self.post = nn.Sequential(*post_precess)
  184.         self.ANet = G2(3, 3)
  186.     def forward(self, x1, x2=0, Val=False):
  187.         x = self.pre(x1)
  188.         res1=self.g1(x)
  189.         res2=self.g2(res1)
  190.         res3=self.g3(res2)
  191.         w=self.ca(torch.cat([res1,res2,res3],dim=1))
  192.         w=w.view(-1,self.gps,self.dim)[:,:,:,None,None]
  193.         out=w[:,0,::]*res1+w[:,1,::]*res2+w[:,2,::]*res3
  194.         out=self.palayer(out)
  195.         
  196.         out_J = self.conv_J_1(out)
  197.         out_J = self.conv_J_2(out_J)
  198.         out_J = out_J + x1
  199.         out_T = self.conv_T_1(out)
  200.         out_T = self.conv_T_2(out_T)
  201.         
  202.         if Val == False:
  203.             out_A = self.ANet(x1)
  204.         else:
  205.             out_A = self.ANet(x2)
  206.             
  207.         out_I = out_T * out_J + (1 - out_T) * out_A
  208.         #x=self.post(out)
  209.         return out, out_J, out_T, out_A, out_I
  210.     
  211. if __name__ == "__main__":
  212.     net=FFA(gps=3,blocks=19)
  213.     print(net)

第四步：运行

第五步：整个工程的内容

代码的下载路径（新窗口打开链接）：基于深度学习神经网络的AI图像PSD去雾系统源码

​​

有问题可以私信或者留言，有问必答

标签： 深度学习 人工智能 神经网络
本文转载自: https://blog.csdn.net/m0_59023219/article/details/138765064
版权归原作者 AI街潜水的八角 所有， 如有侵权，请联系我们删除。
登录后发布评论

“基于深度学习神经网络的AI图像PSD去雾系统源码”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。