def __init__(self, in_channels=1, n_classes=2, feature_scale=2, is_deconv=True, is_batchnorm=True):
super(UNet, self).__init__()
self.in_channels = in_channels
self.feature_scale = feature_scale
self.is_deconv = is_deconv
self.is_batchnorm = is_batchnorm
filters = [64, 128, 256, 512, 1024]
filters = [int(x / self.feature_scale) for x in filters]
# downsampling
self.maxpool = nn.MaxPool2d(kernel_size=2)
self.conv1 = unetConv2(self.in_channels, filters[0], self.is_batchnorm)
self.conv2 = unetConv2(filters[0], filters[1], self.is_batchnorm)
self.conv3 = unetConv2(filters[1], filters[2], self.is_batchnorm)
self.conv4 = unetConv2(filters[2], filters[3], self.is_batchnorm)
self.center = unetConv2(filters[3], filters[4], self.is_batchnorm)
# upsampling
self.up_concat4 = unetUp(filters[4], filters[3], self.is_deconv)
self.up_concat3 = unetUp(filters[3], filters[2], self.is_deconv)
self.up_concat2 = unetUp(filters[2], filters[1], self.is_deconv)
self.up_concat1 = unetUp(filters[1], filters[0], self.is_deconv)
# final conv (without any concat)
self.final = nn.Conv2d(filters[0], n_classes, 1)
# initialise weights
for m in self.modules():
if isinstance(m, nn.Conv2d):
init_weights(m, init_type='kaiming')
elif isinstance(m, nn.BatchNorm2d):
init_weights(m, init_type='kaiming')
def __init__(self,
in_channels=3,
n_classes=2,
feature_scale=2,
is_deconv=True,
is_batchnorm=True,
is_ds=True):
super(UNet_Nested, self).__init__()
self.in_channels = in_channels
self.feature_scale = feature_scale
self.is_deconv = is_deconv
self.is_batchnorm = is_batchnorm
self.is_ds = is_ds
filters = [64, 128, 256, 512, 1024]
filters = [int(x / self.feature_scale) for x in filters]
# downsampling
self.maxpool = nn.MaxPool2d(kernel_size=2)
self.conv00 = unetConv2(self.in_channels, filters[0],
self.is_batchnorm)
self.conv10 = unetConv2(filters[0], filters[1], self.is_batchnorm)
self.conv20 = unetConv2(filters[1], filters[2], self.is_batchnorm)
self.conv30 = unetConv2(filters[2], filters[3], self.is_batchnorm)
self.conv40 = unetConv2(filters[3], filters[4], self.is_batchnorm)
# upsampling
self.up_concat01 = unetUp(filters[1], filters[0], self.is_deconv)
self.up_concat11 = unetUp(filters[2], filters[1], self.is_deconv)
self.up_concat21 = unetUp(filters[3], filters[2], self.is_deconv)
self.up_concat31 = unetUp(filters[4], filters[3], self.is_deconv)
self.up_concat02 = unetUp(filters[1], filters[0], self.is_deconv, 3)
self.up_concat12 = unetUp(filters[2], filters[1], self.is_deconv, 3)
self.up_concat22 = unetUp(filters[3], filters[2], self.is_deconv, 3)
self.up_concat03 = unetUp(filters[1], filters[0], self.is_deconv, 4)
self.up_concat13 = unetUp(filters[2], filters[1], self.is_deconv, 4)
self.up_concat04 = unetUp(filters[1], filters[0], self.is_deconv, 5)
# final conv (without any concat)
self.final_1 = nn.Conv2d(filters[0], n_classes, 1)
self.final_2 = nn.Conv2d(filters[0], n_classes, 1)
self.final_3 = nn.Conv2d(filters[0], n_classes, 1)
self.final_4 = nn.Conv2d(filters[0], n_classes, 1)
# initialise weights
for m in self.modules():
if isinstance(m, nn.Conv2d):
init_weights(m, init_type='kaiming')
elif isinstance(m, nn.BatchNorm2d):
init_weights(m, init_type='kaiming')
def __init__(self, in_channels, n_classes, channels=64, is_deconv=False, is_batchnorm=True):
super(CNN, self).__init__()
self.is_deconv = is_deconv
self.in_channels = in_channels
self.is_batchnorm = is_batchnorm
self.channels = channels
self.n_classes=n_classes
# downsampling
self.conv1 = unetConv2(self.in_channels, self.channels, self.is_batchnorm)
self.conv2 = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.conv3 = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.outconv1 = nn.Conv2d(self.channels, self.n_classes, 3, padding=1)
def __init__(self, in_channels, n_classes, channels=128, is_maxpool=True, is_batchnorm=True):
super(IMN, self).__init__()
self.is_maxpool = is_maxpool
self.in_channels = in_channels
self.is_batchnorm = is_batchnorm
self.channels = channels
self.n_classes=n_classes
# MNET
self.M_conv1 = unetConv2(in_channels, self.channels, self.is_batchnorm)
self.M_up1 = nn.ConvTranspose2d(self.channels,self.channels, kernel_size=2, stride=2, padding=0)
self.M_conv2 = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.M_up2 = nn.ConvTranspose2d(self.channels, self.channels, kernel_size=2, stride=2, padding=0)
self.M_center = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.M_down2 = mnetDown(self.channels*2, self.channels, 2,self.is_maxpool)
self.M_down1 = mnetDown(self.channels*2, self.channels, 2, self.is_maxpool)
self.outconv1 = nn.Conv2d(self.channels, self.n_classes, kernel_size=3, padding=1)
def __init__(self, in_channels, n_classes, channels=128, is_deconv=False, is_batchnorm=True):
super(UNet, self).__init__()
self.is_deconv = is_deconv
self.in_channels = in_channels
self.is_batchnorm = is_batchnorm
self.channels = channels
self.n_classes=n_classes
# downsampling
self.conv1 = unetConv2(in_channels, self.channels, self.is_batchnorm)
self.maxpool1 = nn.MaxPool2d(kernel_size=2)
self.conv2 = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.maxpool2 = nn.MaxPool2d(kernel_size=2)
self.center = unetConv2(self.channels, self.channels, self.is_batchnorm)
# upsampling
self.up_concat2 = unetUp(self.channels*2, self.channels, 2, self.is_deconv)
self.up_concat1 = unetUp(self.channels*2, self.channels, 2, self.is_deconv)
#
self.outconv1 = nn.Conv2d(self.channels, self.n_classes, 3, padding=1)
def __init__(self, in_channels, n_classes, channels=128, is_maxpool=True,is_deconv=False, is_batchnorm=True):
super(MUNet, self).__init__()
self.is_maxpool = is_maxpool
self.in_channels = in_channels
self.is_batchnorm = is_batchnorm
self.is_deconv=is_deconv
self.channels = channels
self.n_classes=n_classes
# MNET
self.M_conv1 = unetConv2(in_channels, self.channels, self.is_batchnorm)
self.M_up1 = nn.ConvTranspose2d(self.channels,self.channels, kernel_size=2, stride=2, padding=0)
self.M_conv2 = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.M_up2 = nn.ConvTranspose2d(self.channels, self.channels, kernel_size=2, stride=2, padding=0)
self.M_center = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.M_down2 = mnetDown(self.channels*2, self.channels, 2,self.is_maxpool)
self.M_down1 = mnetDown(self.channels*2, self.channels, 2, self.is_maxpool)
# UNET
self.U_conv1 = unetConv2(in_channels, self.channels, self.is_batchnorm)
self.U_down1 = nn.MaxPool2d(kernel_size=2)
self.U_conv2 = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.U_down2 = nn.MaxPool2d(kernel_size=2)
self.U_center = unetConv2(self.channels, self.channels, self.is_batchnorm)
self.U_up2 = unetUp(self.channels*2, self.channels, 2, self.is_deconv)
self.U_up1 = unetUp(self.channels*2, self.channels, 2, self.is_deconv)
#output
self.outconv1 = nn.Conv2d(self.channels*2, self.channels, 3, padding=1)
self.outconv2 = nn.Conv2d(self.channels, self.n_classes, 3, padding=1)
def __init__(self,in_channels, n_classes, channels=128):
super(DUNet, self).__init__()
self.channels = channels
self.n_classes=n_classes
self.is_batchnorm = False
self.in_channels = in_channels
# self.inc = deform_inconv(n_channels, 64 // downsize_nb_filters_factor)
self.inc = unetConv2(in_channels, self.channels, self.is_batchnorm)
self.down1 = deform_down(self.channels, self.channels)
self.down2 = deform_down(self.channels, self.channels)
self.up3 = deform_up(self.channels*2, self.channels)
self.up4 = deform_up(self.channels*2, self.channels)
self.outc = nn.Conv2d(self.channels+1, n_classes, 1)
def __init__(self,
in_channels=32,
n_classes=32,
feature_scale=4,
is_deconv=False,
is_batchnorm=True):
super(UNet_2Plus, self).__init__()
self.is_deconv = is_deconv
self.in_channels = in_channels
self.is_batchnorm = is_batchnorm
self.feature_scale = feature_scale
filters = [8, 16, 32, 64, 128]
# downsampling
self.conv00 = unetConv2(self.in_channels, filters[0],
self.is_batchnorm)
self.maxpool0 = nn.MaxPool2d(kernel_size=2)
self.conv10 = unetConv2(filters[0], filters[1], self.is_batchnorm)
self.maxpool1 = nn.MaxPool2d(kernel_size=2)
self.conv20 = unetConv2(filters[1], filters[2], self.is_batchnorm)
self.maxpool2 = nn.MaxPool2d(kernel_size=2)
self.conv30 = unetConv2(filters[2], filters[3], self.is_batchnorm)
self.maxpool3 = nn.MaxPool2d(kernel_size=2)
self.conv40 = unetConv2(filters[3], filters[4], self.is_batchnorm)
self.getfeature = unetConv2(filters[4], filters[3], self.is_batchnorm)
# upsampling
self.up_concat01 = unetUp_origin(filters[1], filters[0],
self.is_deconv)
self.up_concat11 = unetUp_origin(filters[2], filters[1],
self.is_deconv)
self.up_concat21 = unetUp_origin(filters[3], filters[2],
self.is_deconv)
self.up_concat31 = unetUp_origin(filters[4], filters[3],
self.is_deconv)
self.up_concat02 = unetUp_origin(filters[1], filters[0],
self.is_deconv, 3)
self.up_concat12 = unetUp_origin(filters[2], filters[1],
self.is_deconv, 3)
self.up_concat22 = unetUp_origin(filters[3], filters[2],
self.is_deconv, 3)
self.up_concat03 = unetUp_origin(filters[1], filters[0],
self.is_deconv, 4)
self.up_concat13 = unetUp_origin(filters[2], filters[1],
self.is_deconv, 4)
self.up_concat04 = unetUp_origin(filters[1], filters[0],
self.is_deconv, 5)
# final conv (without any concat)
self.final_1 = nn.Conv2d(filters[0], n_classes, 1)
self.final_2 = nn.Conv2d(filters[0], n_classes, 1)
self.final_3 = nn.Conv2d(filters[0], n_classes, 1)
self.final_4 = nn.Conv2d(filters[0], n_classes, 1)
self.skip_add = nn.quantized.FloatFunctional()
# initialise weights
for m in self.modules():
if isinstance(m, nn.Conv2d):
init_weights(m, init_type='kaiming')
elif isinstance(m, nn.BatchNorm2d):
init_weights(m, init_type='kaiming')
def __init__(self,
in_channels=3,
n_classes=1,
feature_scale=4,
is_deconv=True,
is_batchnorm=True):
super(UNet_3Plus_DeepSup_CGM, self).__init__()
self.is_deconv = is_deconv
self.in_channels = in_channels
self.is_batchnorm = is_batchnorm
self.feature_scale = feature_scale
filters = [64, 128, 256, 512, 1024]
## -------------Encoder--------------
self.conv1 = unetConv2(self.in_channels, filters[0], self.is_batchnorm)
self.maxpool1 = nn.MaxPool2d(kernel_size=2)
self.conv2 = unetConv2(filters[0], filters[1], self.is_batchnorm)
self.maxpool2 = nn.MaxPool2d(kernel_size=2)
self.conv3 = unetConv2(filters[1], filters[2], self.is_batchnorm)
self.maxpool3 = nn.MaxPool2d(kernel_size=2)
self.conv4 = unetConv2(filters[2], filters[3], self.is_batchnorm)
self.maxpool4 = nn.MaxPool2d(kernel_size=2)
self.conv5 = unetConv2(filters[3], filters[4], self.is_batchnorm)
## -------------Decoder--------------
self.CatChannels = filters[0]
self.CatBlocks = 5
self.UpChannels = self.CatChannels * self.CatBlocks
'''stage 4d'''
# h1->320*320, hd4->40*40, Pooling 8 times
self.h1_PT_hd4 = nn.MaxPool2d(8, 8, ceil_mode=True)
self.h1_PT_hd4_conv = nn.Conv2d(filters[0],
self.CatChannels,
3,
padding=1)
self.h1_PT_hd4_bn = nn.BatchNorm2d(self.CatChannels)
self.h1_PT_hd4_relu = nn.ReLU(inplace=True)
# h2->160*160, hd4->40*40, Pooling 4 times
self.h2_PT_hd4 = nn.MaxPool2d(4, 4, ceil_mode=True)
self.h2_PT_hd4_conv = nn.Conv2d(filters[1],
self.CatChannels,
3,
padding=1)
self.h2_PT_hd4_bn = nn.BatchNorm2d(self.CatChannels)
self.h2_PT_hd4_relu = nn.ReLU(inplace=True)
# h3->80*80, hd4->40*40, Pooling 2 times
self.h3_PT_hd4 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.h3_PT_hd4_conv = nn.Conv2d(filters[2],
self.CatChannels,
3,
padding=1)
self.h3_PT_hd4_bn = nn.BatchNorm2d(self.CatChannels)
self.h3_PT_hd4_relu = nn.ReLU(inplace=True)
# h4->40*40, hd4->40*40, Concatenation
self.h4_Cat_hd4_conv = nn.Conv2d(filters[3],
self.CatChannels,
3,
padding=1)
self.h4_Cat_hd4_bn = nn.BatchNorm2d(self.CatChannels)
self.h4_Cat_hd4_relu = nn.ReLU(inplace=True)
# hd5->20*20, hd4->40*40, Upsample 2 times
self.hd5_UT_hd4 = nn.Upsample(scale_factor=2, mode='bilinear') # 14*14
self.hd5_UT_hd4_conv = nn.Conv2d(filters[4],
self.CatChannels,
3,
padding=1)
self.hd5_UT_hd4_bn = nn.BatchNorm2d(self.CatChannels)
self.hd5_UT_hd4_relu = nn.ReLU(inplace=True)
# fusion(h1_PT_hd4, h2_PT_hd4, h3_PT_hd4, h4_Cat_hd4, hd5_UT_hd4)
self.conv4d_1 = nn.Conv2d(self.UpChannels,
self.UpChannels,
3,
padding=1) # 16
self.bn4d_1 = nn.BatchNorm2d(self.UpChannels)
self.relu4d_1 = nn.ReLU(inplace=True)
'''stage 3d'''
# h1->320*320, hd3->80*80, Pooling 4 times
self.h1_PT_hd3 = nn.MaxPool2d(4, 4, ceil_mode=True)
self.h1_PT_hd3_conv = nn.Conv2d(filters[0],
self.CatChannels,
3,
padding=1)
self.h1_PT_hd3_bn = nn.BatchNorm2d(self.CatChannels)
self.h1_PT_hd3_relu = nn.ReLU(inplace=True)
# h2->160*160, hd3->80*80, Pooling 2 times
self.h2_PT_hd3 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.h2_PT_hd3_conv = nn.Conv2d(filters[1],
self.CatChannels,
3,
padding=1)
self.h2_PT_hd3_bn = nn.BatchNorm2d(self.CatChannels)
self.h2_PT_hd3_relu = nn.ReLU(inplace=True)
# h3->80*80, hd3->80*80, Concatenation
self.h3_Cat_hd3_conv = nn.Conv2d(filters[2],
self.CatChannels,
3,
padding=1)
self.h3_Cat_hd3_bn = nn.BatchNorm2d(self.CatChannels)
self.h3_Cat_hd3_relu = nn.ReLU(inplace=True)
# hd4->40*40, hd4->80*80, Upsample 2 times
self.hd4_UT_hd3 = nn.Upsample(scale_factor=2, mode='bilinear') # 14*14
self.hd4_UT_hd3_conv = nn.Conv2d(self.UpChannels,
self.CatChannels,
3,
padding=1)
self.hd4_UT_hd3_bn = nn.BatchNorm2d(self.CatChannels)
self.hd4_UT_hd3_relu = nn.ReLU(inplace=True)
# hd5->20*20, hd4->80*80, Upsample 4 times
self.hd5_UT_hd3 = nn.Upsample(scale_factor=4, mode='bilinear') # 14*14
self.hd5_UT_hd3_conv = nn.Conv2d(filters[4],
self.CatChannels,
3,
padding=1)
self.hd5_UT_hd3_bn = nn.BatchNorm2d(self.CatChannels)
self.hd5_UT_hd3_relu = nn.ReLU(inplace=True)
# fusion(h1_PT_hd3, h2_PT_hd3, h3_Cat_hd3, hd4_UT_hd3, hd5_UT_hd3)
self.conv3d_1 = nn.Conv2d(self.UpChannels,
self.UpChannels,
3,
padding=1) # 16
self.bn3d_1 = nn.BatchNorm2d(self.UpChannels)
self.relu3d_1 = nn.ReLU(inplace=True)
'''stage 2d '''
# h1->320*320, hd2->160*160, Pooling 2 times
self.h1_PT_hd2 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.h1_PT_hd2_conv = nn.Conv2d(filters[0],
self.CatChannels,
3,
padding=1)
self.h1_PT_hd2_bn = nn.BatchNorm2d(self.CatChannels)
self.h1_PT_hd2_relu = nn.ReLU(inplace=True)
# h2->160*160, hd2->160*160, Concatenation
self.h2_Cat_hd2_conv = nn.Conv2d(filters[1],
self.CatChannels,
3,
padding=1)
self.h2_Cat_hd2_bn = nn.BatchNorm2d(self.CatChannels)
self.h2_Cat_hd2_relu = nn.ReLU(inplace=True)
# hd3->80*80, hd2->160*160, Upsample 2 times
self.hd3_UT_hd2 = nn.Upsample(scale_factor=2, mode='bilinear') # 14*14
self.hd3_UT_hd2_conv = nn.Conv2d(self.UpChannels,
self.CatChannels,
3,
padding=1)
self.hd3_UT_hd2_bn = nn.BatchNorm2d(self.CatChannels)
self.hd3_UT_hd2_relu = nn.ReLU(inplace=True)
# hd4->40*40, hd2->160*160, Upsample 4 times
self.hd4_UT_hd2 = nn.Upsample(scale_factor=4, mode='bilinear') # 14*14
self.hd4_UT_hd2_conv = nn.Conv2d(self.UpChannels,
self.CatChannels,
3,
padding=1)
self.hd4_UT_hd2_bn = nn.BatchNorm2d(self.CatChannels)
self.hd4_UT_hd2_relu = nn.ReLU(inplace=True)
# hd5->20*20, hd2->160*160, Upsample 8 times
self.hd5_UT_hd2 = nn.Upsample(scale_factor=8, mode='bilinear') # 14*14
self.hd5_UT_hd2_conv = nn.Conv2d(filters[4],
self.CatChannels,
3,
padding=1)
self.hd5_UT_hd2_bn = nn.BatchNorm2d(self.CatChannels)
self.hd5_UT_hd2_relu = nn.ReLU(inplace=True)
# fusion(h1_PT_hd2, h2_Cat_hd2, hd3_UT_hd2, hd4_UT_hd2, hd5_UT_hd2)
self.conv2d_1 = nn.Conv2d(self.UpChannels,
self.UpChannels,
3,
padding=1) # 16
self.bn2d_1 = nn.BatchNorm2d(self.UpChannels)
self.relu2d_1 = nn.ReLU(inplace=True)
'''stage 1d'''
# h1->320*320, hd1->320*320, Concatenation
self.h1_Cat_hd1_conv = nn.Conv2d(filters[0],
self.CatChannels,
3,
padding=1)
self.h1_Cat_hd1_bn = nn.BatchNorm2d(self.CatChannels)
self.h1_Cat_hd1_relu = nn.ReLU(inplace=True)
# hd2->160*160, hd1->320*320, Upsample 2 times
self.hd2_UT_hd1 = nn.Upsample(scale_factor=2, mode='bilinear') # 14*14
self.hd2_UT_hd1_conv = nn.Conv2d(self.UpChannels,
self.CatChannels,
3,
padding=1)
self.hd2_UT_hd1_bn = nn.BatchNorm2d(self.CatChannels)
self.hd2_UT_hd1_relu = nn.ReLU(inplace=True)
# hd3->80*80, hd1->320*320, Upsample 4 times
self.hd3_UT_hd1 = nn.Upsample(scale_factor=4, mode='bilinear') # 14*14
self.hd3_UT_hd1_conv = nn.Conv2d(self.UpChannels,
self.CatChannels,
3,
padding=1)
self.hd3_UT_hd1_bn = nn.BatchNorm2d(self.CatChannels)
self.hd3_UT_hd1_relu = nn.ReLU(inplace=True)
# hd4->40*40, hd1->320*320, Upsample 8 times
self.hd4_UT_hd1 = nn.Upsample(scale_factor=8, mode='bilinear') # 14*14
self.hd4_UT_hd1_conv = nn.Conv2d(self.UpChannels,
self.CatChannels,
3,
padding=1)
self.hd4_UT_hd1_bn = nn.BatchNorm2d(self.CatChannels)
self.hd4_UT_hd1_relu = nn.ReLU(inplace=True)
# hd5->20*20, hd1->320*320, Upsample 16 times
self.hd5_UT_hd1 = nn.Upsample(scale_factor=16,
mode='bilinear') # 14*14
self.hd5_UT_hd1_conv = nn.Conv2d(filters[4],
self.CatChannels,
3,
padding=1)
self.hd5_UT_hd1_bn = nn.BatchNorm2d(self.CatChannels)
self.hd5_UT_hd1_relu = nn.ReLU(inplace=True)
# fusion(h1_Cat_hd1, hd2_UT_hd1, hd3_UT_hd1, hd4_UT_hd1, hd5_UT_hd1)
self.conv1d_1 = nn.Conv2d(self.UpChannels,
self.UpChannels,
3,
padding=1) # 16
self.bn1d_1 = nn.BatchNorm2d(self.UpChannels)
self.relu1d_1 = nn.ReLU(inplace=True)
# -------------Bilinear Upsampling--------------
self.upscore6 = nn.Upsample(scale_factor=32, mode='bilinear') ###
self.upscore5 = nn.Upsample(scale_factor=16, mode='bilinear')
self.upscore4 = nn.Upsample(scale_factor=8, mode='bilinear')
self.upscore3 = nn.Upsample(scale_factor=4, mode='bilinear')
self.upscore2 = nn.Upsample(scale_factor=2, mode='bilinear')
# DeepSup
self.outconv1 = nn.Conv2d(self.UpChannels, n_classes, 3, padding=1)
self.outconv2 = nn.Conv2d(self.UpChannels, n_classes, 3, padding=1)
self.outconv3 = nn.Conv2d(self.UpChannels, n_classes, 3, padding=1)
self.outconv4 = nn.Conv2d(self.UpChannels, n_classes, 3, padding=1)
self.outconv5 = nn.Conv2d(filters[4], n_classes, 3, padding=1)
self.cls = nn.Sequential(nn.Dropout(p=0.5),
nn.Conv2d(filters[4], 2, 1),
nn.AdaptiveMaxPool2d(1), nn.Sigmoid())
# initialise weights
for m in self.modules():
if isinstance(m, nn.Conv2d):
init_weights(m, init_type='kaiming')
elif isinstance(m, nn.BatchNorm2d):
init_weights(m, init_type='kaiming')
