Python torch.nn.MaxUnpool3d() Examples
The following are 6
code examples of torch.nn.MaxUnpool3d().
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: autoencoder.py From AD-DL with MIT License | 6 votes |
|
def forward(self, x):
indices_list = []
pad_list = []
for layer in self.encoder:
if isinstance(layer, PadMaxPool3d):
x, indices, pad = layer(x)
indices_list.append(indices)
pad_list.append(pad)
elif isinstance(layer, nn.MaxPool3d):
x, indices = layer(x)
indices_list.append(indices)
else:
x = layer(x)
for layer in self.decoder:
if isinstance(layer, CropMaxUnpool3d):
x = layer(x, indices_list.pop(), pad_list.pop())
elif isinstance(layer, nn.MaxUnpool3d):
x = layer(x, indices_list.pop())
else:
x = layer(x)
return x
Example #2
| Source File: decoder.py From occupancy_networks with MIT License | 5 votes |
|
def __init__(self, T=256, W=32, H=32, D=32, skip_connection=True):
super(SurfaceDecoder, self).__init__()
self.W = W
self.H = H
self.D = D
self.T = T
self.actvn = nn.ReLU()
self.Occ2Top = OccupancyToTopology()
# decoder
self.deconv4 = nn.Conv3d(128, 64, 3, padding=1)
self.deconv3_1 = nn.ConvTranspose3d(128, 128, 3, padding=1)
self.deconv3_2 = nn.ConvTranspose3d(128, 32, 3, padding=1)
self.deconv2_off_1 = nn.ConvTranspose3d(64, 64, 3, padding=1)
self.deconv2_off_2 = nn.ConvTranspose3d(64, 16, 3, padding=1)
self.deconv2_occ_1 = nn.ConvTranspose3d(64, 64, 3, padding=1)
self.deconv2_occ_2 = nn.ConvTranspose3d(64, 16, 3, padding=1)
self.deconv1_off_1 = nn.ConvTranspose3d(32, 32, 3, padding=1)
self.deconv1_off_2 = nn.ConvTranspose3d(32, 3, 3, padding=3)
self.deconv1_occ_1 = nn.ConvTranspose3d(32, 32, 3, padding=1)
self.deconv1_occ_2 = nn.ConvTranspose3d(32, 1, 3, padding=3)
# batchnorm
self.deconv4_bn = nn.BatchNorm3d(64)
self.deconv3_1_bn = nn.BatchNorm3d(128)
self.deconv3_2_bn = nn.BatchNorm3d(32)
self.deconv2_off_1_bn = nn.BatchNorm3d(64)
self.deconv2_off_2_bn = nn.BatchNorm3d(16)
self.deconv2_occ_1_bn = nn.BatchNorm3d(64)
self.deconv2_occ_2_bn = nn.BatchNorm3d(16)
self.deconv1_off_1_bn = nn.BatchNorm3d(32)
self.deconv1_occ_1_bn = nn.BatchNorm3d(32)
self.sigmoid = nn.Sigmoid()
self.maxunpool = nn.MaxUnpool3d(2)
self.skip_connection = skip_connection
Example #3
| Source File: modules.py From AD-DL with MIT License | 5 votes |
|
def __init__(self, kernel_size, stride):
super(CropMaxUnpool3d, self).__init__()
self.unpool = nn.MaxUnpool3d(kernel_size, stride)
Example #4
| Source File: autoencoder.py From AD-DL with MIT License | 5 votes |
|
def construct_inv_layers(self, model):
"""
Implements the decoder part from the CNN. The decoder part is the symmetrical list of the encoder
in which some layers are replaced by their transpose counterpart.
ConvTranspose and ReLU layers are inverted in the end.
:param model: (Module) a CNN. The convolutional part must be comprised in a 'features' class variable.
:return: (Module) decoder part of the Autoencoder
"""
inv_layers = []
for i, layer in enumerate(self.encoder):
if isinstance(layer, nn.Conv3d):
inv_layers.append(nn.ConvTranspose3d(layer.out_channels, layer.in_channels, layer.kernel_size,
stride=layer.stride, padding=layer.padding))
self.level += 1
elif isinstance(layer, PadMaxPool3d):
inv_layers.append(CropMaxUnpool3d(layer.kernel_size, stride=layer.stride))
elif isinstance(layer, nn.MaxPool3d):
inv_layers.append(nn.MaxUnpool3d(layer.kernel_size, stride=layer.stride))
elif isinstance(layer, nn.Linear):
inv_layers.append(nn.Linear(layer.out_features, layer.in_features))
elif isinstance(layer, Flatten):
inv_layers.append(Reshape(model.flattened_shape))
elif isinstance(layer, nn.LeakyReLU):
inv_layers.append(nn.LeakyReLU(negative_slope=1 / layer.negative_slope))
else:
inv_layers.append(deepcopy(layer))
inv_layers = self.replace_relu(inv_layers)
inv_layers.reverse()
return nn.Sequential(*inv_layers)
Example #5
| Source File: res18.py From DeepLung with GNU General Public License v3.0 | 4 votes |
|
def __init__(self):
super(Net, self).__init__()
# The first few layers consumes the most memory, so use simple convolution to save memory.
# Call these layers preBlock, i.e., before the residual blocks of later layers.
self.preBlock = nn.Sequential(
nn.Conv3d(1, 24, kernel_size = 3, padding = 1),
nn.BatchNorm3d(24),
nn.ReLU(inplace = True),
nn.Conv3d(24, 24, kernel_size = 3, padding = 1),
nn.BatchNorm3d(24),
nn.ReLU(inplace = True))
# 3 poolings, each pooling downsamples the feature map by a factor 2.
# 3 groups of blocks. The first block of each group has one pooling.
num_blocks_forw = [2,2,3,3]
num_blocks_back = [3,3]
self.featureNum_forw = [24,32,64,64,64]
self.featureNum_back = [128,64,64]
for i in range(len(num_blocks_forw)):
blocks = []
for j in range(num_blocks_forw[i]):
if j == 0:
blocks.append(PostRes(self.featureNum_forw[i], self.featureNum_forw[i+1]))
else:
blocks.append(PostRes(self.featureNum_forw[i+1], self.featureNum_forw[i+1]))
setattr(self, 'forw' + str(i + 1), nn.Sequential(*blocks))
for i in range(len(num_blocks_back)):
blocks = []
for j in range(num_blocks_back[i]):
if j == 0:
if i==0:
addition = 3
else:
addition = 0
blocks.append(PostRes(self.featureNum_back[i+1]+self.featureNum_forw[i+2]+addition, self.featureNum_back[i]))
else:
blocks.append(PostRes(self.featureNum_back[i], self.featureNum_back[i]))
setattr(self, 'back' + str(i + 2), nn.Sequential(*blocks))
self.maxpool1 = nn.MaxPool3d(kernel_size=2,stride=2,return_indices =True)
self.maxpool2 = nn.MaxPool3d(kernel_size=2,stride=2,return_indices =True)
self.maxpool3 = nn.MaxPool3d(kernel_size=2,stride=2,return_indices =True)
self.maxpool4 = nn.MaxPool3d(kernel_size=2,stride=2,return_indices =True)
self.unmaxpool1 = nn.MaxUnpool3d(kernel_size=2,stride=2)
self.unmaxpool2 = nn.MaxUnpool3d(kernel_size=2,stride=2)
self.path1 = nn.Sequential(
nn.ConvTranspose3d(64, 64, kernel_size = 2, stride = 2),
nn.BatchNorm3d(64),
nn.ReLU(inplace = True))
self.path2 = nn.Sequential(
nn.ConvTranspose3d(64, 64, kernel_size = 2, stride = 2),
nn.BatchNorm3d(64),
nn.ReLU(inplace = True))
self.drop = nn.Dropout3d(p = 0.5, inplace = False)
self.output = nn.Sequential(nn.Conv3d(self.featureNum_back[0], 64, kernel_size = 1),
nn.ReLU(),
#nn.Dropout3d(p = 0.3),
nn.Conv3d(64, 5 * len(config['anchors']), kernel_size = 1))
Example #6
| Source File: res18.py From DeepSEED-3D-ConvNets-for-Pulmonary-Nodule-Detection with MIT License | 4 votes |
|
def __init__(self):
super(Net, self).__init__()
# The first few layers consumes the most memory, so use simple convolution to save memory.
# Call these layers preBlock, i.e., before the residual blocks of later layers.
self.preBlock = nn.Sequential(
nn.Conv3d(1, 24, kernel_size = 3, padding = 1),
nn.BatchNorm3d(24),
nn.ReLU(inplace = True),
nn.Conv3d(24, 24, kernel_size = 3, padding = 1),
nn.BatchNorm3d(24),
nn.ReLU(inplace = True))
# 3 poolings, each pooling downsamples the feature map by a factor 2.
# 3 groups of blocks. The first block of each group has one pooling.
num_blocks_forw = [2,2,3,3]
num_blocks_back = [3,3]
self.featureNum_forw = [24,32,64,64,64]
self.featureNum_back = [128,64,64]
for i in range(len(num_blocks_forw)):
blocks = []
for j in range(num_blocks_forw[i]):
if j == 0:
blocks.append(PostRes(self.featureNum_forw[i], self.featureNum_forw[i+1]))
else:
blocks.append(PostRes(self.featureNum_forw[i+1], self.featureNum_forw[i+1]))
setattr(self, 'forw' + str(i + 1), nn.Sequential(*blocks))
for i in range(len(num_blocks_back)):
blocks = []
for j in range(num_blocks_back[i]):
if j == 0:
if i==0:
addition = 3
else:
addition = 0
blocks.append(PostRes(self.featureNum_back[i+1]+self.featureNum_forw[i+2]+addition, self.featureNum_back[i]))
else:
blocks.append(PostRes(self.featureNum_back[i], self.featureNum_back[i]))
setattr(self, 'back' + str(i + 2), nn.Sequential(*blocks))
self.maxpool1 = nn.MaxPool3d(kernel_size=2,stride=2,return_indices =True)
self.maxpool2 = nn.MaxPool3d(kernel_size=2,stride=2,return_indices =True)
self.maxpool3 = nn.MaxPool3d(kernel_size=2,stride=2,return_indices =True)
self.maxpool4 = nn.MaxPool3d(kernel_size=2,stride=2,return_indices =True)
self.unmaxpool1 = nn.MaxUnpool3d(kernel_size=2,stride=2)
self.unmaxpool2 = nn.MaxUnpool3d(kernel_size=2,stride=2)
self.path1 = nn.Sequential(
nn.ConvTranspose3d(64, 64, kernel_size = 2, stride = 2),
nn.BatchNorm3d(64),
nn.ReLU(inplace = True))
self.path2 = nn.Sequential(
nn.ConvTranspose3d(64, 64, kernel_size = 2, stride = 2),
nn.BatchNorm3d(64),
nn.ReLU(inplace = True))
self.drop = nn.Dropout3d(p = 0.5, inplace = False)
self.output = nn.Sequential(nn.Conv3d(self.featureNum_back[0], 64, kernel_size = 1),
nn.ReLU(),
#nn.Dropout3d(p = 0.3),
nn.Conv3d(64, 5 * len(config['anchors']), kernel_size = 1))
