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))