Resources

U-Net Architecture.

Reference implementation of the standard U-Net architecture used during experiments.


class DoubleConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(DoubleConv, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels,
                      kernel_size=3, stride=1,
                      padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels,
                      kernel_size=3, stride=1,
                      padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
        )

    def forward(self, x):
        return self.conv(x)


class UNET(nn.Module):
    def __init__(self, num_classes=1,
                 input_channels=3, **kwargs):
        super().__init__()
        nb_filter = [32, 64, 128, 256, 512]
        self.pool = nn.MaxPool2d(2, 2)

        # Encoder
        self.conv0_0 = DoubleConv(input_channels,
                                   nb_filter[0])
        self.conv1_0 = DoubleConv(nb_filter[0],
                                   nb_filter[1])
        self.conv2_0 = DoubleConv(nb_filter[1],
                                   nb_filter[2])
        self.conv3_0 = DoubleConv(nb_filter[2],
                                   nb_filter[3])
        self.conv4_0 = DoubleConv(nb_filter[3],
                                   nb_filter[4])

        # Bottleneck
        self.bottleneck = DoubleConv(nb_filter[4],
                                      nb_filter[4] * 2)

        # Decoder
        self.upconv4 = nn.ConvTranspose2d(
            nb_filter[4] * 2, nb_filter[4],
            kernel_size=2, stride=2)
        self.conv4_1 = DoubleConv(
            nb_filter[4] * 2, nb_filter[4])

        self.upconv3 = nn.ConvTranspose2d(
            nb_filter[4], nb_filter[3],
            kernel_size=2, stride=2)
        self.conv3_2 = DoubleConv(
            nb_filter[3] * 2, nb_filter[3])

        self.upconv2 = nn.ConvTranspose2d(
            nb_filter[3], nb_filter[2],
            kernel_size=2, stride=2)
        self.conv2_3 = DoubleConv(
            nb_filter[2] * 2, nb_filter[2])

        self.upconv1 = nn.ConvTranspose2d(
            nb_filter[2], nb_filter[1],
            kernel_size=2, stride=2)
        self.conv1_4 = DoubleConv(
            nb_filter[1] * 2, nb_filter[1])

        self.upconv0 = nn.ConvTranspose2d(
            nb_filter[1], nb_filter[0],
            kernel_size=2, stride=2)
        self.conv0_5 = DoubleConv(
            nb_filter[0] * 2, nb_filter[0])

        self.final = nn.Conv2d(
            nb_filter[0], num_classes, kernel_size=1)

    def forward(self, x):
        x0_0 = self.conv0_0(x)
        x1_0 = self.conv1_0(self.pool(x0_0))
        x2_0 = self.conv2_0(self.pool(x1_0))
        x3_0 = self.conv3_0(self.pool(x2_0))
        x4_0 = self.conv4_0(self.pool(x3_0))
        x5_0 = self.bottleneck(self.pool(x4_0))

        x4_1 = self.conv4_1(
            torch.cat([self.upconv4(x5_0), x4_0], dim=1))
        x3_2 = self.conv3_2(
            torch.cat([self.upconv3(x4_1), x3_0], dim=1))
        x2_3 = self.conv2_3(
            torch.cat([self.upconv2(x3_2), x2_0], dim=1))
        x1_4 = self.conv1_4(
            torch.cat([self.upconv1(x2_3), x1_0], dim=1))
        x0_5 = self.conv0_5(
            torch.cat([self.upconv0(x1_4), x0_0], dim=1))

        return torch.sigmoid(self.final(x0_5))
← Return to ArticleBrowse All Resources →