Unet网络架构讲解（从零到一，逐行编写并重点讲解数据维度变化）

已于 2024-04-25 08:36:53 修改
阅读量10w+ 收藏 1.8k
点赞数 910
分类专栏： Pytorch 文章标签： python 深度学习 人工智能 unet
于 2024-04-23 00:55:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/knighthood2001/article/details/138075554
版权

📚博客主页：knighthood2001
✨公众号：认知up吧 （目前正在带领大家一起提升认知，感兴趣可以来围观一下）
🎃知识星球：【认知up吧|成长|副业】介绍
❤️感谢大家点赞👍🏻收藏⭐评论✍🏻，您的三连就是我持续更新的动力❤️
🙏笔者水平有限，欢迎各位大佬指点，相互学习进步！

今天开始讲解一下Unet网络架构以及Pytorch代码构建。

整体架构图

在这里插入图片描述
这张图片应该是Unet网络最出名的图片，网络形状像“U”，故被称为U-net。

网络讲解

我觉得很多人对这个网络架构可能还是一知半解的，包括我最初也是这样的。

首先就是这几个箭头表示的是什么，这几个箭头相比于VGG16网络架构，难了不少。
因为VGG16网络架构中只有卷积层、全连接层，不涉及到特别复杂的操作。

  1. conv 3x3,ReLu就是卷积层，其中卷积核大小是3x3，然后经过ReLu激活。
  2. copy and crop的意思是复制和裁剪。这块内容我觉得很多人最初和我一样，不明白是什么意思，这里的意思就是对于你输出的尺寸，你需要进行复制并进行中心剪裁。方便和后面上采样生成的尺寸进行拼接。
  3. max pool 2x2，就是最大池化层，卷积核为2x2。
  4. up-conv 2x2：这里对于初学者来说，是最难领悟的地方，因为看不懂这个符号是啥意思。我最初以为是upsample+conv2d，试了一下，好像生成不了符合要求的尺寸，后来想了一下，这个是不是就是反卷积，用来上采样的，然后试了一下，可以实现，并且卷积核也是2x2。本文中使用的就是ConvTranspose2d()函数进行该操作。
  5. conv 1x1 这里就是卷积层，卷积核大小是1x1。

网络架构图，大家需要好好理解一下。

以上内容，我会在接下来的文章进行讲解。

左边部分代码讲解

导入包

import torch
import torch.nn as nn

Unet网络的左边部分和VGG16网络结构类似，都是卷积＋最大池化，因此这部分讲解，可以看我之前写的这篇文章，里面着重讲了参数如何设置，也希望基础不好的，先去这篇文章补一补。

深度学习VGG16网络构建（Pytorch代码从零到一精讲，帮助理解网络的参数定义）

第一块内容

        # 由572*572*1变成了570*570*64
        self.conv1_1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=0)
        self.relu1_1 = nn.ReLU(inplace=True)
        # 由570*570*64变成了568*568*64
        self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)  
        self.relu1_2 = nn.ReLU(inplace=True)

由Unet网络架构图，可以看出输入图像是1x572x572大小，其中的1代表的是通道数(后续可以自己更改成自己想要的，比如3通道)，输出通道是64，并且通过conv3x3，得知卷积核为3x3尺寸，并且由图片中的尺寸变成570x570，因此可以得出相关的参数值in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=0，整个图片的蓝色箭头的卷积操作都是这样，因此kernel_size=3, stride=1, padding=0可以固定了。只需要更改输入和输出通道数的大小即可。
数据维度变化：1x572x572->64x570x570->64x568x568

最大池化层1

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

最大池化的卷积核和步长都设置为2，使得输出尺寸减半，通道数不变。
数据维度变化：64x568x568->64x284x284

第二块内容

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

数据维度变化：64x284x284->128x282x282->128x280x280

最大池化层2

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

最大池化的卷积核和步长都设置为2，使得输出尺寸减半，通道数不变。
数据维度变化：128x280x280->128x140x140

Unet左边部分剩下内容，等等等等（有空补）

Unet左边部分汇总

由Unet网络架构图，可以看出，每经过一次卷积+relu操作，图像尺寸-2，可以得出padding=0（VGG16中padding=1，因此使得图像尺寸不变）；每经过一次最大池化，图像尺寸减半。

左边部分代码如下：

class Unet(nn.Module):
    def __init__(self):
        super(Unet, self).__init__()
        self.conv1_1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=0)  # 由572*572*1变成了570*570*64
        self.relu1_1 = nn.ReLU(inplace=True)
        self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)  # 由570*570*64变成了568*568*64
        self.relu1_2 = nn.ReLU(inplace=True)

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

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

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

        self.conv3_1 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=0)  # 140*140*128->138*138*256
        self.relu3_1 = nn.ReLU(inplace=True)
        self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=0)  # 138*138*256->136*136*256
        self.relu3_2 = nn.ReLU(inplace=True)

        self.maxpool_3 = nn.MaxPool2d(kernel_size=2, stride=2)  # 采用最大池化进行下采样  136*136*256->68*68*256

        self.conv4_1 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=0)  # 68*68*256->66*66*512
        self.relu4_1 = nn.ReLU(inplace=True)
        self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=0)  # 66*66*512->64*64*512
        self.relu4_2 = nn.ReLU(inplace=True)

        self.maxpool_4 = nn.MaxPool2d(kernel_size=2, stride=2)  # 采用最大池化进行下采样  64*64*512->32*32*512

        self.conv5_1 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, stride=1, padding=0)  # 32*32*512->30*30*1024
        self.relu5_1 = nn.ReLU(inplace=True)
        self.conv5_2 = nn.Conv2d(1024, 1024, kernel_size=3, stride=1, padding=0)  # 30*30*1024->28*28*1024
        self.relu5_2 = nn.ReLU(inplace=True)

前向传播函数中，你不能将所有对象都写成x，因为这个网络涉及到copy and crop，如果你全部都当作x，那么就无法复制和裁剪了，因为每次都是对最终结果进行复制，而不是中间步骤进行复制。

注意一下，下面的写法是错误的。
在这里插入图片描述
原因是因为Unet网络需要copy，因此你不能将所有层的输出都定义为x。

**正确做法应该是，在最大池化(下采样)之前，你需要有个新变量保存输出的内容，方便后续进行复制和裁剪。**这里不知道你能否听懂。代码如下：

    def forward(self, x):
        x1 = self.conv1_1(x)
        x1 = self.relu1_1(x1)
        x2 = self.conv1_2(x1)
        x2 = self.relu1_2(x2)  # 这个后续需要使用
        down1 = self.maxpool_1(x2)

        x3 = self.conv2_1(down1)
        x3 = self.relu2_1(x3)
        x4 = self.conv2_2(x3)
        x4 = self.relu2_2(x4)  # 这个后续需要使用
        down2 = self.maxpool_2(x4)

        x5 = self.conv3_1(down2)
        x5 = self.relu3_1(x5)
        x6 = self.conv3_2(x5)
        x6 = self.relu3_2(x6)  # 这个后续需要使用
        down3 = self.maxpool_3(x6)

        x7 = self.conv4_1(down3)
        x7 = self.relu4_1(x7)
        x8 = self.conv4_2(x7)
        x8 = self.relu4_2(x8)  # 这个后续需要使用
        down4 = self.maxpool_4(x8)

        x9 = self.conv5_1(down4)
        x9 = self.relu5_1(x9)
        x10 = self.conv5_2(x9)
        x10 = self.relu5_2(x10)

右边部分代码讲解

右边部分的架构如下，当然，由于Unet网络的特殊性，不能只看右半边。
在这里插入图片描述
右半部分每一层最开始的数据，由两部分组成，一部分由up-conv 2x2的上采样组成，另外一部风是由左边部分进行复制并进行中心裁剪后得到的，然后对这两部分进行拼接。
在这里插入图片描述
以最下面的绿色箭头这部分，举个例子。

最下面的是1024x28x28的图像，经过上采样(绿色箭头)，得到512x56x56的图像，尺寸扩大一倍，通道数减半。

然后看最下面的灰色的横向箭头。灰色箭头左边的图像是512x64x64，然后对其进行复制并中心裁剪(中心裁剪是看图得出的)，最后得到512x56x56，然后和刚刚说的上采样得到的图像进行拼接，最后得出1024x56x56，我这应该讲的很清楚了。我最开始的时候，这地方没有仔细看图，一直在想到底是如何得出的。

有了上面这个例子，大家应该就能理解右半部分了。
接下来就实现这个上面说的。
注意：我在init中只是定义了上采样的函数，没有涉及到copy and crop，这个我放到forward函数中实现。
下面这四个上采样，就是图片中绿色箭头部分，大家可以关注一下数据维度的变化。

上采样部分代码

# 接下来实现上采样中的up-conv2*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

数据维度变化：1024x28x28->512x56x56

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

数据维度变化：512x52x52->256x104x104

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

数据维度变化：256x100x100->128x200x200

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

数据维度变化：128x196x196->64x392x392

右半部分的卷积

右边部分的卷积层也有四个大层，每个大层经过两个卷积层。

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

数据维度变化：1024x56x56->512x54x54->512x52x52

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

数据维度变化：512x104x104->256x102x102->256x100x100

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

数据维度变化：256x200x200->128x198x198->128x196x196

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

数据维度变化：128x392x392->64x390x390->64x388x388

最后的conv 1x1

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

这个代码就是最后的conv1x1操作，输入通道数为64，输出通道数为2，卷积核大小为1，步长为1，padding=0，使得

数据维度变化：64x388x388->2x388x388

其中的输出通道数可以根据自己的需要进行更改。

copy and crop的实现，并且实现拼接操作

上面的代码是init中定义好的层，copy and crop操作没有能够直接实现的函数，因此我放到forward函数中。

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

首先我实现了一个这样的函数。这个函数可以帮助我将tensor中心裁剪成target_tensor的尺寸，符合Unet网络的需求。

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

这是第一次实现上采样并且进行拼接。

首先up1 = self.up_conv_1(x10)这段代码实现上采样，得到512x56x56的数据，x8就是经过conv4_2和relu操作后，处在左下角灰色箭头左边的数据，其维度是512x64x64，我们需要将其裁剪成up1的形状，因此可以调用self.crop_tensor函数，得到crop1，其维度和up1一样，都是512x56x56。

然后就可以进行拼接，使用torch.cat()函数对张量列表在指定维度上进行拼接，这里就是将crop1和up1进行在通道数维度上的拼接，最后拼接成1024x56x56大小的数据（由unet架构图中可以看出，crop1在前面，up1在后面）。

然后经过两次卷积后，继续上采样，copy and crop，然后进行拼接。

这是第二次的这个过程：上采样+裁剪+拼接

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

同理：经过两次卷积后，继续上采样，copy and crop，然后进行拼接。

这是第三次的这个过程：上采样+裁剪+拼接

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

同理：经过两次卷积后，继续上采样，copy and crop，然后进行拼接。

这是第四次的这个过程：上采样+裁剪+拼接

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

最终代码展示

这个代码我敢肯定，这是全网最基础、最简单的代码，但是是最适合小白的代码。

并且我配上了本代码的具体名称对应的层，比如x1就是第一个conv 3x3，大家可以自己对应着看。
在这里插入图片描述

import torch
import torch.nn as nn

class Unet(nn.Module):
    def __init__(self):
        super(Unet, self).__init__()
        self.conv1_1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=0)  # 由572*572*1变成了570*570*64
        self.relu1_1 = nn.ReLU(inplace=True)
        self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)  # 由570*570*64变成了568*568*64
        self.relu1_2 = nn.ReLU(inplace=True)

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

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

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

        self.conv3_1 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=0)  # 140*140*128->138*138*256
        self.relu3_1 = nn.ReLU(inplace=True)
        self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=0)  # 138*138*256->136*136*256
        self.relu3_2 = nn.ReLU(inplace=True)

        self.maxpool_3 = nn.MaxPool2d(kernel_size=2, stride=2)  # 采用最大池化进行下采样  136*136*256->68*68*256

        self.conv4_1 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=0)  # 68*68*256->66*66*512
        self.relu4_1 = nn.ReLU(inplace=True)
        self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=0)  # 66*66*512->64*64*512
        self.relu4_2 = nn.ReLU(inplace=True)

        self.maxpool_4 = nn.MaxPool2d(kernel_size=2, stride=2)  # 采用最大池化进行下采样  64*64*512->32*32*512

        self.conv5_1 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, stride=1, padding=0)  # 32*32*512->30*30*1024
        self.relu5_1 = nn.ReLU(inplace=True)
        self.conv5_2 = nn.Conv2d(1024, 1024, kernel_size=3, stride=1, padding=0)  # 30*30*1024->28*28*1024
        self.relu5_2 = nn.ReLU(inplace=True)

        # 接下来实现上采样中的up-conv2*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


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

        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

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

        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


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

        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


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

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

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

    def forward(self, x):
        x1 = self.conv1_1(x)
        x1 = self.relu1_1(x1)
        x2 = self.conv1_2(x1)
        x2 = self.relu1_2(x2)  # 这个后续需要使用
        down1 = self.maxpool_1(x2)

        x3 = self.conv2_1(down1)
        x3 = self.relu2_1(x3)
        x4 = self.conv2_2(x3)
        x4 = self.relu2_2(x4)  # 这个后续需要使用
        down2 = self.maxpool_2(x4)

        x5 = self.conv3_1(down2)
        x5 = self.relu3_1(x5)
        x6 = self.conv3_2(x5)
        x6 = self.relu3_2(x6)  # 这个后续需要使用
        down3 = self.maxpool_3(x6)

        x7 = self.conv4_1(down3)
        x7 = self.relu4_1(x7)
        x8 = self.conv4_2(x7)
        x8 = self.relu4_2(x8)  # 这个后续需要使用
        down4 = self.maxpool_4(x8)

        x9 = self.conv5_1(down4)
        x9 = self.relu5_1(x9)
        x10 = self.conv5_2(x9)
        x10 = self.relu5_2(x10)

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

        y1 = self.conv6_1(up_1)
        y1 = self.relu6_1(y1)
        y2 = self.conv6_2(y1)
        y2 = self.relu6_2(y2)

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

        y3 = self.conv7_1(up_2)
        y3 = self.relu7_1(y3)
        y4 = self.conv7_2(y3)
        y4 = self.relu7_2(y4)

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

        y5 = self.conv8_1(up_3)
        y5 = self.relu8_1(y5)
        y6 = self.conv8_2(y5)
        y6 = self.relu8_2(y6)

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

        y7 = self.conv9_1(up_4)
        y7 = self.relu9_1(y7)
        y8 = self.conv9_2(y7)
        y8 = self.relu9_2(y8)

        # 最后的conv1*1
        out = self.conv_10(y8)
        return out
if __name__ == '__main__':
    input_data = torch.randn([1, 1, 572, 572])
    unet = Unet()
    output = unet(input_data)
    print(output.shape)
    # torch.Size([1, 2, 388, 388])

这段代码包括空行在内，一共写了160行++，因为我是初学者，我懂初学者的痛。

网上的代码是经过封装的，因为Unet网络中涉及到很多重复的操作，大家为了简便代码，都通过定义相同操作的类，通过调用，从而减少代码量，使得代码看起来简短一些。但是这就不利于初学者去学习了，因为一般，大家都不喜欢嵌套，跳来跳去会容易晕（除非你一步一步debug）。

正是由于这一点，我才花了很多时间，来写这个博客，想着从初学者的角度，如何逐行编写网络结构。

后续也会打算从这篇文章开始，把重复操作的步骤，通过定义成类，进行调用，从而使得代码简短一些，也更加符合大佬们的写法。

我相信，经过这两天，VGG16+Unet网络架构从零到一的编写，大家的能力会得到很大的提升。

本文如有错误或者不合理的地方，请指出（笔者没有去看过原作者的paper，是根据Unet网络架构图和网上的资料进行编写的），谢谢！！

unet 网络结构
qq_40107571的博客
10-03 1万+
unet 网络结构
图像分割 UNet 是一种特定的 CNN 网络架构，其具有良好的分类、数据驱动、适应范围等优势
AI天才研究院
08-08 2775
U-Net 是 2015 年提出的一个全卷积神经网络（CNN）架构，它用于图像分割任务。该网络架构通过在两个路径上进行特征抽取并逐层融合它们来实现对图像进行精细化分割。这种结构能够有效地结合全局信息和局部信息，从而达到很好地解决分割中的信息不足的问题。相比于传统的基于区域的分割方法，U-Net 在准确率、小体积和计算量方面都有很大的优势。U-Net 的设计思想是将输入图像划分为几个互斥且尺寸相同的子区域，然后再利用卷积网络来提取图像的局部特征。
基于unet 网络对蓝莓叶片分割【数据集+代码+训练结果】
05-10
基于unet 网络对蓝莓叶片分割【数据集+代码+训练结果】 代码均为手写，全网无重复，训练自己数据很简单，只需要摆放好数据即可 数据集：蓝莓叶片分割 网络仅仅测试5个epoch，全局像素点的准确度达到0.97，dice为0.96，训练epoch加大的话，性能还会更加优越！ 代码介绍： 网络采用unet、损失函数为BCEWithLogitsLoss、优化器为Adam，评价指标为dice。代码介绍参考：https://blog.csdn.net/qq_44886601/article/details/129350075 具体参考README文件，小白均可使
unet代码以及注释，免费使用
03-24
unet代码以及注释，免费使用
【UNET】
ml_plgg的博客
04-04 1674
UNET教程
UNet_unet代码_Unet图像分割_医学图像分割_unet代码_UNet_
10-03
u-net经典神经网络模型代码，适用于医学图像分割领域，可以根据此代码搭建
基于Unet架构的2018LAUnet左心房分割挑战数据集源码分析
10-03
本项目深入分析了基于Unet架构的2018 LA Unet左心房分割挑战数据集的源码，共计包含36个文件，其中34个为Python代码文件，2个为Markdown文档。该数据集旨在实现左心房的高精度分割，采用Unet模型进行训练。
【深度学习】 UNet详解
DawnAurora_的博客
01-26 6801
我们将训练一个 UNet 模型，使用交叉熵损失函数和 Adam 优化器。训练时，输入的图像和标签将通过 DataLoader 加载。# 超参数# 数据加载# 初始化模型与优化器model = UNet(in_channels=3, out_channels=2).to(DEVICE) # 假设是二分类# 训练过程# 前向传播# 计算损失# 反向传播# 更新参数。
Unet网络架构讲解
weixin_40641178的博客
11-03 3712
Unet网络详解
热门推荐
qq_58529413的博客
07-10 4万+
Unet网络详解
UNet网络结构
lianghe77的博客
03-01 2万+
UNet是医学图像处理方面著名的图像分割网络，过程是这样的：输入是一幅图，输出是目标的分割结果。继续简化就是，一幅图，编码，或者说降采样，然后解码，也就是升采样，然后输出一个分割结果。根据结果和真实分割的差异，反向传播来训练这个分割网络。其网络结构如下： 可以看出，该网络结构主要分为三部分：下采样，上采样以及跳跃连接。首先将该网络分为左右部分来分析，左边是压缩的过程，即Encoder。通过卷积和...
Unet系列网络解析
01-15 7815
当然，也有些同学会说，这个算法中的一些思想很多人在以前也有提出，比如下采样或是多尺度的思想，但是有一个问题，在众多思路中寻找合理的方法进行组合与重构以达到更有效的结果也是一种巨大的创新和进步。在encoder操作中，采用了5个池化层（在实际应用中也有采用4个池化层的操作），在不断的下采样过程中不断的降低分辨率以获得不同尺度的图像信息，图像的信息由底层信息中的点、线、梯度等信息逐渐向高程信息中的轮廓以及更抽象的信息过度，整个网路完成了“由细到粗”特征的提取与组合，使UNet得到的信息更加全面。
UNet网络训练数据集，DRIVE
09-06
UNet网络是一种在图像分割任务中广泛使用的深度学习模型，特别是在医学影像分析领域。DRIVE（Digital Retinal Images for Vessel Extraction）数据集是专门为血管分割而设计的，旨在帮助研究者评估和改进自动血管...
深度学习融合MetaFormer的UNet网络架构设计：图像分割任务中的性能提升方案
最新发布
04-22
内容概要：本文介绍了一种结合MetaFormer模块的U-Net神经网络架构，用于图像分割任务。模型由编码器（下采样）和解码器（上采样）组成，中间加入了MetaFormer模块增强特征提取能力。编码部分包括多个Down层，每个...
UNet原理与代码实例讲解
AI天才研究院
05-31 1549
1.背景介绍 UNet是一种流行的深度学习架构，用于图像分割任务。它以其出色的性能和相对较小的计算成本而闻名，使其成为医学图像分析、自动驾驶汽车技术以及各种计算机视觉应用中的首选方法。UNet架构的成功在于其能够捕获图像的上下文信息，同时保持对细节的敏感性，这得益于其独特的编码器-解码器结构以及跨尺度特征融合的创新。
从入门到精通UNet: 让你快速掌握图像分割算法
忆~遂愿的博客
01-01 3万+
UNet是一种常用的图像分割神经网络模型，能够在医疗影像、自然图像等领域得到广泛应用。本文介绍了从入门到精通UNet的学习路径，包括基础知识的学习、代码实现及优化、数据集的准备等方面。文章中重点讲解了UNet的原理和结构，以及如何根据具体场景调整网络参数。此外，还介绍了图像预处理、数据增强等技巧，帮助读者更好地理解和应用UNet算法。通过本文的学习，读者可以快速掌握图像分割算法，为进一步深入学习和应用打下坚实的基础。
UNet 算法
2402_85799538的博客
10-18 1993
UNet 是一种卷积神经网络（CNN），最早由 Olaf Ronneberger 等人在 2015 年提出，专门用于生物医学图像分割。UNet 的结构形似字母 "U"，由一个对称的编码器-解码器架构组成。编码器负责捕捉图像的特征，解码器负责将这些特征转换为与输入图像尺寸相同的分割图像。其特点是通过跳跃连接（skip connections）结合编码器和解码器的对应层，能够有效地保留高分辨率的细节信息。
UNET详解和UNET++介绍（零基础）
浩瀚之水的专栏
11-12 4万+
一·背景介绍 背景介绍： 自2015年以来，在生物医学图像分割领域，U-Net得到了广泛的应用，目前已达到四千多次引用。至今，U-Net已经有了很多变体。目前已有许多新的卷积神经网络设计方式，但很多仍延续了U-Net的核心思想，加入了新的模块或者融入其他设计理念。 编码和解码，早在2006年就发表在了nature上.当时这个结构提出的主要作用并不是分割，而是压缩图像和去噪声.后来把这个思路被用在了图像分割的问题上，也就是现在我们看到的FCN或者U-Net结构，在它被提出的三年中，有很多很多的论文
Unet
qq_40310710的博客
09-30 1089
深入理解深度学习分割网络Ｕnet——U-Net: Convolutional Networks for Biomedical Image Segmentation super_lsl 2018-05-19 12:06:10 195054 收藏 292 分类专栏： 深度学习 版权 背景 分割 Ｍask = Function(I) 1 什么是图像分割问题呢？ 简单的来讲就是给一张图像，检测是用框出框出物体，而图像分割分出一个物体的准确轮廓。也这样考虑，给出一张图像 Ｉ，这个问题就是求一个函数，从I映
QQmlComponent: Component is not ready 是什么原因？如何解决？
10-30
QQmlComponent: Component is not ready 是Qt Quick（一种用于构建用户界面的框架）中的一个常见错误，它表示你试图在组件（Component）还没有完全加载完成或者初始化完毕的时候就去使用它。这通常是由于以下几个原因： 1. **生命周期问题**：如果你在组件实例化之前就尝试访问它的属性或调用方法，就会遇到这种错误。你需要确保在`onCompleted`信号触发后再使用组件。 ```qml QQmlComponent component; component.loadUrl(QUrl("path_to_your_qml_file.qml")); component.onCompleted.connect({ // 现在可以安全地使用component了 var instance = component.create(); }); ``` 2. **网络延迟**：如果组件通过网络请求加载，网络未响应或数据加载时间过长，可能导致此错误。确保网络请求已经成功并且数据已准备好。 3. **资源依赖**：有些组件依赖于其他资源（如图像、音频等），如果没有正确设置或者加载顺序不对，也可能引发此错误。确认资源是否都已加载，并按正确的顺序初始化。 4. **构造函数问题**：如果你在构造函数中进行了复杂的操作，可能会阻塞组件的初始化过程。尽量避免在构造函数中做耗时的操作。 解决这个问题的关键在于理解组件的生命周期，并确保在其真正准备就绪后进行交互。你可以使用`onCompleted`信号或`isReady`属性来确保这一点。
评论 82
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

knighthood2001

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值