0
0

神经网络（四）：UNet图像分割网络

文章目录

  论文链接：点击跳转

一、简介

  UNet网络是一种用于图像分割的卷积神经网络，其特点是采用了U型网络结构，因此称为UNet。该网络具有编码器和解码器结构，两种结构的功能如下：

  • 编码器：逐步提取输入图像的特征并降低空间分辨率。
  • 解码器：通过上采样操作将特征图恢复到原始输入图像的尺寸，并逐步生成分割结果。

【CNN角度的编码器、解码器】以卷积神经网络为例，输入为一个猫，进行特征提取后输出图片类别。

  • 编码器：完成对输入图片中猫的特征提取。
  • 解码器：将特征提取的结果解码为分类结果。

在这里插入图片描述
【RNN角度的编码器、解码器】以循环神经网络LSTM为例，输入为一个文本，进行特征提取再输出

  • 编码器：将文本表示为向量并实现特征提取。
  • 解码器：将向量转化为输出。

在这里插入图片描述
  UNet算法的关键创新是在解码器中引入了跳跃连接（Skip Connections），即将编码器中的特征图与解码器中对应的特征图进行连接。这种跳跃连接可以帮助解码器更好地利用不同层次的特征信息，从而提高图像分割的准确性和细节保留能力。

二、网络结构

  UNet的设计思想是通过编码器逐渐提取丰富的低级特征和高级特征，然后通过解码器逐渐恢复分辨率，并将低级特征和高级特征进行融合，以便获取准确且具有上下文信息的分割结果。这种U字形结构使得UNet能够同时利用全局（高分辨率时的特征图）和局部信息（低分辨率时的特征图），适用于图像分割任务。执行过程可粗略描述为：

输入层 -> 编码器（下采样模块 + 编码器模块） -> 解码器（上采样模块 + 解码器模块）-> 输出层。

即：

  • 编码器（Encoder）部分： - 输入层：接受输入图像作为模型的输入。- 下采样模块（Downsampling Block）：由一系列卷积层（通常是卷积、批归一化和激活函数的组合）和池化层组成，用于逐渐减小特征图的尺寸和通道数。这样可以逐渐提取出更高级别的特征信息。- 编码器模块（Encoder Block）：重复使用多个下采样模块，以便逐渐减小特征图的尺寸和通道数。每个编码器模块通常包含一个下采样模块和一个跳跃连接（Skip Connection），将上一级的特征图连接到下一级，以便在解码器中进行特征融合。
  • 解码器（Decoder）部分： - 上采样模块（Upsampling Block）：由一系列上采样操作（如反卷积或转置卷积）和卷积操作组成，用于逐渐增加特征图的尺寸和通道数。这样可以逐渐恢复分辨率并且保留更多的细节信息。- 解码器模块（Decoder Block）：重复使用多个上采样模块，以便逐渐增加特征图的尺寸和通道数。每个解码器模块通常包含一个上采样模块、一个跳跃连接和一个融合操作（如拼接或加权求和），用于将来自编码器的特征图与当前解码器的特征图进行融合。
  • 输出层：最后一层是一个卷积层，用于生成最终的分割结果。通常，输出层的通道数等于任务中的类别数，并应用适当的激活函数（如sigmoid或softmax），以产生每个像素点属于各个类别的概率分布。

跳跃连接（skip connection）：输入数据直接添加到网络某一层输出之上。这种设计使得信息可以更自由地流动，并且保留了原始输入数据中的细节和语义信息。 使信息更容易传播到后面的层次，避免了信息丢失。跳跃连接通常会通过求和操作或拼接操作来实现。
在这里插入图片描述
以图像分类任务为例，假设我们使用卷积神经网络进行特征提取，在每个卷积层后面都加入一个池化层来减小特征图尺寸。然而，池化操作可能导致信息损失。通过添加一个跳跃连接，将原始输入直接与最后一个池化层输出相加或拼接起来，可以保留原始图像中更多的细节和语义信息。

2.1编码器部分

在这里插入图片描述
  编码器部分由多个下采样模块（down sampling step）组成，每个下采样模块都由两个卷积层（卷积核大小为3x3，且与ReLU函数配合使用。由于图像尺寸变小，可见并未填充）和一个最大池化层（池化核大小2x2，步幅为2，将图像尺寸收缩一半）组成，并且每一次下采样操作后特征图的通道数均增加一倍。
  事实上，随着不断执行下采样模块（也成为收缩路径），特征图通道数随着卷积操作也不断增加，从而获取了图像的更多特征。并且在进入下一下采样模块前，进行 2x2 最大池化以获得最大像素值，虽然丢失一些特征，但保留最大像素值。通过这种方式，可将图像中目标的像素按类别进行分割。每一下采样模块的实现代码如下：
【第一个下采样模块】
  卷积操作：

  1.         self.conv1_1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=0)#(572,572,1)->((572-3+1),(572-3+1),64)->(570,570,64)
  2.         self.relu1_1 = nn.ReLU(inplace=True)
  3.         self.conv1_2 = nn.Conv2d(64,64, kernel_size=3, stride=1, padding=0)# (570,570,64)->((570-3+1),(570-3+1),64)->(568,568,64)
  4.         self.relu1_2 = nn.ReLU(inplace=True)

  池化操作

  1. #采用最大池化进行下采样，图片大小减半，通道数不变，由(568,568,64)->(284,284,64)
  2. self.maxpool_1 = nn.MaxPool2d(kernel_size=2, stride=2)

【第二个下采样模块】
  卷积操作：

  1.         self.conv2_1 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=0)#(284,284,64)->(282,282,128)
  2.         self.relu2_1 = nn.ReLU(inplace=True)
  3.         self.conv2_2 = nn.Conv2d(128,128, kernel_size=3, stride=1, padding=0)#(282,282,128)->(280,280,128)
  4.         self.relu2_2 = nn.ReLU(inplace=True)

  池化操作：

  1. # 采用最大池化进行下采样(280,280,128)->(140,140,128)
  2. self.maxpool_2 = nn.MaxPool2d(kernel_size=2, stride=2)

  编码器部分总代码：

  1. classUnet(nn.Module):def__init__(self):super(Unet, self).__init__()#第一个下采样模块
  2.         self.conv1_1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=0)
  3.         self.relu1_1 = nn.ReLU(inplace=True)
  4.         self.conv1_2 = nn.Conv2d(64,64, kernel_size=3, stride=1, padding=0) 
  5.         self.relu1_2 = nn.ReLU(inplace=True)
  7.         self.maxpool_1 = nn.MaxPool2d(kernel_size=2, stride=2)#第二个下采样模块
  8.         self.conv2_1 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=0)#(284,284,64)->(282,282,128)
  9.         self.relu2_1 = nn.ReLU(inplace=True)
  10.         self.conv2_2 = nn.Conv2d(128,128, kernel_size=3, stride=1, padding=0)#(282,282,128)->(280,280,128)
  11.         self.relu2_2 = nn.ReLU(inplace=True)
  13.         self.maxpool_2 = nn.MaxPool2d(kernel_size=2, stride=2)#第三个下采样模块
  14.         self.conv3_1 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=0)
  15.         self.relu3_1 = nn.ReLU(inplace=True)
  16.         self.conv3_2 = nn.Conv2d(256,256, kernel_size=3, stride=1, padding=0)
  17.         self.relu3_2 = nn.ReLU(inplace=True)
  19.         self.maxpool_3 = nn.MaxPool2d(kernel_size=2, stride=2)#第四个下采样模块
  20.         self.conv4_1 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=0)
  21.         self.relu4_1 = nn.ReLU(inplace=True)
  22.         self.conv4_2 = nn.Conv2d(512,512, kernel_size=3, stride=1, padding=0)
  23.         self.relu4_2 = nn.ReLU(inplace=True)
  25.         self.maxpool_4 = nn.MaxPool2d(kernel_size=2, stride=2)#第五个下采样模块
  26.         self.conv5_1 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, stride=1, padding=0)# 32*32*512->30*30*1024
  27.         self.relu5_1 = nn.ReLU(inplace=True)
  28.         self.conv5_2 = nn.Conv2d(1024,1024, kernel_size=3, stride=1, padding=0)
  29.         self.relu5_2 = nn.ReLU(inplace=True)

在五个下采样操作后，特征图大小变为 

  1.      ( 
  2.     
  3.    
  4.      28 
  5.     
  6.    
  7.      , 
  8.     
  9.    
  10.      28 
  11.     
  12.    
  13.      , 
  14.     
  15.    
  16.      1024 
  17.     
  18.    
  19.      ) 
  20.     
  21.    
  22.   
  23.     (28,28,1024) 
  24.    
  25.   
  26. (28,28,1024)。

2.2解码器部分

在这里插入图片描述

  • up-conv 2x2：上采样操作，通过反卷积操作实现。
  • copy and crop：复制和裁剪，将下采样模块输出的特征图进行复制和裁剪，方便和上采样生成的特征图进行拼接。

  下采样操作后，虽然使用最大池化运算丢失了部分细节信息，但模型已经得到了所有类的像素特征值。而在上采样中，模型将特征图通过具有相同级别的上采样过滤器来将特征图恢复到原始的分辨率大小，并通过跳跃连接的方式将下采样模块输出的每个特征图都添加到上采样模块的相应特征层中，从而保留特征。最后，通过完整的特征图即可定位每个类在图像中存在的位置，从而实现类别的定位。

  第一个上采样模块细节如下：
在这里插入图片描述
  最下面的下采样模块输出特征图大小为 

  1.      ( 
  2.     
  3.    
  4.      28 
  5.     
  6.    
  7.      , 
  8.     
  9.    
  10.      28 
  11.     
  12.    
  13.      , 
  14.     
  15.    
  16.      1024 
  17.     
  18.    
  19.      ) 
  20.     
  21.    
  22.   
  23.     (28,28,1024) 
  24.    
  25.   
  26. (28,28,1024)，经过反卷积操作（up-conv 2x2）得到大小为 
  27.  
  28.   
  29.    
  30.    
  31.      ( 
  32.     
  33.    
  34.      56 
  35.     
  36.    
  37.      , 
  38.     
  39.    
  40.      56 
  41.     
  42.    
  43.      , 
  44.     
  45.    
  46.      512 
  47.     
  48.    
  49.      ) 
  50.     
  51.    
  52.   
  53.     (56,56,512) 
  54.    
  55.   
  56. (56,56,512)的特征图，即尺寸扩大一倍，通道数减半。之后，将左侧下采样模块输出的 
  57.  
  58.   
  59.    
  60.    
  61.      ( 
  62.     
  63.    
  64.      64 
  65.     
  66.    
  67.      , 
  68.     
  69.    
  70.      64 
  71.     
  72.    
  73.      , 
  74.     
  75.    
  76.      512 
  77.     
  78.    
  79.      ) 
  80.     
  81.    
  82.   
  83.     (64,64,512) 
  84.    
  85.   
  86. (64,64,512)图像进行复制并中心裁剪（copy and crop）同样转化为 
  87.  
  88.   
  89.    
  90.    
  91.      ( 
  92.     
  93.    
  94.      56 
  95.     
  96.    
  97.      , 
  98.     
  99.    
  100.      56 
  101.     
  102.    
  103.      , 
  104.     
  105.    
  106.      512 
  107.     
  108.    
  109.      ) 
  110.     
  111.    
  112.   
  113.     (56,56,512) 
  114.    
  115.   
  116. (56,56,512)大小，并与之拼接得到 
  117.  
  118.   
  119.    
  120.    
  121.      ( 
  122.     
  123.    
  124.      56 
  125.     
  126.    
  127.      , 
  128.     
  129.    
  130.      56 
  131.     
  132.    
  133.      , 
  134.     
  135.    
  136.      1024 
  137.     
  138.    
  139.      ) 
  140.     
  141.    
  142.   
  143.     (56,56,1024) 
  144.    
  145.   
  146. (56,56,1024)大小的特征图（可见，此拼接仅是通道方向的拼接）。代码实现：
  1. # 上采样中反卷积操作的实现
  2. self.up_conv_1 = nn.ConvTranspose2d(in_channels=1024, out_channels=512, kernel_size=2, stride=2, padding=0)# 28*28*1024->56*56*512

同理也可得到其他反卷积操作的实现：

  1. self.up_conv_2 = nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=2, stride=2, padding=0)# 52*52*512->104*104*256
  2. self.up_conv_3 = nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=2, stride=2, padding=0)# 100*100*256->200*200*128
  3. self.up_conv_4 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=2, stride=2, padding=0)# 196*196*128->392*392*64

  右半部分卷积操作的代码实现：
【第一次卷积】

  1.         self.conv6_1 = nn.Conv2d(in_channels=1024, out_channels=512, kernel_size=3, stride=1, padding=0)# 56*56*1024->54*54*512
  2.         self.relu6_1 = nn.ReLU(inplace=True)
  3.         self.conv6_2 = nn.Conv2d(512,512, kernel_size=3, stride=1, padding=0)# 54*54*512->52*52*512
  4.         self.relu6_2 = nn.ReLU(inplace=True)

【第二次卷积】

  1.         self.conv7_1 = nn.Conv2d(in_channels=512, out_channels=256, kernel_size=3, stride=1, padding=0)# 104*104*512->102*102*256
  2.         self.relu7_1 = nn.ReLU(inplace=True)
  3.         self.conv7_2 = nn.Conv2d(256,256, kernel_size=3, stride=1, padding=0)# 102*102*256->100*100*256
  4.         self.relu7_2 = nn.ReLU(inplace=True)

【第三次卷积】

  1.         self.conv8_1 = nn.Conv2d(in_channels=256, out_channels=128, kernel_size=3, stride=1, padding=0)# 200*200*256->198*198*128
  2.         self.relu8_1 = nn.ReLU(inplace=True)
  3.         self.conv8_2 = nn.Conv2d(128,128, kernel_size=3, stride=1, padding=0)# 198*198*128->196*196*128
  4.         self.relu8_2 = nn.ReLU(inplace=True)

【第四次卷积】

  1.         self.conv9_1 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=0)# 392*392*128->390*390*64
  2.         self.relu9_1 = nn.ReLU(inplace=True)
  3.         self.conv9_2 = nn.Conv2d(64,64, kernel_size=3, stride=1, padding=0)# 390*390*64->388*388*64
  4.         self.relu9_2 = nn.ReLU(inplace=True)

【第五次卷积】

  1. # 最后的conv1*1
  2.         self.conv_10 = nn.Conv2d(in_channels=64, out_channels=2, kernel_size=1, stride=1, padding=0)#64x388x388->2x388x388

  中心裁剪操作的实现：

  1. # 中心裁剪，defcrop_tensor(self, tensor, target_tensor):
  2.         target_size = target_tensor.size()[2]
  3.         tensor_size = tensor.size()[2]
  4.         delta = tensor_size - target_size
  5.         delta = delta //2# 如果原始张量的尺寸为10，而delta为2，那么"delta:tensor_size - delta"将截取从索引2到索引8的部分，长度为6，以使得截取后的张量尺寸变为6。return tensor[:,:, delta:tensor_size - delta, delta:tensor_size - delta]

【第一次上采样+拼接】

  1. # 第一次上采样，需要"Copy and crop"（复制并裁剪）
  2.         up1 = self.up_conv_1(x10)# 得到56*56*512# 需要对x8进行裁剪，从中心往外裁剪
  3.         crop1 = self.crop_tensor(x8, up1)# 拼接操作
  4.         up_1 = torch.cat([crop1, up1], dim=1)

【第二次上采样+拼接】

  1. # 第二次上采样，需要"Copy and crop"（复制并裁剪）
  2.         up2 = self.up_conv_2(y2)# 需要对x6进行裁剪，从中心往外裁剪
  3.         crop2 = self.crop_tensor(x6, up2)# 拼接
  4.         up_2 = torch.cat([crop2, up2], dim=1)

【第三次上采样+拼接】

  1. # 第三次上采样，需要"Copy and crop"（复制并裁剪）
  2.         up3 = self.up_conv_3(y4)# 需要对x4进行裁剪，从中心往外裁剪
  3.         crop3 = self.crop_tensor(x4, up3)
  4.         up_3 = torch.cat([crop3, up3], dim=1)

【第四次上采样+拼接】

  1. # 第四次上采样，需要"Copy and crop"（复制并裁剪）
  2.         up4 = self.up_conv_4(y6)# 需要对x2进行裁剪，从中心往外裁剪
  3.         crop4 = self.crop_tensor(x2, up4)
  4.         up_4 = torch.cat([crop4, up4], dim=1)

2.3完整代码

在这里插入图片描述

  1. import torch
  2. import torch.nn as nn
  4. classUnet(nn.Module):def__init__(self):super(Unet, self).__init__()
  5.         self.conv1_1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=0)# 由572*572*1变成了570*570*64
  6.         self.relu1_1 = nn.ReLU(inplace=True)
  7.         self.conv1_2 = nn.Conv2d(64,64, kernel_size=3, stride=1, padding=0)# 由570*570*64变成了568*568*64
  8.         self.relu1_2 = nn.ReLU(inplace=True)
  10.         self.maxpool_1 = nn.MaxPool2d(kernel_size=2, stride=2)# 采用最大池化进行下采样，图片大小减半，通道数不变，由568*568*64变成284*284*64
  12.         self.conv2_1 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=0)# 284*284*64->282*282*128
  13.         self.relu2_1 = nn.ReLU(inplace=True)
  14.         self.conv2_2 = nn.Conv2d(128,128, kernel_size=3, stride=1, padding=0)# 282*282*128->280*280*128
  15.         self.relu2_2 = nn.ReLU(inplace=True)
  17.         self.maxpool_2 = nn.MaxPool2d(kernel_size=2, stride=2)# 采用最大池化进行下采样  280*280*128->140*140*128
  19.         self.conv3_1 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=0)# 140*140*128->138*138*256
  20.         self.relu3_1 = nn.ReLU(inplace=True)
  21.         self.conv3_2 = nn.Conv2d(256,256, kernel_size=3, stride=1, padding=0)# 138*138*256->136*136*256
  22.         self.relu3_2 = nn.ReLU(inplace=True)
  24.         self.maxpool_3 = nn.MaxPool2d(kernel_size=2, stride=2)# 采用最大池化进行下采样  136*136*256->68*68*256
  26.         self.conv4_1 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=0)# 68*68*256->66*66*512
  27.         self.relu4_1 = nn.ReLU(inplace=True)
  28.         self.conv4_2 = nn.Conv2d(512,512, kernel_size=3, stride=1, padding=0)# 66*66*512->64*64*512
  29.         self.relu4_2 = nn.ReLU(inplace=True)
  31.         self.maxpool_4 = nn.MaxPool2d(kernel_size=2, stride=2)# 采用最大池化进行下采样  64*64*512->32*32*512
  33.         self.conv5_1 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, stride=1, padding=0)# 32*32*512->30*30*1024
  34.         self.relu5_1 = nn.ReLU(inplace=True)
  35.         self.conv5_2 = nn.Conv2d(1024,1024, kernel_size=3, stride=1, padding=0)# 30*30*1024->28*28*1024
  36.         self.relu5_2 = nn.ReLU(inplace=True)# 接下来实现上采样中的up-conv2*2
  37.         self.up_conv_1 = nn.ConvTranspose2d(in_channels=1024, out_channels=512, kernel_size=2, stride=2, padding=0)# 28*28*1024->56*56*512
  39.         self.conv6_1 = nn.Conv2d(in_channels=1024, out_channels=512, kernel_size=3, stride=1, padding=0)# 56*56*1024->54*54*512
  40.         self.relu6_1 = nn.ReLU(inplace=True)
  41.         self.conv6_2 = nn.Conv2d(512,512, kernel_size=3, stride=1, padding=0)# 54*54*512->52*52*512
  42.         self.relu6_2 = nn.ReLU(inplace=True)
  44.         self.up_conv_2 = nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=2, stride=2, padding=0)# 52*52*512->104*104*256
  46.         self.conv7_1 = nn.Conv2d(in_channels=512, out_channels=256, kernel_size=3, stride=1, padding=0)# 104*104*512->102*102*256
  47.         self.relu7_1 = nn.ReLU(inplace=True)
  48.         self.conv7_2 = nn.Conv2d(256,256, kernel_size=3, stride=1, padding=0)# 102*102*256->100*100*256
  49.         self.relu7_2 = nn.ReLU(inplace=True)
  51.         self.up_conv_3 = nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=2, stride=2, padding=0)# 100*100*256->200*200*128
  53.         self.conv8_1 = nn.Conv2d(in_channels=256, out_channels=128, kernel_size=3, stride=1, padding=0)# 200*200*256->198*198*128
  54.         self.relu8_1 = nn.ReLU(inplace=True)
  55.         self.conv8_2 = nn.Conv2d(128,128, kernel_size=3, stride=1, padding=0)# 198*198*128->196*196*128
  56.         self.relu8_2 = nn.ReLU(inplace=True)
  58.         self.up_conv_4 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=2, stride=2, padding=0)# 196*196*128->392*392*64
  60.         self.conv9_1 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=0)# 392*392*128->390*390*64
  61.         self.relu9_1 = nn.ReLU(inplace=True)
  62.         self.conv9_2 = nn.Conv2d(64,64, kernel_size=3, stride=1, padding=0)# 390*390*64->388*388*64
  63.         self.relu9_2 = nn.ReLU(inplace=True)# 最后的conv1*1
  64.         self.conv_10 = nn.Conv2d(in_channels=64, out_channels=2, kernel_size=1, stride=1, padding=0)# 中心裁剪，defcrop_tensor(self, tensor, target_tensor):
  65.         target_size = target_tensor.size()[2]
  66.         tensor_size = tensor.size()[2]
  67.         delta = tensor_size - target_size
  68.         delta = delta //2# 如果原始张量的尺寸为10，而delta为2，那么"delta:tensor_size - delta"将截取从索引2到索引8的部分，长度为6，以使得截取后的张量尺寸变为6。return tensor[:,:, delta:tensor_size - delta, delta:tensor_size - delta]defforward(self, x):
  69.         x1 = self.conv1_1(x)
  70.         x1 = self.relu1_1(x1)
  71.         x2 = self.conv1_2(x1)
  72.         x2 = self.relu1_2(x2)# 这个后续需要使用
  73.         down1 = self.maxpool_1(x2)
  75.         x3 = self.conv2_1(down1)
  76.         x3 = self.relu2_1(x3)
  77.         x4 = self.conv2_2(x3)
  78.         x4 = self.relu2_2(x4)# 这个后续需要使用
  79.         down2 = self.maxpool_2(x4)
  81.         x5 = self.conv3_1(down2)
  82.         x5 = self.relu3_1(x5)
  83.         x6 = self.conv3_2(x5)
  84.         x6 = self.relu3_2(x6)# 这个后续需要使用
  85.         down3 = self.maxpool_3(x6)
  87.         x7 = self.conv4_1(down3)
  88.         x7 = self.relu4_1(x7)
  89.         x8 = self.conv4_2(x7)
  90.         x8 = self.relu4_2(x8)# 这个后续需要使用
  91.         down4 = self.maxpool_4(x8)
  93.         x9 = self.conv5_1(down4)
  94.         x9 = self.relu5_1(x9)
  95.         x10 = self.conv5_2(x9)
  96.         x10 = self.relu5_2(x10)# 第一次上采样，需要"Copy and crop"（复制并裁剪）
  97.         up1 = self.up_conv_1(x10)# 得到56*56*512# 需要对x8进行裁剪，从中心往外裁剪
  98.         crop1 = self.crop_tensor(x8, up1)
  99.         up_1 = torch.cat([crop1, up1], dim=1)
  101.         y1 = self.conv6_1(up_1)
  102.         y1 = self.relu6_1(y1)
  103.         y2 = self.conv6_2(y1)
  104.         y2 = self.relu6_2(y2)# 第二次上采样，需要"Copy and crop"（复制并裁剪）
  105.         up2 = self.up_conv_2(y2)# 需要对x6进行裁剪，从中心往外裁剪
  106.         crop2 = self.crop_tensor(x6, up2)
  107.         up_2 = torch.cat([crop2, up2], dim=1)
  109.         y3 = self.conv7_1(up_2)
  110.         y3 = self.relu7_1(y3)
  111.         y4 = self.conv7_2(y3)
  112.         y4 = self.relu7_2(y4)# 第三次上采样，需要"Copy and crop"（复制并裁剪）
  113.         up3 = self.up_conv_3(y4)# 需要对x4进行裁剪，从中心往外裁剪
  114.         crop3 = self.crop_tensor(x4, up3)
  115.         up_3 = torch.cat([crop3, up3], dim=1)
  117.         y5 = self.conv8_1(up_3)
  118.         y5 = self.relu8_1(y5)
  119.         y6 = self.conv8_2(y5)
  120.         y6 = self.relu8_2(y6)# 第四次上采样，需要"Copy and crop"（复制并裁剪）
  121.         up4 = self.up_conv_4(y6)# 需要对x2进行裁剪，从中心往外裁剪
  122.         crop4 = self.crop_tensor(x2, up4)
  123.         up_4 = torch.cat([crop4, up4], dim=1)
  125.         y7 = self.conv9_1(up_4)
  126.         y7 = self.relu9_1(y7)
  127.         y8 = self.conv9_2(y7)
  128.         y8 = self.relu9_2(y8)# 最后的conv1*1
  129.         out = self.conv_10(y8)return out
  130. if __name__ =='__main__':
  131.     input_data = torch.randn([1,1,572,572])
  132.     unet = Unet()
  133.     output = unet(input_data)print(output.shape)# torch.Size([1, 2, 388, 388])

三、实战案例

  准备复现论文：点击跳转、点击跳转
  准备复现项目：点击跳转

标签： 神经网络 网络 人工智能
本文转载自: https://blog.csdn.net/qq_51976293/article/details/142515193
版权归原作者 悟兰因w 所有， 如有侵权，请联系我们删除。
登录后发布评论

“神经网络（四）：UNet图像分割网络”的评论:

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

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

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

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

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

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

Kafka学习笔记

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