Python torch.nn.ConvTranspose3d() Examples
The following are 30
code examples of torch.nn.ConvTranspose3d().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
torch.nn
, or try the search function
.
.
Example #1
| Source File: gwcnet.py From GwcNet with MIT License | 6 votes |
|
def __init__(self, in_channels):
super(hourglass, self).__init__()
self.conv1 = nn.Sequential(convbn_3d(in_channels, in_channels * 2, 3, 2, 1),
nn.ReLU(inplace=True))
self.conv2 = nn.Sequential(convbn_3d(in_channels * 2, in_channels * 2, 3, 1, 1),
nn.ReLU(inplace=True))
self.conv3 = nn.Sequential(convbn_3d(in_channels * 2, in_channels * 4, 3, 2, 1),
nn.ReLU(inplace=True))
self.conv4 = nn.Sequential(convbn_3d(in_channels * 4, in_channels * 4, 3, 1, 1),
nn.ReLU(inplace=True))
self.conv5 = nn.Sequential(
nn.ConvTranspose3d(in_channels * 4, in_channels * 2, 3, padding=1, output_padding=1, stride=2, bias=False),
nn.BatchNorm3d(in_channels * 2))
self.conv6 = nn.Sequential(
nn.ConvTranspose3d(in_channels * 2, in_channels, 3, padding=1, output_padding=1, stride=2, bias=False),
nn.BatchNorm3d(in_channels))
self.redir1 = convbn_3d(in_channels, in_channels, kernel_size=1, stride=1, pad=0)
self.redir2 = convbn_3d(in_channels * 2, in_channels * 2, kernel_size=1, stride=1, pad=0)
Example #2
| Source File: ufrcnn.py From medicaldetectiontoolkit with Apache License 2.0 | 6 votes |
|
def __init__(self, cf, conv):
super(Mask, self).__init__()
self.pool_size = cf.mask_pool_size
self.pyramid_levels = cf.pyramid_levels
self.dim = conv.dim
self.conv1 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv2 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv3 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv4 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
if conv.dim == 2:
self.deconv = nn.ConvTranspose2d(cf.end_filts, cf.end_filts, kernel_size=2, stride=2)
else:
self.deconv = nn.ConvTranspose3d(cf.end_filts, cf.end_filts, kernel_size=2, stride=2)
self.relu = nn.ReLU(inplace=True) if cf.relu == 'relu' else nn.LeakyReLU(inplace=True)
self.conv5 = conv(cf.end_filts, cf.head_classes, ks=1, stride=1, relu=None)
self.sigmoid = nn.Sigmoid()
Example #3
| Source File: mrcnn.py From medicaldetectiontoolkit with Apache License 2.0 | 6 votes |
|
def __init__(self, cf, conv):
super(Mask, self).__init__()
self.pool_size = cf.mask_pool_size
self.pyramid_levels = cf.pyramid_levels
self.dim = conv.dim
self.conv1 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv2 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv3 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv4 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
if conv.dim == 2:
self.deconv = nn.ConvTranspose2d(cf.end_filts, cf.end_filts, kernel_size=2, stride=2)
else:
self.deconv = nn.ConvTranspose3d(cf.end_filts, cf.end_filts, kernel_size=2, stride=2)
self.relu = nn.ReLU(inplace=True) if cf.relu == 'relu' else nn.LeakyReLU(inplace=True)
self.conv5 = conv(cf.end_filts, cf.head_classes, ks=1, stride=1, relu=None)
self.sigmoid = nn.Sigmoid()
Example #4
| Source File: baselineRes18Conc.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 6 votes |
|
def __init__(self, block, upblock, n_size, num_classes=2, in_channel=1): # BasicBlock, 3
super(ResNetUNET3D, self).__init__()
self.inplane = 28
self.conv1 = nn.Conv3d(in_channel, self.inplane, kernel_size=3, stride=2, padding=1, bias=False)
self.bn1 = nn.BatchNorm3d(self.inplane)
self.relu = nn.ReLU(inplace=True)
self.layer1 = self._make_layer(block, 32, blocks=n_size, stride=1)
self.layer2 = self._make_layer(block, 36, blocks=n_size, stride=1)
self.layer3 = self._make_layer(block, 40, blocks=n_size, stride=1)
self.layer4 = upblock(40, 36, 36, stride=1)
self.inplane = 36
self.layer5 = self._make_layer(block, 36, blocks=n_size-1, stride=1)
self.layer6 = upblock(36, 32, 32, stride=1)
self.inplane = 32
self.layer7 = self._make_layer(block, 32, blocks=n_size-1, stride=1)
self.layer8 = upblock(32, 28, 28, stride=1)
self.inplane = 28
self.layer9 = self._make_layer(block, 28, blocks=n_size-1, stride=1)
self.inplane = 28
self.layer10 = upblock(28, 1, 14, stride=2)
self.layer11 = nn.Sequential(#nn.Conv3d(16, 14, kernel_size=3, stride=1, padding=1, bias=True),
#nn.ReLU(inplace=True),
nn.Conv3d(14, num_classes, kernel_size=3, stride=1, padding=1, bias=True))
# self.outconv = nn.ConvTranspose3d(self.inplane, num_classes, 2, stride=2)
self.initialize()
Example #5
| Source File: submodule.py From DSGN with MIT License | 6 votes |
|
def __init__(self, inplanes, gn=False):
super(hourglass, self).__init__()
self.conv1 = nn.Sequential(convbn_3d(inplanes, inplanes * 2, kernel_size=3, stride=2, pad=1, gn=gn),
nn.ReLU(inplace=True))
self.conv2 = convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=1, pad=1, gn=gn)
self.conv3 = nn.Sequential(convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=2, pad=1, gn=gn),
nn.ReLU(inplace=True))
self.conv4 = nn.Sequential(convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=1, pad=1, gn=gn),
nn.ReLU(inplace=True))
self.conv5 = nn.Sequential(
nn.ConvTranspose3d(inplanes * 2, inplanes * 2, kernel_size=3, padding=1, output_padding=1, stride=2,
bias=False),
nn.BatchNorm3d(inplanes * 2) if not gn else nn.GroupNorm(32, inplanes * 2)) # +conv2
self.conv6 = nn.Sequential(
nn.ConvTranspose3d(inplanes * 2, inplanes, kernel_size=3, padding=1, output_padding=1, stride=2,
bias=False),
nn.BatchNorm3d(inplanes) if not gn else nn.GroupNorm(32, inplanes)) # +x
Example #6
| Source File: baselineSERes18Sum.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 6 votes |
|
def __init__(self, block, upblock, upblock1, n_size, num_classes=2, in_channel=1): # BasicBlock, 3
super(ResNetUNET3D, self).__init__()
self.inplane = 22
self.conv1 = nn.Conv3d(in_channel, self.inplane, kernel_size=3, stride=2, padding=1, bias=False)
self.bn1 = nn.BatchNorm3d(self.inplane)
self.relu = nn.ReLU(inplace=True)
self.layer1 = self._make_layer(block, 22, blocks=n_size, stride=1)
self.layer2 = self._make_layer(block, 22, blocks=n_size, stride=1)
self.layer3 = self._make_layer(block, 22, blocks=n_size, stride=1)
self.layer4 = upblock(22, 22, 22, stride=1)
self.inplane = 22
self.layer5 = self._make_layer(block, 22, blocks=n_size-1, stride=1)
self.layer6 = upblock(22, 22, 22, stride=1)
self.inplane = 22
self.layer7 = self._make_layer(block, 22, blocks=n_size-1, stride=1)
self.layer8 = upblock(22, 22, 22, stride=1)
self.inplane = 22
self.layer9 = self._make_layer(block, 22, blocks=n_size-1, stride=1)
self.inplane = 22
self.layer10 = upblock1(22, 1, 14, stride=2)
self.layer11 = nn.Sequential(#nn.Conv3d(16, 14, kernel_size=3, stride=1, padding=1, bias=True),
#nn.ReLU(inplace=True),
nn.Conv3d(14, num_classes, kernel_size=3, stride=1, padding=1, bias=True))
# self.outconv = nn.ConvTranspose3d(self.inplane, num_classes, 2, stride=2)
self.initialize()
Example #7
| Source File: highresnet_3D.py From pytorch-mri-segmentation-3D with MIT License | 6 votes |
|
def __init__(self,NoLabels):
super(HighResNet,self).__init__()
self.conv1 = nn.Conv3d(1, 16, kernel_size=3, stride=2, padding=1, bias=False)
self.bn1 = nn.BatchNorm3d(16, affine = affine_par)
for i in self.bn1.parameters():
i.requires_grad = False
self.relu = nn.PReLU()
self.block1_1 = HighResNetBlock(inplanes=16, outplanes=16, padding_=1, dilation_=1)
self.block2_1 = HighResNetBlock(inplanes=16, outplanes=32, padding_=2, dilation_=2)
self.block2_2 = HighResNetBlock(inplanes=32, outplanes=32, padding_=2, dilation_=2)
self.block3_1 = HighResNetBlock(inplanes=32, outplanes=64, padding_=4, dilation_=4)
self.block3_2 = HighResNetBlock(inplanes=64, outplanes=64, padding_=4, dilation_=4)
self.conv2 = nn.Conv3d(64, 80, kernel_size=1, stride=1, padding=0, bias=False)
self.upsample = nn.ConvTranspose3d(80, 80, kernel_size=2, stride=2, bias=False)
self.conv3 = nn.Conv3d(80, NoLabels, kernel_size=1, stride=1, padding=0, bias=False)
Example #8
| Source File: baselineSERes18Conc.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 6 votes |
|
def __init__(self, block, upblock, upblock1, n_size, num_classes=2, in_channel=1): # BasicBlock, 3
super(ResNetUNET3D, self).__init__()
self.inplane = 28
self.conv1 = nn.Conv3d(in_channel, self.inplane, kernel_size=3, stride=2, padding=1, bias=False)
self.bn1 = nn.BatchNorm3d(self.inplane)
self.relu = nn.ReLU(inplace=True)
self.layer1 = self._make_layer(block, 30, blocks=n_size, stride=1)
self.layer2 = self._make_layer(block, 32, blocks=n_size, stride=1)
self.layer3 = self._make_layer(block, 34, blocks=n_size, stride=1)
self.layer4 = upblock(34, 32, 32, stride=1)
self.inplane = 32
self.layer5 = self._make_layer(block, 32, blocks=n_size-1, stride=1)
self.layer6 = upblock(32, 30, 30, stride=1)
self.inplane = 30
self.layer7 = self._make_layer(block, 30, blocks=n_size-1, stride=1)
self.layer8 = upblock(30, 28, 28, stride=1)
self.inplane = 28
self.layer9 = self._make_layer(block, 28, blocks=n_size-1, stride=1)
self.inplane = 28
self.layer10 = upblock1(28, 1, 14, stride=2)
self.layer11 = nn.Sequential(#nn.Conv3d(16, 14, kernel_size=3, stride=1, padding=1, bias=True),
#nn.ReLU(inplace=True),
nn.Conv3d(14, num_classes, kernel_size=3, stride=1, padding=1, bias=True))
# self.outconv = nn.ConvTranspose3d(self.inplane, num_classes, 2, stride=2)
self.initialize()
Example #9
| Source File: baselineRes18Sum.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 6 votes |
|
def __init__(self, block, upblock, n_size, num_classes=2, in_channel=1): # BasicBlock, 3
super(ResNetUNET3D, self).__init__()
self.inplane = 22
self.conv1 = nn.Conv3d(in_channel, self.inplane, kernel_size=3, stride=2, padding=1, bias=False)
self.bn1 = nn.BatchNorm3d(self.inplane)
self.relu = nn.ReLU(inplace=True)
self.layer1 = self._make_layer(block, 22, blocks=n_size, stride=1)
self.layer2 = self._make_layer(block, 22, blocks=n_size, stride=1)
self.layer3 = self._make_layer(block, 22, blocks=n_size, stride=1)
self.layer4 = upblock(22, 22, 22, stride=1)
self.inplane = 22
self.layer5 = self._make_layer(block, 22, blocks=n_size-1, stride=1)
self.layer6 = upblock(22, 22, 22, stride=1)
self.inplane = 22
self.layer7 = self._make_layer(block, 22, blocks=n_size-1, stride=1)
self.layer8 = upblock(22, 22, 22, stride=1)
self.inplane = 22
self.layer9 = self._make_layer(block, 22, blocks=n_size-1, stride=1)
self.inplane = 22
self.layer10 = upblock(22, 1, 14, stride=2)
self.layer11 = nn.Sequential(#nn.Conv3d(20, 20, kernel_size=3, stride=1, padding=1, bias=True),
#nn.ReLU(inplace=True),
nn.Conv3d(14, num_classes, kernel_size=3, stride=1, padding=1, bias=True))
# self.outconv = nn.ConvTranspose3d(self.inplane, num_classes, 2, stride=2)
self.initialize()
Example #10
| Source File: blocks.py From pytorch-UNet with MIT License | 6 votes |
|
def __init__(self, in_channels, middle_channels, out_channels, deconv_channels, dropout=False):
super(Center3D, self).__init__()
layers = [
nn.MaxPool3d(kernel_size=2),
nn.Conv3d(in_channels, middle_channels, kernel_size=3, padding=1),
nn.BatchNorm3d(middle_channels),
nn.ReLU(inplace=True),
nn.Conv3d(middle_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm3d(out_channels),
nn.ReLU(inplace=True),
nn.ConvTranspose3d(out_channels, deconv_channels, kernel_size=2, stride=2)
]
if dropout:
assert 0 <= dropout <= 1, 'dropout must be between 0 and 1'
layers.append(nn.Dropout3d(p=dropout))
self.center = nn.Sequential(*layers)
Example #11
| Source File: util_conv.py From DSMnet with Apache License 2.0 | 6 votes |
|
def deconv3d_bn(in_planes, out_planes, kernel_size=4, stride=2, flag_bias=flag_bias_default, bn=flag_bn, activefun=activefun_default):
"3d deconvolution with padding, bn and activefun"
assert stride > 1
p = (kernel_size - 1)//2
op = stride - (kernel_size - 2*p)
conv2d = ConvTranspose3d(in_planes, out_planes, kernel_size, stride, padding=p, output_padding=op, bias=flag_bias)
if(not bn and not activefun):
return conv2d
layers = []
layers.append(conv2d)
if bn: layers.append(nn.BatchNorm2d(out_planes))
if activefun: layers.append(activefun)
return nn.Sequential(*layers)
Example #12
| Source File: basic_layers.py From DenseMatchingBenchmark with MIT License | 6 votes |
|
def deconv3d_bn_relu(batchNorm, in_planes, out_planes, kernel_size=4, stride=2, padding=1, output_padding=0, bias=True):
if batchNorm:
return nn.Sequential(
nn.ConvTranspose3d(
in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, output_padding=output_padding, bias=bias),
nn.BatchNorm3d(out_planes),
nn.ReLU(inplace=True),
)
else:
return nn.Sequential(
nn.ConvTranspose3d(
in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, output_padding=output_padding, bias=bias
),
nn.ReLU(inplace=True),
)
Example #13
| Source File: blocks.py From pytorch-UNet with MIT License | 6 votes |
|
def __init__(self, in_channels, middle_channels, out_channels, deconv_channels, dropout=False):
super(Decoder3D, self).__init__()
layers = [
nn.Conv3d(in_channels, middle_channels, kernel_size=3, padding=1),
nn.BatchNorm3d(middle_channels),
nn.ReLU(inplace=True),
nn.Conv3d(middle_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm3d(out_channels),
nn.ReLU(inplace=True),
nn.ConvTranspose3d(out_channels, deconv_channels, kernel_size=2, stride=2)
]
if dropout:
assert 0 <= dropout <= 1, 'dropout must be between 0 and 1'
layers.append(nn.Dropout3d(p=dropout))
self.decoder = nn.Sequential(*layers)
Example #14
| Source File: mrcnn.py From RegRCNN with Apache License 2.0 | 6 votes |
|
def __init__(self, cf, conv):
super(Mask, self).__init__()
self.pool_size = cf.mask_pool_size
self.pyramid_levels = cf.pyramid_levels
self.dim = conv.dim
self.conv1 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv2 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv3 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
self.conv4 = conv(cf.end_filts, cf.end_filts, ks=3, stride=1, pad=1, norm=cf.norm, relu=cf.relu)
if conv.dim == 2:
self.deconv = nn.ConvTranspose2d(cf.end_filts, cf.end_filts, kernel_size=2, stride=2) # todo why no norm here?
else:
self.deconv = nn.ConvTranspose3d(cf.end_filts, cf.end_filts, kernel_size=2, stride=2)
self.relu = nn.ReLU(inplace=True) if cf.relu == 'relu' else nn.LeakyReLU(inplace=True)
self.conv5 = conv(cf.end_filts, cf.head_classes, ks=1, stride=1, relu=None)
self.sigmoid = nn.Sigmoid()
Example #15
| Source File: deconvolution.py From PyMIC with Apache License 2.0 | 6 votes |
|
def __init__(self, in_channels, out_channels, kernel_size,
dim = 3, stride = 1, padding = 0, output_padding = 0,
dilation =1, groups = 1, bias = True,
batch_norm = True, acti_func = None):
super(DeconvolutionLayer, self).__init__()
self.n_in_chns = in_channels
self.n_out_chns = out_channels
self.batch_norm = batch_norm
self.acti_func = acti_func
assert(dim == 2 or dim == 3)
if(dim == 2):
self.conv = nn.ConvTranspose2d(in_channels, out_channels,
kernel_size, stride, padding, output_padding,
groups, bias, dilation)
if(self.batch_norm):
self.bn = nn.BatchNorm2d(out_channels)
else:
self.conv = nn.ConvTranspose3d(in_channels, out_channels,
kernel_size, stride, padding, output_padding,
groups, bias, dilation)
if(self.batch_norm):
self.bn = nn.BatchNorm3d(out_channels)
Example #16
| Source File: stackhourglass.py From Pseudo_Lidar_V2 with MIT License | 6 votes |
|
def __init__(self, inplanes):
super(hourglass, self).__init__()
self.conv1 = nn.Sequential(convbn_3d(inplanes, inplanes * 2, kernel_size=3, stride=2, pad=1),
nn.ReLU(inplace=True))
self.conv2 = convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=1, pad=1)
self.conv3 = nn.Sequential(convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=2, pad=1),
nn.ReLU(inplace=True))
self.conv4 = nn.Sequential(convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=1, pad=1),
nn.ReLU(inplace=True))
self.conv5 = nn.Sequential(
nn.ConvTranspose3d(inplanes * 2, inplanes * 2, kernel_size=3, padding=1, output_padding=1, stride=2,
bias=False),
nn.BatchNorm3d(inplanes * 2)) # +conv2
self.conv6 = nn.Sequential(
nn.ConvTranspose3d(inplanes * 2, inplanes, kernel_size=3, padding=1, output_padding=1, stride=2,
bias=False),
nn.BatchNorm3d(inplanes)) # +x
Example #17
| Source File: unet2d5.py From PyMIC with Apache License 2.0 | 6 votes |
|
def __init__(self, in_channels1, in_channels2, out_channels,
dim = 2, dropout_p = 0.0, bilinear=True):
super(UpBlock, self).__init__()
self.bilinear = bilinear
self.dim = dim
if bilinear:
if(dim == 2):
self.up = nn.Sequential(
nn.Conv2d(in_channels1, in_channels2, kernel_size = 1),
nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True))
else:
self.up = nn.Sequential(
nn.Conv3d(in_channels1, in_channels2, kernel_size = 1),
nn.Upsample(scale_factor=2, mode='trilinear', align_corners=True))
else:
if(dim == 2):
self.up = nn.ConvTranspose2d(in_channels1, in_channels2, kernel_size=2, stride=2)
else:
self.up = nn.ConvTranspose3d(in_channels1, in_channels2, kernel_size=2, stride=2)
self.conv = ConvBlockND(in_channels2 * 2, out_channels, dim, dropout_p)
Example #18
| Source File: stackedhourglass.py From PSMNet with MIT License | 6 votes |
|
def __init__(self):
super().__init__()
self.net1 = nn.Sequential(
Conv3dBn(in_channels=32, out_channels=64, kernel_size=3, stride=2, padding=1, dilation=1, use_relu=True),
Conv3dBn(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1, dilation=1, use_relu=False)
)
self.net2 = nn.Sequential(
Conv3dBn(in_channels=64, out_channels=64, kernel_size=3, stride=2, padding=1, dilation=1, use_relu=True),
Conv3dBn(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1, dilation=1, use_relu=True)
)
self.net3 = nn.Sequential(
nn.ConvTranspose3d(in_channels=64, out_channels=64, kernel_size=3, stride=2, padding=1, output_padding=1, bias=False),
nn.BatchNorm3d(num_features=64)
# nn.ReLU(inplace=True)
)
self.net4 = nn.Sequential(
nn.ConvTranspose3d(in_channels=64, out_channels=32, kernel_size=3, stride=2, padding=1, output_padding=1, bias=False),
nn.BatchNorm3d(num_features=32)
)
Example #19
| Source File: nnBuildUnits.py From medSynthesisV1 with MIT License | 6 votes |
|
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, nd=2):
super(convTranspose23D_bn_Unit, self).__init__()
assert nd==1 or nd==2 or nd==3, 'nd is not correctly specified!!!!, it should be {1,2,3}'
if nd==2:
self.conv = nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, output_padding=output_padding, groups=groups, bias=bias, dilation=dilation)
self.bn = nn.BatchNorm2d(out_channels)
elif nd==3:
self.conv = nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, output_padding=output_padding, groups=groups, bias=bias, dilation=dilation)
self.bn = nn.BatchNorm3d(out_channels)
else:
self.conv = nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, output_padding=output_padding, groups=groups, bias=bias, dilation=dilation)
self.bn = nn.BatchNorm1d(out_channels)
init.xavier_uniform(self.conv.weight, gain = np.sqrt(2.0))
init.constant(self.conv.bias, 0)
# self.relu = nn.ReLU()
Example #20
| Source File: nnBuildUnits.py From medSynthesisV1 with MIT License | 6 votes |
|
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, nd=2):
super(convTranspose23D_bn_relu_Unit, self).__init__()
assert nd==1 or nd==2 or nd==3, 'nd is not correctly specified!!!!, it should be {1,2,3}'
if nd==2:
self.conv = nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, output_padding=output_padding, groups=groups, bias=bias, dilation=dilation)
self.bn = nn.BatchNorm2d(out_channels)
elif nd==3:
self.conv = nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, output_padding=output_padding, groups=groups, bias=bias, dilation=dilation)
self.bn = nn.BatchNorm3d(out_channels)
else:
self.conv = nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, output_padding=output_padding, groups=groups, bias=bias, dilation=dilation)
self.bn = nn.BatchNorm1d(out_channels)
init.xavier_uniform(self.conv.weight, gain = np.sqrt(2.0))
init.constant(self.conv.bias, 0)
self.relu = nn.ReLU()
Example #21
| Source File: modules.py From PlaneNet with MIT License | 6 votes |
|
def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, padding=None, mode='conv'):
super(ConvBlock, self).__init__()
if padding == None:
padding = (kernel_size - 1) // 2
pass
if mode == 'conv':
self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)
elif mode == 'deconv':
self.conv = nn.ConvTranspose2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)
elif mode == 'conv_3d':
self.conv = nn.Conv3d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)
elif mode == 'deconv_3d':
self.conv = nn.ConvTranspose3d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)
else:
print('conv mode not supported', mode)
exit(1)
pass
if '3d' not in mode:
self.bn = nn.BatchNorm2d(out_planes)
else:
self.bn = nn.BatchNorm3d(out_planes)
pass
self.relu = nn.ReLU(inplace=True)
return
Example #22
| Source File: baselineSERes18Sum.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 5 votes |
|
def initialize(self):
for m in self.modules():
if isinstance(m, nn.Conv3d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm3d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.ConvTranspose3d):
nn.init.kaiming_normal_(m.weight)
Example #23
| Source File: baselineRes18Conc.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 5 votes |
|
def Deconv3x3x3(in_planes, out_planes, stride=2):
"3x3x3 deconvolution with padding"
return nn.ConvTranspose3d(in_planes, out_planes, kernel_size=2, stride=stride) #, bias=False)
Example #24
| Source File: v2v.py From learnable-triangulation-pytorch with MIT License | 5 votes |
|
def _initialize_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv3d):
nn.init.xavier_normal_(m.weight)
# nn.init.normal_(m.weight, 0, 0.001)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.ConvTranspose3d):
nn.init.xavier_normal_(m.weight)
# nn.init.normal_(m.weight, 0, 0.001)
nn.init.constant_(m.bias, 0)
Example #25
| Source File: baselineRes18Sum.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 5 votes |
|
def Deconv3x3x3(in_planes, out_planes, stride=2):
"3x3x3 deconvolution with padding"
return nn.ConvTranspose3d(in_planes, out_planes, kernel_size=2, stride=stride) #, bias=False)
Example #26
| Source File: baselineSERes18Sum.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 5 votes |
|
def Deconv3x3x3(in_planes, out_planes, stride=2):
"3x3x3 deconvolution with padding"
return nn.ConvTranspose3d(in_planes, out_planes, kernel_size=2, stride=stride)
Example #27
| Source File: baselineRes18Sum.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 5 votes |
|
def initialize(self):
for m in self.modules():
if isinstance(m, nn.Conv3d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm3d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.ConvTranspose3d):
nn.init.kaiming_normal_(m.weight)
Example #28
| Source File: v2v.py From learnable-triangulation-pytorch with MIT License | 5 votes |
|
def __init__(self, in_planes, out_planes, kernel_size, stride):
super(Upsample3DBlock, self).__init__()
assert(kernel_size == 2)
assert(stride == 2)
self.block = nn.Sequential(
nn.ConvTranspose3d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=0, output_padding=0),
nn.BatchNorm3d(out_planes),
nn.ReLU(True)
)
Example #29
| Source File: AnatomyNet.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 5 votes |
|
def initialize(self):
for m in self.modules():
if isinstance(m, nn.Conv3d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm3d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.ConvTranspose3d):
nn.init.kaiming_normal_(m.weight)
Example #30
| Source File: AnatomyNet.py From AnatomyNet-for-anatomical-segmentation with Apache License 2.0 | 5 votes |
|
def Deconv3x3x3(in_planes, out_planes, stride=2):
"3x3x3 deconvolution with padding"
return nn.ConvTranspose3d(in_planes, out_planes, kernel_size=2, stride=stride)
