1. # coding: utf-8
    2. """
    3. File Name:          main_1
    4. Author:             Ma
    5. Date:               2021/8/26
    6. """
    7. import torch
    8. import torch.nn as nn
    9. from torch.nn import functional as F
    11. class DoubleConv(nn.Module):
    12.     """(convolution => [BN] => ReLU) * 2"""
    13.     def __init__(self, in_channels, out_channels, mid_channels=None):
    14.         super().__init__()
    15.         if not mid_channels:
    16.             mid_channels = out_channels
    17.         self.double_conv = nn.Sequential(
    18.             nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1),
    19.             nn.BatchNorm2d(mid_channels),
    20.             nn.ReLU(inplace=True),
    21.             nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1),
    22.             nn.BatchNorm2d(out_channels),
    23.             nn.ReLU(inplace=True)
    24.         )
    26.     def forward(self, x):
    27.         return self.double_conv(x)
    29. class Down(nn.Module):
    30.     """Downscaling with maxpool then double conv"""
    31.     def __init__(self, in_channels, out_channels):
    32.         super().__init__()
    33.         self.maxpool_conv = nn.Sequential(
    34.             nn.MaxPool2d(2),
    35.             DoubleConv(in_channels, out_channels)
    36.         )
    38.     def forward(self, x):
    39.         return self.maxpool_conv(x)
    41. class Up(nn.Module):
    42.     """Upscaling then double conv"""
    44.     def __init__(self, in_channels, out_channels, bilinear=True):
    45.         super().__init__()
    47.         # if bilinear, use the normal convolutions to reduce the number of channels
    48.         if bilinear:
    49.             self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
    50.             self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
    51.         else:
    52.             self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
    53.             self.conv = DoubleConv(in_channels, out_channels)
    55.     def forward(self, x1, x2):
    56.         x1 = self.up(x1)
    57.         # input is CHW
    58.         diffy = x2.size()[2] - x1.size()[2]
    59.         diffx = x2.size()[3] - x1.size()[3]
    61.         x1 = F.pad(x1, [diffx // 2, diffx - diffx // 2,
    62.                         diffy // 2, diffy - diffy // 2])
    63.         # if you have padding issues, see
    64.         # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a
    65.         # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd
    66.         x = torch.cat([x2, x1], dim=1)
    67.         return self.conv(x)
    69. class OutConv(nn.Module):
    70.     def __init__(self, in_channels, out_channels):
    71.         super(OutConv, self).__init__()
    72.         self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
    74.     def forward(self, x):
    75.         return self.conv(x)
    77. class UNet(nn.Module):
    78.     def __init__(self, n_channels, n_classes, bilinear=True):
    79.         super(UNet, self).__init__()
    80.         self.n_channels = n_channels
    81.         self.n_classes = n_classes
    82.         self.bilinear = bilinear
    84.         self.inc = DoubleConv(n_channels, 64)
    85.         self.down1 = Down(64, 128)
    86.         self.down2 = Down(128, 256)
    87.         self.down3 = Down(256, 512)
    88.         factor = 2 if bilinear else 1
    89.         self.down4 = Down(512, 1024 // factor)
    90.         self.up1 = Up(1024, 512 // factor, bilinear)
    91.         self.up2 = Up(512, 256 // factor, bilinear)
    92.         self.up3 = Up(256, 128 // factor, bilinear)
    93.         self.up4 = Up(128, 64, bilinear)
    94.         self.outc = OutConv(64, n_classes)
    96.     def forward(self, x):
    97.         x1 = self.inc(x)
    98.         x2 = self.down1(x1)
    99.         x3 = self.down2(x2)
    100.         x4 = self.down3(x3)
    101.         x5 = self.down4(x4)
    102.         x = self.up1(x5, x4)
    103.         x = self.up2(x, x3)
    104.         x = self.up3(x, x2)
    105.         x = self.up4(x, x1)
    106.         logits = self.outc(x)
    107.         return logits
    110. if __name__ == "__main__":
    111.     image = torch.randn(1, 1, 256, 128)
    112.     model = UNet(1, 4)
    113.     pred = model(image)
    114.     print(pred.shape)