def build_conv_block(dim, norm_layer, use_dropout, use_bias):
"""
Construct a convolutional block.
:param dim: the number of channels in the conv layer.
:type dim: int
:param norm_layer: normalization layer.
:type norm_layer: :class:`nn.Module`
:param use_dropout: if use dropout layers.
:type use_dropout: bool
:param use_bias: if the conv layer uses bias or not
:type use_bias: bool
:return: Returns a conv block (with a conv layer, a normalization layer, and a non-linearity layer (ReLU))
:rtype: :class:`nn.Sequential`
"""
conv_block = []
conv_block += [nn.ReplicationPad3d(1)]
conv_block += [nn.Conv3d(dim, dim, kernel_size=3, bias=use_bias)]
conv_block += [nn.ReLU(True)]
if use_dropout:
conv_block += [nn.Dropout(0.5)]
conv_block += [nn.ReplicationPad3d(1)]
conv_block += [nn.Conv3d(dim, dim, kernel_size=3, bias=use_bias)]
conv_block += [norm_layer(dim)]
return nn.Sequential(*conv_block)
def build_conv_block(self, dim, padding_type, norm_layer, use_dropout, use_bias):
conv_block = []
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReplicationPad3d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad3d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' % padding_type)
conv_block += [nn.Conv3d(dim, dim, kernel_size=3, padding=p, bias=use_bias),
norm_layer(dim),
nn.ReLU(True)]
if use_dropout:
conv_block += [nn.Dropout(0.5)]
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReplicationPad3d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad3d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' % padding_type)
conv_block += [nn.Conv3d(dim, dim, kernel_size=3, padding=p, bias=use_bias),
norm_layer(dim)]
return nn.Sequential(*conv_block)
def restrctuctre3d(nf0, norm, inplace=False):
tmp = nn.Sequential(
norm(nf0 * 1, affine=True),
nn.ReLU(inplace),
# nn.Dropout3d(0.1, inplace),
nn.ReplicationPad3d(1),
nn.Conv3d(nf0 * 1,
nf0 * 1,
kernel_size=[3, 3, 3],
padding=0,
stride=[1, 1, 1],
bias=False),
norm(nf0 * 1, affine=True),
nn.ReLU(inplace),
# nn.Dropout3d(0.1, inplace),
nn.ReplicationPad3d(1),
nn.Conv3d(nf0 * 1,
nf0 * 1,
kernel_size=[3, 3, 3],
padding=0,
stride=[1, 1, 1],
bias=False),
)
return tmp
def __init__(self, nf0, inplace=False):
super(ResConv3D, self).__init__()
self.tmp = nn.Sequential(
nn.ReplicationPad3d(1),
nn.Conv3d(nf0 * 1,
nf0 * 1,
kernel_size=[3, 3, 3],
padding=0,
stride=[1, 1, 1],
bias=True),
nn.LeakyReLU(negative_slope=0.2, inplace=inplace),
# nn.Dropout3d(0.1, inplace),
nn.ReplicationPad3d(1),
nn.Conv3d(nf0 * 1,
nf0 * 1,
kernel_size=[3, 3, 3],
padding=0,
stride=[1, 1, 1],
bias=True),
)
self.inplace = inplace
def __init__(self, c_len_in, c_len_out, opt=None):
super(Unet3D, self).__init__()
# (BV,8,32,48,32) | conv3d(k3,s1,i8,o8,nb), BN3d, LearkyReLU(0.2) | (BV,8,32,48,32) ------> skip-0: (BV,8,32,48,32)
c_len_1 = 8
self.conv3d_pre_process = nn.Sequential(
Conv3dSame(c_len_in, c_len_1, kernel_size=3, bias=False),
nn.BatchNorm3d(c_len_1, affine=True), nn.LeakyReLU(0.2, True))
# (BV,8,32,48,32) | conv3d(k4,s2,i8,o16,nb), BN3d, LeakyReLU(0.2) | (BV,16,16,24,16) ------> skip-1: (BV,16,16,24,16)
c_len_2 = 16
self.conv3d_enc_1 = nn.Sequential(
nn.ReplicationPad3d(1),
nn.Conv3d(c_len_1,
c_len_2,
kernel_size=4,
padding=0,
stride=2,
bias=False), nn.BatchNorm3d(c_len_2, affine=True),
nn.LeakyReLU(0.2, True))
# (BV,16,16,24,16) | conv3d(k4,s2,i16,o32,b), LeakyReLU(0.2) | (BV,32,8,12,8)
c_len_3 = 32
self.conv3d_enc_2 = nn.Sequential(
nn.ReplicationPad3d(1),
nn.Conv3d(c_len_2,
c_len_3,
kernel_size=4,
padding=0,
stride=2,
bias=True), nn.LeakyReLU(0.2, True))
# (BV,32,8,12,8) | DeConv3d(k4,s2,i32,o16,b), ReLU | (BV,16,16,24,16)
self.deconv3d_dec_2 = nn.Sequential(
nn.ConvTranspose3d(c_len_3,
c_len_2,
kernel_size=4,
stride=2,
padding=1,
bias=True), nn.ReLU(True))
# (BV,16+16,16,24,16) | DeConv3d(k4,s2,i32,o8,nb), BN3d, ReLU | (BV,8,32,48,32) <------ skip-1: (BV,16,16,24,16)
self.deconv3d_dec_1 = nn.Sequential(
nn.ConvTranspose3d(c_len_2 * 2,
c_len_1,
kernel_size=4,
stride=2,
padding=1,
bias=False), nn.BatchNorm3d(c_len_1,
affine=True),
nn.ReLU(True))
# (BV,8+8,32,48,32) | Conv3d(k3,s1,i16,o8,nb), BN3d, ReLU | (BV,8,32,48,32) <------ skip-0: (BV,8,32,48,32)
self.conv3d_final_process = nn.Sequential(
Conv3dSame(c_len_1 * 2, c_len_out, kernel_size=3, bias=False),
nn.BatchNorm3d(c_len_out, affine=True), nn.ReLU(True))
def __init__(self, n_input, n_output):
super(BlockB, self).__init__()
self.pad1 = nn.ReplicationPad3d((1, 1, 1, 1, 1, 1))
self.left1 = nn.Conv3d(n_input, n_output, 3, 1, padding=1)
self.pad2 = nn.ReplicationPad3d((1, 1, 1, 1, 1, 1))
self.left2 = nn.Conv3d(n_output, n_output, 3, 1, padding=1)
self.pad3 = nn.ReplicationPad3d((1, 1, 1, 1, 1, 1))
self.right = nn.Conv3d(n_input, n_output, 3, 1, padding=1)
self.relu = nn.ReLU()
def __init__(self):
super(subplanar_pdd, self).__init__()
self.alpha = nn.Parameter(torch.Tensor([1,.1,1,1,.1,5]))#1]))#.cuda()
self.pad1 = nn.ReplicationPad3d((0,0,2,2,2,2))#.cuda()
self.avg1 = nn.AvgPool3d((3,3,1),stride=1)#.cuda()
self.max1 = nn.MaxPool3d((3,3,1),stride=1)#.cuda()
self.pad2 = nn.ReplicationPad3d((0,0,2,2,2,2))#.cuda()##
def __init__(self):
super(deeds, self).__init__()
self.alpha = nn.Parameter(torch.Tensor([1, .1, 1, 1, .1, 1])) #.cuda()
self.pad1 = nn.ReplicationPad3d(3) #.cuda()
self.avg1 = nn.AvgPool3d(3, stride=1) #.cuda()
self.max1 = nn.MaxPool3d(3, stride=1) #.cuda()
self.pad2 = nn.ReplicationPad3d(2) #.cuda()##
def __init__(self, input_channels):
super(Kurvature3D, self).__init__()
dx_0 = kernels3D['dx0']()
dy_0 = kernels3D['dy0']()
dz_0 = kernels3D['dz0']()
self.padx_b = nn.ReplicationPad3d(list(reversed([1, 1, 0, 0, 0, 0])))
self.pady_b = nn.ReplicationPad3d(list(reversed([0, 0, 1, 1, 0, 0])))
self.padz_b = nn.ReplicationPad3d(list(reversed([0, 0, 0, 0, 1, 1])))
self.conv_dx_0 = Convolve(dx_0, input_channels, padding=0)
self.conv_dy_0 = Convolve(dy_0, input_channels, padding=0)
self.conv_dz_0 = Convolve(dz_0, input_channels, padding=0)
dx_bf = kernels3D['dx+-']()
dy_bf = kernels3D['dy+-']()
dz_bf = kernels3D['dz+-']()
self.padx_f = nn.ReplicationPad3d(list(reversed([1, 0, 0, 0, 0, 0])))
self.pady_f = nn.ReplicationPad3d(list(reversed([0, 0, 1, 0, 0, 0])))
self.padz_f = nn.ReplicationPad3d(list(reversed([0, 0, 0, 0, 1, 0])))
self.padx_b = nn.ReplicationPad3d(list(reversed([0, 1, 0, 0, 0, 0])))
self.pady_b = nn.ReplicationPad3d(list(reversed([0, 0, 0, 1, 0, 0])))
self.padz_b = nn.ReplicationPad3d(list(reversed([0, 0, 0, 0, 0, 1])))
self.conv_dx_b = Convolve(dx_bf, input_channels, padding=0)
self.conv_dx_f = self.conv_dx_b
self.conv_dy_b = Convolve(dy_bf, input_channels, padding=0)
self.conv_dy_f = self.conv_dy_b
self.conv_dz_b = Convolve(dz_bf, input_channels, padding=0)
self.conv_dz_f = self.conv_dz_b
def __init__(self, input_channels):
super(Gradient3D, self).__init__()
if method == '0':
dx = kernels3D['dx0']()
dy = kernels3D['dy0']()
dz = kernels3D['dz0']()
self.padx = nn.ReplicationPad3d(list(reversed([1, 1, 0, 0, 0, 0])))
self.pady = nn.ReplicationPad3d(list(reversed([0, 0, 1, 1, 0, 0])))
self.padz = nn.ReplicationPad3d(list(reversed([0, 0, 0, 0, 1, 1])))
if method == '+':
dx = kernels3D['dx+-']()
dy = kernels3D['dy+-']()
dz = kernels3D['dy+-']()
self.padx = nn.ReplicationPad3d(list(reversed([1, 0, 0, 0, 0, 0])))
self.pady = nn.ReplicationPad3d(list(reversed([0, 0, 1, 0, 0, 0])))
self.padz = nn.ReplicationPad3d(list(reversed([0, 0, 0, 0, 1, 0])))
if method == '-':
dx = kernels3D['dx+-']()
dy = kernels3D['dy+-']()
dz = kernels3D['dy+-']()
self.padx = nn.ReplicationPad3d(list(reversed([0, 1, 0, 0, 0, 0])))
self.pady = nn.ReplicationPad3d(list(reversed([0, 0, 0, 1, 0, 0])))
self.padz = nn.ReplicationPad3d(list(reversed([0, 0, 0, 0, 0, 1])))
self.conv_dx = Convolve(dx, input_channels, padding=0)
self.conv_dy = Convolve(dy, input_channels, padding=0)
self.conv_dz = Convolve(dz, input_channels, padding=0)
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm3d, use_dropout=False, n_blocks=9, padding_type='replicate'):
"""Construct a Resnet-based generator
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
ngf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers
n_blocks (int) -- the number of ResNet blocks
padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero
"""
assert(n_blocks >= 0)
super(ResnetGenerator, self).__init__()
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm3d
else:
use_bias = norm_layer == nn.InstanceNorm3d
# model = [nn.ReflectionPad2d(3),
# nn.Conv3d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),
# norm_layer(ngf),
# nn.ReLU(True)]
model = [nn.ReplicationPad3d(3),
nn.Conv3d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),
norm_layer(ngf),
nn.ReLU(True)]
n_downsampling = 2
for i in range(n_downsampling): # add downsampling layers
mult = 2 ** i
model += [nn.Conv3d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),
norm_layer(ngf * mult * 2),
nn.ReLU(True)]
mult = 2 ** n_downsampling
for i in range(n_blocks): # add ResNet blocks
model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]
for i in range(n_downsampling): # add upsampling layers
mult = 2 ** (n_downsampling - i)
model += [nn.ConvTranspose3d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=2,
padding=1, output_padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
# model += [nn.ReflectionPad2d(3)]
model += [nn.ReplicationPad3d(3)]
model += [nn.Conv3d(ngf, output_nc, kernel_size=7, padding=0)]
model += [nn.Tanh()]
self.model = nn.Sequential(*model)
def __init__(self,
input_nc,
output_nc,
depth,
ngf=64,
norm_layer=nn.BatchNorm3d,
use_naive=False):
super(SrcnnGenerator3d, self).__init__()
use_bias = True
downconv_ab = [
nn.ReplicationPad3d(1),
nn.Conv3d(input_nc,
ngf,
kernel_size=3,
stride=1,
padding=0,
bias=use_bias)
]
downconv_ba = [
nn.ReplicationPad3d(1),
nn.Conv3d(input_nc,
ngf,
kernel_size=3,
stride=1,
padding=0,
bias=use_bias)
]
core = []
for _ in range(depth):
core += [RevBlock3d(ngf, use_bias, norm_layer, use_naive)]
upconv_ab = [
nn.Conv3d(ngf,
output_nc,
kernel_size=1,
stride=1,
padding=0,
bias=use_bias)
]
upconv_ba = [
nn.Conv3d(ngf,
output_nc,
kernel_size=1,
stride=1,
padding=0,
bias=use_bias)
]
self.downconv_ab = nn.Sequential(*downconv_ab)
self.downconv_ba = nn.Sequential(*downconv_ba)
self.core = nn.ModuleList(core)
self.upconv_ab = nn.Sequential(*upconv_ab)
self.upconv_ba = nn.Sequential(*upconv_ba)
def __init__(self, in_channels, out_channels, leaky=False):
super().__init__()
self.double_conv = nn.Sequential(
nn.ReplicationPad3d((1, 1, 1, 1, 1, 1)),
nn.Conv3d(in_channels, out_channels, kernel_size=3, padding=0),
nn.BatchNorm3d(out_channels),
nn.ReLU(inplace=True) if leaky is False else nn.LeakyReLU(negative_slope=0.2, inplace=True),
nn.ReplicationPad3d((1, 1, 1, 1, 1, 1)),
nn.Conv3d(out_channels, out_channels, kernel_size=3, padding=0),
nn.BatchNorm3d(out_channels),
nn.ReLU(inplace=True) if leaky is False else nn.LeakyReLU(negative_slope=0.2, inplace=True)
)
def MINDSSC(img, radius=2, dilation=2):
# see http://mpheinrich.de/pub/miccai2013_943_mheinrich.pdf for details on the MIND-SSC descriptor
# kernel size
kernel_size = radius * 2 + 1
# define start and end locations for self-similarity pattern
six_neighbourhood = torch.Tensor([[0, 1, 1], [1, 1, 0], [1, 0, 1],
[1, 1, 2], [2, 1, 1], [1, 2, 1]]).long()
# squared distances
dist = pdist_squared(six_neighbourhood.t().unsqueeze(0)).squeeze(0)
# define comparison mask
x, y = torch.meshgrid(torch.arange(6), torch.arange(6))
mask = ((x > y).view(-1) & (dist == 2).view(-1))
# build kernel
idx_shift1 = six_neighbourhood.unsqueeze(1).repeat(1, 6,
1).view(-1, 3)[mask, :]
idx_shift2 = six_neighbourhood.unsqueeze(0).repeat(6, 1,
1).view(-1, 3)[mask, :]
mshift1 = torch.zeros(12, 1, 3, 3, 3).cuda()
mshift1.view(-1)[torch.arange(12) * 27 + idx_shift1[:, 0] * 9 +
idx_shift1[:, 1] * 3 + idx_shift1[:, 2]] = 1
mshift2 = torch.zeros(12, 1, 3, 3, 3).cuda()
mshift2.view(-1)[torch.arange(12) * 27 + idx_shift2[:, 0] * 9 +
idx_shift2[:, 1] * 3 + idx_shift2[:, 2]] = 1
rpad1 = nn.ReplicationPad3d(dilation)
rpad2 = nn.ReplicationPad3d(radius)
# compute patch-ssd
ssd = F.avg_pool3d(rpad2(
(F.conv3d(rpad1(img), mshift1, dilation=dilation) -
F.conv3d(rpad1(img), mshift2, dilation=dilation))**2),
kernel_size,
stride=1)
# MIND equation
mind = ssd - torch.min(ssd, 1, keepdim=True)[0]
mind_var = torch.mean(mind, 1, keepdim=True)
mind_var_mean = mind_var.mean().cpu().data
mind_var = torch.clamp(mind_var, mind_var_mean * 0.001,
mind_var_mean * 1000)
mind /= mind_var
mind = torch.exp(-mind)
#permute to have same ordering as C++ code
mind = mind[:,
torch.Tensor([6, 8, 1, 11, 2, 10, 0, 7, 9, 4, 5, 3]).long(
), :, :, :]
return mind
def __init__(self, dim):
super(C3dResNetBlock, self).__init__()
conv_block = []
conv_block += [
nn.ReplicationPad3d(1),
nn.Conv3d(dim, dim, kernel_size=3),
nn.InstanceNorm3d(dim),
nn.ReLU(True),
nn.ReplicationPad3d(1),
nn.Conv3d(dim, dim, kernel_size=3),
nn.InstanceNorm3d(dim)
]
self.conv_block = nn.Sequential(*conv_block)
def __init__(self, ic:int, oc:int, scale_factor:Union[List[int],int]=2, full:bool=False, k:int=1):
super().__init__()
if isinstance(scale_factor, int): scale_factor = [scale_factor] * 3
self.sf = scale_factor
sf = (scale_factor[0] * scale_factor[1] * scale_factor[2])
pad = k//2 if isinstance(k,int) else tuple([ks//2 for p in zip(reversed(k),reversed(k)) for ks in p])
if isinstance(k,int): self.pad = None if k < 3 else nn.ReplicationPad3d(pad)
if isinstance(k,tuple): self.pad = None if all([p == 0 for p in pad]) else nn.ReplicationPad3d(pad)
self.conv = nn.Conv3d(ic, oc*sf, k, bias=False)
self.full = full
if full:
self.bn = nn.BatchNorm3d(oc)
self.act = nn.ReLU(inplace=True)
def build_conv_block(self, dim, use_bias, norm_layer):
conv_block = []
conv_block += [nn.ReplicationPad3d(1)]
conv_block += [
nn.Conv3d(dim, dim, kernel_size=3, padding=0, bias=use_bias)
]
conv_block += [norm_layer(dim)]
conv_block += [nn.ReLU(True)]
conv_block += [nn.ReplicationPad3d(1)]
conv_block += [
ZeroInit(dim, dim, kernel_size=3, padding=0, bias=use_bias)
]
return nn.Sequential(*conv_block)
def get_padding(self, padding_type):
""" Takes the input padding type and returns the appropiate padding
layer and the ammount of padding to use in convolutional layer"""
p, p_layer = 0, [] # Ammount of padding and type of layer
if padding_type == 'reflect':
p_layer = [nn.ReplicationPad3d(1)]
elif padding_type == 'replicate':
p_layer = [nn.ReplicationPad3d(1)]
elif padding_type == 'zero': # If using 'zero', don't add padding layer
p = 1
else:
raise NotImplementedError(
f"padding {padding_type} is not implemented")
return p_layer, p
def build_conv_block(self, dim, padding_type, norm_layer, use_dropout,
use_bias):
"""Construct a convolutional block.
Parameters:
dim (int) -- the number of channels in the conv layer.
padding_type (str) -- the name of padding layer: reflect | replicate | zero
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers.
use_bias (bool) -- if the conv layer uses bias or not
Returns a conv block (with a conv layer, a normalization layer, and a non-linearity layer (ReLU))
"""
conv_block = []
p = 0
if padding_type == 'reflect':
conv_block += [ReflectionPad3d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad3d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' %
padding_type)
conv_block += [
nn.Conv3d(dim, dim, kernel_size=3, padding=p, bias=use_bias),
norm_layer(dim),
nn.ReLU(True)
]
if use_dropout:
conv_block += [nn.Dropout(0.5)]
p = 0
if padding_type == 'reflect':
conv_block += [ReflectionPad3d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad3d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' %
padding_type)
conv_block += [
nn.Conv3d(dim, dim, kernel_size=3, padding=p, bias=use_bias),
norm_layer(dim)
]
return nn.Sequential(*conv_block)
def __init__(self, num_classes=157):
super(InceptionUp3D, self).__init__()
self.conv1up = BasicConvUp3d(64, 3, (7, 7, 7), (2, 2, 2), padding=(3, 3,3))
self.upsample1 = nn.Upsample(scale_factor=(1, 2, 2), mode='trilinear')
self.conv2up = BasicConvUp3d(64, 64, (1, 1, 1))
#self.conv3up = BasicConvUp3d(64, 64, (3, 3, 3))
self.upsample2 = nn.Upsample(scale_factor=(1, 2, 2), mode='trilinear')
#self.inc1up = InceptionUp([192, 64, 96, 128, 16, 32, 32])
self.inc1up = InceptionUp([192, 16, 96, 32, 16, 8, 8])
self.inc2up = InceptionUp([256, 32, 32, 64, 32, 64, 32])
self.upsample3 = nn.Upsample(scale_factor=(2, 2, 2), mode='trilinear')
#self.inc3up = InceptionUp([480, 192, 96, 208, 16, 48, 64])
self.inc3up = InceptionUp([480, 64, 96, 128, 16, 32, 32])
self.inc4up = InceptionUp([512, 128, 128, 192, 32, 96, 64])
#self.upsample5 = nn.Upsample(scale_factor=(2, 2, 2), mode='trilinear')
#self.inc4up = InceptionUp([512, 160, 112, 224, 24, 64, 64])
self.inc5up = InceptionUp([512, 128, 128, 256, 24, 64, 64])
self.inc6up = InceptionUp([512, 128, 128, 256, 24, 64, 64])
#self.inc6up = InceptionUp([512, 112, 144, 288, 32, 64, 64])
self.inc7up = InceptionUp([528, 128, 128, 256, 24, 64, 64])
#self.inc7up = InceptionUp([528, 256, 160, 320, 32, 128, 128])
self.upsample4 = nn.Upsample(scale_factor=(2, 2, 2), mode='trilinear')
self.inc8up = InceptionUp([832, 112, 144, 288, 32, 64, 64])
#self.inc8up = InceptionUp([832, 256, 160, 320, 32, 128, 128])
self.inc9up = InceptionUp([832, 256, 160, 320, 32, 128, 128])
self.inc10up = InceptionUp([1024, 256, 160, 320, 32, 128, 128])
self.padding = nn.ReplicationPad3d((1, 1, 1, 1, 0, 0))
self.aapadding = nn.ReplicationPad3d((1, 1, 1, 1, 1, 1))
#self.inc9up = InceptionUp([832, 384, 192, 384, 48, 128, 128])
self.tpadding = nn.ReplicationPad3d((0, 0, 0, 0, 0, 1))
self.spadding = nn.ReplicationPad3d((0, 1, 0, 1, 0, 0))
self.apadding = nn.ReplicationPad3d((0, 1, 0, 1, 0, 1))
self.attnout1 = nn.Conv3d(1024, 1, (3, 3, 3), padding=(1, 1, 1))
self.attnout2 = nn.Conv3d(832, 1, (3, 3, 3), padding=(1, 1, 1))
self.attnout3 = nn.Conv3d(512, 1, (3, 3, 3), padding=(1, 1, 1))
self.attnout4 = nn.Conv3d(256, 1, (3, 3, 3), padding=(1, 1, 1))
self.attnout5 = nn.Conv3d(64, 1, (3, 3, 3), padding=(1, 1, 1))
self.refine1 = FactoredRefinement(832)
self.refine2 = FactoredRefinement(832)
self.refine3 = FactoredRefinement(528)
self.refine4 = FactoredRefinement(512)
self.refine5 = FactoredRefinement(512)
self.refine6 = FactoredRefinement(512)
self.refine7 = FactoredRefinement(480)
self.refine8 = FactoredRefinement(256)
self.refine9 = FactoredRefinement(192)
self.refine10 = FactoredRefinement(64)
self.refine11 = FactoredRefinement(64)
def conv3d_norm_act(in_planes, out_planes, kernel_size=(3,3,3), stride=1,
dilation=(1,1,1), padding=(1,1,1), bias=True, pad_mode='rep', norm_mode='', act_mode='', return_list=False):
if isinstance(padding,int):
pad_mode = pad_mode if padding!=0 else 'zeros'
else:
pad_mode = pad_mode if max(padding)!=0 else 'zeros'
if pad_mode in ['zeros','circular']:
layers = [nn.Conv3d(in_planes, out_planes, kernel_size=kernel_size,
stride=stride, padding=padding, padding_mode=pad_mode, dilation=dilation, bias=bias)]
elif pad_mode=='rep':
# the size of the padding should be a 6-tuple
padding = tuple([x for x in padding for _ in range(2)][::-1])
layers = [nn.ReplicationPad3d(padding),
nn.Conv3d(in_planes, out_planes, kernel_size=kernel_size,
stride=stride, padding=0, dilation=dilation, bias=bias)]
else:
raise ValueError('Unknown padding option {}'.format(mode))
layers += get_layer_norm(out_planes, norm_mode, 3)
layers += get_layer_act(act_mode)
if return_list:
return layers
else:
return nn.Sequential(*layers)
def __init__(self):
super(Conv3d_convLSTM, self).__init__()
self.pad = nn.ReplicationPad3d((1,1,1,1,0,0))
self.conv_time = nn.Conv3d(1, 32, (6, 1, 1))
self.conv_spat = nn.Conv3d(32, 32, (1, 3, 3))
self.pool_time = nn.AvgPool3d(kernel_size=(3, 1, 1), stride=(3, 1, 1))
self.batchnorm = nn.BatchNorm3d(32)
self.conv_time2 = nn.Conv3d(32, 64, (6, 1, 1))
self.conv_spat2 = nn.Conv3d(64, 64, (1, 3, 3))
self.pool_time2 = nn.AvgPool3d(kernel_size=(3, 1, 1), stride=(3, 1, 1))
self.batchnorm2 = nn.BatchNorm3d(64)
self.conv_time3 = nn.Conv3d(64, 128, (6, 1, 1))
self.conv_spat3 = nn.Conv3d(128, 128, (1, 3, 3))
self.pool_time3 = nn.AvgPool3d(kernel_size=(3, 1, 1), stride=(3, 1, 1))
self.batchnorm3 = nn.BatchNorm3d(128)
self.convlstm = NlayersSeqConvLSTM(input_channels=128,
hidden_channels=[256],
kernel_sizes=[3])
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.dropout = nn.Dropout(0.5)
self.linear = nn.Linear(256, 4)
def __init__(self,
dim,
norm_layer='batch',
kernel=3,
use_bias=False,
act=Mish()):
super(ResnetBlock, self).__init__()
conv_block = []
p = 0
conv_block += [
nn.Conv3d(dim, 64, kernel_size=1, padding=p, bias=use_bias),
select_norm(64, norm_layer), act
]
if kernel == 3:
conv_block += [nn.ReplicationPad3d(1)]
conv_block += [
nn.Conv3d(64, 64, kernel_size=kernel, padding=p, bias=use_bias),
select_norm(64, norm_layer), act
]
conv_block += [
nn.Conv3d(64, dim, kernel_size=1, padding=p, bias=use_bias),
select_norm(dim, norm_layer)
]
self.conv_block = nn.Sequential(*conv_block)
def __init__(self, in_features):
super(ResidualBlock, self).__init__()
conv_block = [ nn.ReplicationPad3d(1),
nn.Conv3d(in_features, in_features, 3),
# nn.BatchNorm3d(in_features),
nn.InstanceNorm3d(in_features),
# nn.BatchNorm3d(in_features),
nn.ReLU(inplace=True),
nn.ReplicationPad3d(1),
nn.Conv3d(in_features, in_features, 3),
# nn.BatchNorm3d(in_features)
nn.InstanceNorm3d(in_features) ]
# nn.BatchNorm3d(in_features) ]
self.conv_block = nn.Sequential(*conv_block)
def conv(layers,
c_in,
c_out,
k_size,
stride=1,
pad=0,
padding='zero',
lrelu=True,
batch_norm=False,
w_norm=False,
d_gdrop=False,
pixel_norm=False,
only=False):
if padding == 'replication':
layers.append(nn.ReplicationPad3d(pad))
pad = 0
if d_gdrop: layers.append(GeneralizedDropOut(mode='prop', strength=0.0))
if w_norm:
layers.append(
EqualizedConv3d(c_in,
c_out,
k_size,
stride,
pad,
initializer='kaiming'))
else:
layers.append(nn.Conv3d(c_in, c_out, k_size, stride, pad))
if not only:
if lrelu: layers.append(nn.LeakyReLU(0.2))
else: layers.append(nn.ReLU())
if batch_norm: layers.append(nn.BatchNorm3d(c_out))
if pixel_norm: layers.append(PixelwiseNormLayer())
return layers
def deconv_t(layers,
c_in,
c_out,
k_size,
stride=1,
pad=0,
padding='zero',
lrelu=True,
batch_norm=False,
w_norm=False,
pixel_norm=False,
only=False):
if padding == 'replication':
layers.append(nn.ReplicationPad3d(pad))
pad = 0
if w_norm:
layers.append(
EqualizedConvTranspose3d(c_in, c_out, k_size, stride, pad))
else:
layers.append(nn.ConvTranspose3d(c_in, c_out, k_size, stride, pad))
if not only:
if lrelu: layers.append(nn.LeakyReLU(0.2))
else: layers.append(nn.ReLU())
if batch_norm: layers.append(nn.BatchNorm3d(c_out))
if pixel_norm: layers.append(PixelwiseNormLayer())
return layers
def _conv(self,
in_c: int,
out_c: int,
kernel_sz: Optional[Tuple[int]] = None,
bias: bool = False,
seq: bool = True,
stride: Tuple[int] = None):
ksz = kernel_sz or self.kernel_sz
bias = False if self.norm != 'none' and not bias else True
stride = stride or tuple([1 for _ in ksz])
if not self.separable or all([ks == 1 for ks in ksz]):
layers = [nn.Conv3d(in_c, out_c, ksz, bias=bias, stride=stride)] if self.dim == 3 else \
[nn.Conv2d(in_c, out_c, ksz, bias=bias, stride=stride)] if self.dim == 2 else \
[nn.Conv1d(in_c, out_c, ksz, bias=bias, stride=stride)]
else:
layers = [SeparableConv3d(in_c, out_c, ksz, bias=bias, stride=stride)] if self.dim == 3 else \
[SeparableConv2d(in_c, out_c, ksz, bias=bias, stride=stride)] if self.dim == 2 else \
[SeparableConv1d(in_c, out_c, ksz, bias=bias, stride=stride)]
if any([ks > 1 for ks in ksz]):
rp = tuple([
ks // 2 for p in zip(reversed(ksz), reversed(ksz)) for ks in p
])
layers = [nn.ReplicationPad3d(rp)] + layers if self.dim == 3 else \
[nn.ReflectionPad2d(rp)] + layers if self.dim == 2 else \
[nn.ReflectionPad1d(rp)] + layers
if seq and len(layers) > 1:
c = nn.Sequential(*layers)
else:
c = layers if len(layers) > 1 else layers[0]
return c
def __init__(self, num_classes=157):
super(Inception3D, self).__init__()
self.conv1 = BasicConv3d(3,
64, (7, 7, 7), (2, 2, 2),
padding=(3, 3, 3))
self.maxpool1 = nn.MaxPool3d((1, 3, 3), (1, 2, 2), padding=(0, 1, 1))
self.conv2 = BasicConv3d(64, 64, (1, 1, 1))
self.conv3 = BasicConv3d(64, 192, (3, 3, 3), padding=(1, 1, 1))
self.maxpool2 = nn.MaxPool3d((1, 3, 3), (1, 2, 2), padding=(0, 1, 1))
self.inc1 = Inception([192, 64, 96, 128, 16, 32, 32])
self.inc2 = Inception([256, 128, 128, 192, 32, 96, 64])
self.maxpool3 = nn.MaxPool3d((3, 3, 3), (2, 2, 2), padding=(1, 1, 1))
self.inc3 = Inception([480, 192, 96, 208, 16, 48, 64])
#self.inc3 = Inception([480, 192, 96, 204, 16, 48, 64])
self.inc4 = Inception([512, 160, 112, 224, 24, 64, 64])
#self.inc4 = Inception([508, 160, 112, 224, 24, 64, 64])
self.inc5 = Inception([512, 128, 128, 256, 24, 64, 64])
self.inc6 = Inception([512, 112, 144, 288, 32, 64, 64])
self.inc7 = Inception([528, 256, 160, 320, 32, 128, 128])
self.maxpool4 = nn.MaxPool3d((2, 2, 2), (2, 2, 2), padding=(0, 0, 0))
self.inc8 = Inception([832, 256, 160, 320, 32, 128, 128])
#self.inc8 = Inception([832, 256, 160, 320, 48, 128, 128])
self.inc9 = Inception([832, 384, 192, 384, 48, 128, 128])
self.padding = nn.ReplicationPad3d((1, 0, 1, 0, 0, 0))
self.avgpool = nn.AvgPool3d((2, 7, 7), stride=(1, 1, 1))
self.conv4 = nn.Conv3d(
1024, 157, kernel_size=(1, 1, 1),
stride=(1, 1, 1)) #BasicConv3d(1024, num_classes, (1, 1, 1))
def __init__(self,input_ch=1,output_ch=95): #Number of classes
super(AttU_Net3D,self).__init__()
self.Maxpool3D = nn.MaxPool3d(kernel_size=2,stride=2)
self.pad = nn.ReplicationPad3d(1)
self.sig = nn.Sigmoid()
self.Conv3D_1 = conv_block3D(ch_in=input_ch,ch_out=64)
self.Conv3D_2 = conv_block3D(ch_in=64,ch_out=128)
self.Conv3D_3 = conv_block3D(ch_in=128,ch_out=256)
self.Conv3D_4 = conv_block3D(ch_in=256,ch_out=512)
self.Conv3D_5 = conv_block3D(ch_in=512,ch_out=1024)
self.Up5 = up_conv3D(ch_in=1024,ch_out=512)
self.Att3D_5 = Attention3D(F_g=512,F_l=512,F_int=256)
self.Up3D_conv5 = conv_block3D(ch_in=1024, ch_out=512)
self.Up4 = up_conv3D(ch_in=512,ch_out=256)
self.Att3D_4 = Attention3D(F_g=256,F_l=256,F_int=128)
self.Up3D_conv4 = conv_block3D(ch_in=512, ch_out=256)
self.Up3 = up_conv3D(ch_in=256,ch_out=128)
self.Att3D_3 = Attention3D(F_g=128,F_l=128,F_int=64)
self.Up3D_conv3 = conv_block3D(ch_in=256, ch_out=128)
self.Up2 = up_conv3D(ch_in=128,ch_out=64)
self.Att3D_2 = Attention3D(F_g=64,F_l=64,F_int=32)
self.Up3D_conv2 = conv_block3D2(ch_in=128, ch_out=64)
self.Conv3D_1x1 = nn.Conv3d(64,output_ch,kernel_size=1,stride=1,padding=0)
def __init__(self,
n_downsamples=5,
in_channels=1,
filters=24,
activation=nn.LeakyReLU(0.1),
maxfeatures=256):
super().__init__()
self.maxfeatures = maxfeatures
self.n_downsamples = n_downsamples
self.filters = filters
self.intro = nn.Sequential(
nn.ReplicationPad3d(3),
nn.Conv3d(in_channels, filters, kernel_size=7, padding=0),
nn.BatchNorm3d(filters), activation)
model = []
for i in range(1, self.n_downsamples):
inp = self.filters * i
inp = min(inp, self.maxfeatures)
out = self.filters * (i + 1)
out = min(out, self.maxfeatures)
model += [
nn.Conv3d(inp, out, kernel_size=4, stride=2, padding=1),
nn.BatchNorm3d(out), activation
]
print(f'{inp} -> {out}')
self.model = nn.Sequential(*model)
self.dense = nn.Sequential(nn.Linear(120 * 4 * 4 * 3, 512), activation,
nn.Dropout(), nn.Linear(512, 2))
print()
