---

??論文鏈接：點擊跳轉(zhuǎn)

一、簡介

??UNet網(wǎng)絡(luò)是一種用于圖像分割的卷積神經(jīng)網(wǎng)絡(luò)，其特點是采用了U型網(wǎng)絡(luò)結(jié)構(gòu)，因此稱為UNet。該網(wǎng)絡(luò)具有編碼器和解碼器結(jié)構(gòu)，兩種結(jié)構(gòu)的功能如下：

• 編碼器：逐步提取輸入圖像的特征并降低空間分辨率。
• 解碼器：通過上采樣操作將特征圖恢復(fù)到原始輸入圖像的尺寸，并逐步生成分割結(jié)果。

【CNN角度的編碼器、解碼器】以卷積神經(jīng)網(wǎng)絡(luò)為例，輸入為一個貓，進(jìn)行特征提取后輸出圖片類別。

• 編碼器：完成對輸入圖片中貓的特征提取。
• 解碼器：將特征提取的結(jié)果解碼為分類結(jié)果。

【RNN角度的編碼器、解碼器】以循環(huán)神經(jīng)網(wǎng)絡(luò)LSTM為例，輸入為一個文本，進(jìn)行特征提取再輸出

• 編碼器：將文本表示為向量并實現(xiàn)特征提取。
• 解碼器：將向量轉(zhuǎn)化為輸出。

??UNet算法的關(guān)鍵創(chuàng)新是在解碼器中引入了跳躍連接（Skip Connections），即將編碼器中的特征圖與解碼器中對應(yīng)的特征圖進(jìn)行連接。這種跳躍連接可以幫助解碼器更好地利用不同層次的特征信息，從而提高圖像分割的準(zhǔn)確性和細(xì)節(jié)保留能力。

二、網(wǎng)絡(luò)結(jié)構(gòu)

??UNet的設(shè)計思想是通過編碼器逐漸提取豐富的低級特征和高級特征，然后通過解碼器逐漸恢復(fù)分辨率，并將低級特征和高級特征進(jìn)行融合，以便獲取準(zhǔn)確且具有上下文信息的分割結(jié)果。這種U字形結(jié)構(gòu)使得UNet能夠同時利用全局（高分辨率時的特征圖）和局部信息（低分辨率時的特征圖），適用于圖像分割任務(wù)。執(zhí)行過程可粗略描述為：

輸入層 -> 編碼器（下采樣模塊 + 編碼器模塊） -> 解碼器（上采樣模塊 + 解碼器模塊）-> 輸出層。

即：

• 編碼器（Encoder）部分：
  • 輸入層：接受輸入圖像作為模型的輸入。
  • 下采樣模塊（Downsampling Block）：由一系列卷積層（通常是卷積、批歸一化和激活函數(shù)的組合）和池化層組成，用于逐漸減小特征圖的尺寸和通道數(shù)。這樣可以逐漸提取出更高級別的特征信息。
  • 編碼器模塊（Encoder Block）：重復(fù)使用多個下采樣模塊，以便逐漸減小特征圖的尺寸和通道數(shù)。每個編碼器模塊通常包含一個下采樣模塊和一個跳躍連接（Skip Connection），將上一級的特征圖連接到下一級，以便在解碼器中進(jìn)行特征融合。
• 解碼器（Decoder）部分：
  • 上采樣模塊（Upsampling Block）：由一系列上采樣操作（如反卷積或轉(zhuǎn)置卷積）和卷積操作組成，用于逐漸增加特征圖的尺寸和通道數(shù)。這樣可以逐漸恢復(fù)分辨率并且保留更多的細(xì)節(jié)信息。
  • 解碼器模塊（Decoder Block）：重復(fù)使用多個上采樣模塊，以便逐漸增加特征圖的尺寸和通道數(shù)。每個解碼器模塊通常包含一個上采樣模塊、一個跳躍連接和一個融合操作（如拼接或加權(quán)求和），用于將來自編碼器的特征圖與當(dāng)前解碼器的特征圖進(jìn)行融合。
• 輸出層：最后一層是一個卷積層，用于生成最終的分割結(jié)果。通常，輸出層的通道數(shù)等于任務(wù)中的類別數(shù)，并應(yīng)用適當(dāng)?shù)募せ詈瘮?shù)（如sigmoid或softmax），以產(chǎn)生每個像素點屬于各個類別的概率分布。

跳躍連接（skip connection）：輸入數(shù)據(jù)直接添加到網(wǎng)絡(luò)某一層輸出之上。這種設(shè)計使得信息可以更自由地流動，并且保留了原始輸入數(shù)據(jù)中的細(xì)節(jié)和語義信息。 使信息更容易傳播到后面的層次，避免了信息丟失。跳躍連接通常會通過求和操作或拼接操作來實現(xiàn)。

以圖像分類任務(wù)為例，假設(shè)我們使用卷積神經(jīng)網(wǎng)絡(luò)進(jìn)行特征提取，在每個卷積層后面都加入一個池化層來減小特征圖尺寸。然而，池化操作可能導(dǎo)致信息損失。通過添加一個跳躍連接，將原始輸入直接與最后一個池化層輸出相加或拼接起來，可以保留原始圖像中更多的細(xì)節(jié)和語義信息。

2.1編碼器部分

??編碼器部分由多個下采樣模塊（down sampling step）組成，每個下采樣模塊都由兩個卷積層（卷積核大小為3x3，且與ReLU函數(shù)配合使用。由于圖像尺寸變小，可見并未填充）和一個最大池化層（池化核大小2x2，步幅為2，將圖像尺寸收縮一半）組成，并且每一次下采樣操作后特征圖的通道數(shù)均增加一倍。
??事實上，隨著不斷執(zhí)行下采樣模塊（也成為收縮路徑），特征圖通道數(shù)隨著卷積操作也不斷增加，從而獲取了圖像的更多特征。并且在進(jìn)入下一下采樣模塊前，進(jìn)行 2x2 最大池化以獲得最大像素值，雖然丟失一些特征，但保留最大像素值。通過這種方式，可將圖像中目標(biāo)的像素按類別進(jìn)行分割。每一下采樣模塊的實現(xiàn)代碼如下：
【第一個下采樣模塊】
??卷積操作：

        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)self.relu1_1 = nn.ReLU(inplace=True)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)self.relu1_2 = nn.ReLU(inplace=True)

??池化操作

#采用最大池化進(jìn)行下采樣，圖片大小減半，通道數(shù)不變，由(568,568,64)->(284,284,64)
self.maxpool_1 = nn.MaxPool2d(kernel_size=2, stride=2)  

【第二個下采樣模塊】
??卷積操作：

        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)

??池化操作：

# 采用最大池化進(jìn)行下采樣(280,280,128)->(140,140,128)
self.maxpool_2 = nn.MaxPool2d(kernel_size=2, stride=2)  

??編碼器部分總代碼：

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)self.relu1_1 = nn.ReLU(inplace=True)self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0) self.relu1_2 = nn.ReLU(inplace=True)self.maxpool_1 = nn.MaxPool2d(kernel_size=2, stride=2)  #第二個下采樣模塊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)  #第三個下采樣模塊self.conv3_1 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=0)self.relu3_1 = nn.ReLU(inplace=True)self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=0)self.relu3_2 = nn.ReLU(inplace=True)self.maxpool_3 = nn.MaxPool2d(kernel_size=2, stride=2)#第四個下采樣模塊self.conv4_1 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=0)self.relu4_1 = nn.ReLU(inplace=True)self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=0)self.relu4_2 = nn.ReLU(inplace=True)self.maxpool_4 = nn.MaxPool2d(kernel_size=2, stride=2) #第五個下采樣模塊self.conv5_1 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, stride=1, padding=0)  # 32*32*512->30*30*1024self.relu5_1 = nn.ReLU(inplace=True)self.conv5_2 = nn.Conv2d(1024, 1024, kernel_size=3, stride=1, padding=0)self.relu5_2 = nn.ReLU(inplace=True)

在五個下采樣操作后，特征圖大小變?yōu)?span id="vxwlu0yf4" class="katex--inline">$(28,28,1024)$。

2.2解碼器部分

• up-conv 2x2：上采樣操作，通過反卷積操作實現(xiàn)。
• copy and crop：復(fù)制和裁剪，將下采樣模塊輸出的特征圖進(jìn)行復(fù)制和裁剪，方便和上采樣生成的特征圖進(jìn)行拼接。

??下采樣操作后，雖然使用最大池化運算丟失了部分細(xì)節(jié)信息，但模型已經(jīng)得到了所有類的像素特征值。而在上采樣中，模型將特征圖通過具有相同級別的上采樣過濾器來將特征圖恢復(fù)到原始的分辨率大小，并通過跳躍連接的方式將下采樣模塊輸出的每個特征圖都添加到上采樣模塊的相應(yīng)特征層中，從而保留特征。最后，通過完整的特征圖即可定位每個類在圖像中存在的位置，從而實現(xiàn)類別的定位。

??第一個上采樣模塊細(xì)節(jié)如下：

??最下面的下采樣模塊輸出特征圖大小為$(28,28,1024)$，經(jīng)過反卷積操作（up-conv 2x2）得到大小為$(56,56,512)$的特征圖，即尺寸擴大一倍，通道數(shù)減半。之后，將左側(cè)下采樣模塊輸出的$(64,64,512)$圖像進(jìn)行復(fù)制并中心裁剪（copy and crop）同樣轉(zhuǎn)化為$(56,56,512)$大小，并與之拼接得到$(56,56,1024)$大小的特征圖（可見，此拼接僅是通道方向的拼接）。代碼實現(xiàn)：

# 上采樣中反卷積操作的實現(xiàn)
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

同理也可得到其他反卷積操作的實現(xiàn)：

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.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.up_conv_4 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=2, stride=2, padding=0) # 196*196*128->392*392*64

??右半部分卷積操作的代碼實現(xiàn)：
【第一次卷積】

        self.conv6_1 = nn.Conv2d(in_channels=1024, out_channels=512, kernel_size=3, stride=1, padding=0)  # 56*56*1024->54*54*512self.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*512self.relu6_2 = nn.ReLU(inplace=True)

【第二次卷積】

        self.conv7_1 = nn.Conv2d(in_channels=512, out_channels=256, kernel_size=3, stride=1, padding=0)  # 104*104*512->102*102*256self.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*256self.relu7_2 = nn.ReLU(inplace=True)

【第三次卷積】

        self.conv8_1 = nn.Conv2d(in_channels=256, out_channels=128, kernel_size=3, stride=1, padding=0)  # 200*200*256->198*198*128self.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*128self.relu8_2 = nn.ReLU(inplace=True)

【第四次卷積】

        self.conv9_1 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=0)  # 392*392*128->390*390*64self.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*64self.relu9_2 = nn.ReLU(inplace=True)

【第五次卷積】

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

??中心裁剪操作的實現(xiàn)：

    # 中心裁剪，def crop_tensor(self, tensor, target_tensor):target_size = target_tensor.size()[2]tensor_size = tensor.size()[2]delta = tensor_size - target_sizedelta = delta // 2# 如果原始張量的尺寸為10，而delta為2，那么"delta:tensor_size - delta"將截取從索引2到索引8的部分，長度為6，以使得截取后的張量尺寸變?yōu)?。return tensor[:, :, delta:tensor_size - delta, delta:tensor_size - delta]

【第一次上采樣+拼接】

        # 第一次上采樣，需要"Copy and crop"（復(fù)制并裁剪）up1 = self.up_conv_1(x10)  # 得到56*56*512# 需要對x8進(jìn)行裁剪，從中心往外裁剪crop1 = self.crop_tensor(x8, up1)# 拼接操作up_1 = torch.cat([crop1, up1], dim=1)

【第二次上采樣+拼接】

		# 第二次上采樣，需要"Copy and crop"（復(fù)制并裁剪）up2 = self.up_conv_2(y2)# 需要對x6進(jìn)行裁剪，從中心往外裁剪crop2 = self.crop_tensor(x6, up2)# 拼接up_2 = torch.cat([crop2, up2], dim=1)

【第三次上采樣+拼接】

        # 第三次上采樣，需要"Copy and crop"（復(fù)制并裁剪）up3 = self.up_conv_3(y4)# 需要對x4進(jìn)行裁剪，從中心往外裁剪crop3 = self.crop_tensor(x4, up3)up_3 = torch.cat([crop3, up3], dim=1)

【第四次上采樣+拼接】

        # 第四次上采樣，需要"Copy and crop"（復(fù)制并裁剪）up4 = self.up_conv_4(y6)# 需要對x2進(jìn)行裁剪，從中心往外裁剪crop4 = self.crop_tensor(x2, up4)up_4 = torch.cat([crop4, up4], dim=1)

2.3完整代碼

import torch
import torch.nn as nnclass 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*64self.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*64self.relu1_2 = nn.ReLU(inplace=True)self.maxpool_1 = nn.MaxPool2d(kernel_size=2, stride=2)  # 采用最大池化進(jìn)行下采樣，圖片大小減半，通道數(shù)不變，由568*568*64變成284*284*64self.conv2_1 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=0)  # 284*284*64->282*282*128self.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*128self.relu2_2 = nn.ReLU(inplace=True)self.maxpool_2 = nn.MaxPool2d(kernel_size=2, stride=2)  # 采用最大池化進(jìn)行下采樣  280*280*128->140*140*128self.conv3_1 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=0)  # 140*140*128->138*138*256self.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*256self.relu3_2 = nn.ReLU(inplace=True)self.maxpool_3 = nn.MaxPool2d(kernel_size=2, stride=2)  # 采用最大池化進(jìn)行下采樣  136*136*256->68*68*256self.conv4_1 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=0)  # 68*68*256->66*66*512self.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*512self.relu4_2 = nn.ReLU(inplace=True)self.maxpool_4 = nn.MaxPool2d(kernel_size=2, stride=2)  # 采用最大池化進(jìn)行下采樣  64*64*512->32*32*512self.conv5_1 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, stride=1, padding=0)  # 32*32*512->30*30*1024self.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*1024self.relu5_2 = nn.ReLU(inplace=True)# 接下來實現(xiàn)上采樣中的up-conv2*2self.up_conv_1 = nn.ConvTranspose2d(in_channels=1024, out_channels=512, kernel_size=2, stride=2, padding=0) # 28*28*1024->56*56*512self.conv6_1 = nn.Conv2d(in_channels=1024, out_channels=512, kernel_size=3, stride=1, padding=0)  # 56*56*1024->54*54*512self.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*512self.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*256self.conv7_1 = nn.Conv2d(in_channels=512, out_channels=256, kernel_size=3, stride=1, padding=0)  # 104*104*512->102*102*256self.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*256self.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*128self.conv8_1 = nn.Conv2d(in_channels=256, out_channels=128, kernel_size=3, stride=1, padding=0)  # 200*200*256->198*198*128self.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*128self.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*64self.conv9_1 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=0)  # 392*392*128->390*390*64self.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*64self.relu9_2 = nn.ReLU(inplace=True)# 最后的conv1*1self.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_sizedelta = delta // 2# 如果原始張量的尺寸為10，而delta為2，那么"delta:tensor_size - delta"將截取從索引2到索引8的部分，長度為6，以使得截取后的張量尺寸變?yōu)?。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)  # 這個后續(xù)需要使用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)  # 這個后續(xù)需要使用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)  # 這個后續(xù)需要使用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)  # 這個后續(xù)需要使用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"（復(fù)制并裁剪）up1 = self.up_conv_1(x10)  # 得到56*56*512# 需要對x8進(jìn)行裁剪，從中心往外裁剪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"（復(fù)制并裁剪）up2 = self.up_conv_2(y2)# 需要對x6進(jìn)行裁剪，從中心往外裁剪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"（復(fù)制并裁剪）up3 = self.up_conv_3(y4)# 需要對x4進(jìn)行裁剪，從中心往外裁剪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"（復(fù)制并裁剪）up4 = self.up_conv_4(y6)# 需要對x2進(jìn)行裁剪，從中心往外裁剪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*1out = 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])

三、實戰(zhàn)案例

??準(zhǔn)備復(fù)現(xiàn)論文：點擊跳轉(zhuǎn)、點擊跳轉(zhuǎn)
??準(zhǔn)備復(fù)現(xiàn)項目：點擊跳轉(zhuǎn)