Python torch.nn.Dropout3d() Examples
The following are 30
code examples of torch.nn.Dropout3d().
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
.
![](https://www.programcreek.com/common/static/images/search.png)
Example #1
Source File: nnUNetTrainerV2_ReLU.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.ReLU net_nonlin_kwargs = {'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(0), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #2
Source File: nnUNetTrainerV2_ReLU_biasInSegOutput.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.ReLU net_nonlin_kwargs = {'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(0), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True, seg_output_use_bias=True) self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #3
Source File: nnUNetTrainerV2_LReLU_slope_2en1.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'inplace': True, 'negative_slope': 2e-1} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(0), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #4
Source File: nnUNetTrainerV2_3ConvPerStage_samefilters.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'negative_slope': 1e-2, 'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), 3, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(1e-2), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #5
Source File: nnUNetTrainerV2_ReLU_convReLUIN.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.ReLU net_nonlin_kwargs = {'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(0), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True, basic_block=ConvDropoutNonlinNorm) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #6
Source File: ResUnet3d_pytorch.py From medSynthesisV1 with MIT License | 6 votes |
def __init__(self, in_channel=1, n_classes=4, dp_prob=0): super(ResUNet_LRes, self).__init__() # self.imsize = imsize self.activation = F.relu self.pool1 = nn.MaxPool3d(2) self.pool2 = nn.MaxPool3d(2) self.pool3 = nn.MaxPool3d(2) # self.pool4 = nn.MaxPool3d(2) self.conv_block1_64 = UNetConvBlock(in_channel, 32) self.conv_block64_128 = residualUnit(32, 64) self.conv_block128_256 = residualUnit(64, 128) self.conv_block256_512 = residualUnit(128, 256) # self.conv_block512_1024 = residualUnit(512, 1024) # this kind of symmetric design is awesome, it automatically solves the number of channels during upsamping # self.up_block1024_512 = UNetUpResBlock(1024, 512) self.up_block512_256 = UNetUpResBlock(256, 128) self.up_block256_128 = UNetUpResBlock(128, 64) self.up_block128_64 = UNetUpResBlock(64, 32) self.Dropout = nn.Dropout3d(p=dp_prob) self.last = nn.Conv3d(32, n_classes, 1, stride=1)
Example #7
Source File: nnUNetTrainerV2_3ConvPerStage.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): self.base_num_features = 24 # otherwise we run out of VRAM if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'negative_slope': 1e-2, 'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), 3, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(1e-2), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #8
Source File: S3DG_Pytorch.py From s3d.pytorch with MIT License | 6 votes |
def __init__(self, num_classes=400, dropout_keep_prob = 1, input_channel = 3, spatial_squeeze=True): super(S3DG, self).__init__() self.features = nn.Sequential( STConv3d(input_channel, 64, kernel_size=7, stride=2, padding=3), # (64, 32, 112, 112) nn.MaxPool3d(kernel_size=(1,3,3), stride=(1,2,2), padding=(0,1,1)), # (64, 32, 56, 56) BasicConv3d(64, 64, kernel_size=1, stride=1), # (64, 32, 56, 56) STConv3d(64, 192, kernel_size=3, stride=1, padding=1), # (192, 32, 56, 56) nn.MaxPool3d(kernel_size=(1,3,3), stride=(1,2,2), padding=(0,1,1)), # (192, 32, 28, 28) Mixed_3b(), # (256, 32, 28, 28) Mixed_3c(), # (480, 32, 28, 28) nn.MaxPool3d(kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=(1, 1, 1)), # (480, 16, 14, 14) Mixed_4b(),# (512, 16, 14, 14) Mixed_4c(),# (512, 16, 14, 14) Mixed_4d(),# (512, 16, 14, 14) Mixed_4e(),# (528, 16, 14, 14) Mixed_4f(),# (832, 16, 14, 14) nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2), padding=(0, 0, 0)), # (832, 8, 7, 7) Mixed_5b(), # (832, 8, 7, 7) Mixed_5c(), # (1024, 8, 7, 7) nn.AvgPool3d(kernel_size=(2, 7, 7), stride=1),# (1024, 8, 1, 1) nn.Dropout3d(dropout_keep_prob), nn.Conv3d(1024, num_classes, kernel_size=1, stride=1, bias=True),# (400, 8, 1, 1) ) self.spatial_squeeze = spatial_squeeze self.softmax = nn.Softmax()
Example #9
Source File: noNewReversible.py From PartiallyReversibleUnet with BSD 3-Clause "New" or "Revised" License | 6 votes |
def __init__(self): super(NoNewReversible, self).__init__() depth = 1 self.levels = 5 self.firstConv = nn.Conv3d(4, CHANNELS[0], 3, padding=1, bias=False) #self.dropout = nn.Dropout3d(0.2, True) self.lastConv = nn.Conv3d(CHANNELS[0], 3, 1, bias=True) #create encoder levels encoderModules = [] for i in range(self.levels): encoderModules.append(EncoderModule(getChannelsAtIndex(i - 1), getChannelsAtIndex(i), depth, i != 0)) self.encoders = nn.ModuleList(encoderModules) #create decoder levels decoderModules = [] for i in range(self.levels): decoderModules.append(DecoderModule(getChannelsAtIndex(self.levels - i - 1), getChannelsAtIndex(self.levels - i - 2), depth, i != (self.levels -1))) self.decoders = nn.ModuleList(decoderModules)
Example #10
Source File: nnUNetTrainerV2_Mish.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = Mish net_nonlin_kwargs = {} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(0), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #11
Source File: noNewReversibleFat.py From PartiallyReversibleUnet with BSD 3-Clause "New" or "Revised" License | 6 votes |
def __init__(self): super(NoNewReversible, self).__init__() encoderDepth = encDepth decoderDepth = 1 self.levels = 5 self.firstConv = nn.Conv3d(4, CHANNELS[0], 3, padding=1, bias=False) #self.dropout = nn.Dropout3d(0.2, True) self.lastConv = nn.Conv3d(CHANNELS[0], 3, 1, bias=True) #create encoder levels encoderModules = [] for i in range(self.levels): encoderModules.append(EncoderModule(getChannelsAtIndex(i - 1), getChannelsAtIndex(i), encoderDepth, i != 0)) self.encoders = nn.ModuleList(encoderModules) #create decoder levels decoderModules = [] for i in range(self.levels): decoderModules.append(DecoderModule(getChannelsAtIndex(self.levels - i - 1), getChannelsAtIndex(self.levels - i - 2), decoderDepth, i != (self.levels -1))) self.decoders = nn.ModuleList(decoderModules)
Example #12
Source File: nnUNetTrainerV2_lReLU_convlReLUIN.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'inplace': True, 'negative_slope': 1e-2} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(1e-2), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True, basic_block=ConvDropoutNonlinNorm) self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
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: 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 #15
Source File: blocks.py From pytorch-UNet with MIT License | 6 votes |
def __init__( self, in_channels, middle_channels, out_channels, dropout=False, downsample_kernel=2 ): super(Encoder3D, self).__init__() layers = [ nn.MaxPool3d(kernel_size=downsample_kernel), 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) ] if dropout: assert 0 <= dropout <= 1, 'dropout must be between 0 and 1' layers.append(nn.Dropout3d(p=dropout)) self.encoder = nn.Sequential(*layers)
Example #16
Source File: blocks.py From pytorch-UNet with MIT License | 6 votes |
def __init__(self, in_channels, middle_channels, out_channels, dropout=False): super(First3D, 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) ] if dropout: assert 0 <= dropout <= 1, 'dropout must be between 0 and 1' layers.append(nn.Dropout3d(p=dropout)) self.first = nn.Sequential(*layers)
Example #17
Source File: nnUNetTrainerV2_lReLU_biasInSegOutput.py From nnUNet with Apache License 2.0 | 6 votes |
def initialize_network(self): if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'negative_slope': 1e-2, 'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(0), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True, seg_output_use_bias=True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #18
Source File: drop_block.py From Magic-VNet with MIT License | 5 votes |
def __init__(self, drop_type): super(Drop, self).__init__() if drop_type is None: self.drop = keep_origin elif drop_type == 'alpha': self.drop = nn.AlphaDropout(p=0.5) elif drop_type == 'dropout': self.drop = nn.Dropout3d(p=0.5) elif drop_type == 'drop_block': self.drop = DropBlock3D(drop_prob=0.2, block_size=2) else: raise NotImplementedError('{} not implemented'.format(drop_type))
Example #19
Source File: vnet_new.py From pytorch_memonger with GNU General Public License v3.0 | 5 votes |
def __init__(self, inChans, outChans, nConvs, elu, dropout=False): super(UpTransition, self).__init__() self.up_conv = nn.ConvTranspose3d(inChans, outChans // 2, kernel_size=2, stride=2) self.bn1 = ContBatchNorm3d(outChans // 2) self.do1 = passthrough self.do2 = nn.Dropout3d() self.relu1 = ELUCons(elu, outChans // 2) self.relu2 = ELUCons(elu, outChans) if dropout: self.do1 = nn.Dropout3d() self.ops = _make_nConv(outChans, nConvs, elu)
Example #20
Source File: vnet_new.py From pytorch_memonger with GNU General Public License v3.0 | 5 votes |
def __init__(self, inChans, nConvs, elu, dropout=False): super(DownTransition, self).__init__() outChans = 2*inChans self.down_conv = nn.Conv3d(inChans, outChans, kernel_size=2, stride=2) self.bn1 = ContBatchNorm3d(outChans) self.do1 = passthrough self.relu1 = ELUCons(elu, outChans) self.relu2 = ELUCons(elu, outChans) if dropout: self.do1 = nn.Dropout3d() self.ops = _make_nConv(outChans, nConvs, elu)
Example #21
Source File: noNewNet.py From PartiallyReversibleUnet with BSD 3-Clause "New" or "Revised" License | 5 votes |
def __init__(self, inChannels, outChannels, maxpool=False, secondConv=True, hasDropout=False): super(EncoderModule, self).__init__() groups = min(outChannels, CHANNELS) self.maxpool = maxpool self.secondConv = secondConv self.hasDropout = hasDropout self.conv1 = nn.Conv3d(inChannels, outChannels, 3, padding=1, bias=False) self.gn1 = nn.GroupNorm(groups, outChannels) if secondConv: self.conv2 = nn.Conv3d(outChannels, outChannels, 3, padding=1, bias=False) self.gn2 = nn.GroupNorm(groups, outChannels) if hasDropout: self.dropout = nn.Dropout3d(0.2, True)
Example #22
Source File: HighResNet3D.py From MedicalZooPytorch with MIT License | 5 votes |
def __init__(self, in_channels=1, classes=4, shortcut_type="A", dropout_layer=True): super(HighResNet3D, self).__init__() self.in_channels = in_channels self.shortcut_type = shortcut_type self.classes = classes self.init_channels = 16 self.red_channels = 16 self.dil2_channels = 32 self.dil4_channels = 64 self.conv_out_channels = 80 if self.shortcut_type == "B": self.res_pad_1 = Conv1x1x1(self.red_channels, self.dil2_channels) self.res_pad_2 = Conv1x1x1(self.dil2_channels, self.dil4_channels) self.conv_init = ConvInit(in_channels) self.red_blocks1 = self.create_red(self.init_channels) self.red_blocks2 = self.create_red(self.red_channels) self.red_blocks3 = self.create_red(self.red_channels) self.dil2block1 = self.create_dil2(self.red_channels) self.dil2block2 = self.create_dil2(self.dil2_channels) self.dil2block3 = self.create_dil2(self.dil2_channels) self.dil4block1 = self.create_dil4(self.dil2_channels) self.dil4block2 = self.create_dil4(self.dil4_channels) self.dil4block3 = self.create_dil4(self.dil4_channels) if dropout_layer: conv_out = nn.Conv3d(self.dil4_channels, self.conv_out_channels, kernel_size=1) drop3d = nn.Dropout3d() conv1x1x1 = Conv1x1x1(self.conv_out_channels, self.classes) self.conv_out = nn.Sequential(conv_out, drop3d, conv1x1x1) else: self.conv_out = Conv1x1x1(self.dil4_channels, self.classes)
Example #23
Source File: Vnet.py From MedicalZooPytorch with MIT License | 5 votes |
def __init__(self, inChans, nConvs, elu, dropout=False): super(DownTransition, self).__init__() outChans = 2 * inChans self.down_conv = nn.Conv3d(inChans, outChans, kernel_size=2, stride=2) self.bn1 = torch.nn.BatchNorm3d(outChans) self.do1 = passthrough self.relu1 = ELUCons(elu, outChans) self.relu2 = ELUCons(elu, outChans) if dropout: self.do1 = nn.Dropout3d() self.ops = _make_nConv(outChans, nConvs, elu)
Example #24
Source File: Vnet.py From MedicalZooPytorch with MIT License | 5 votes |
def __init__(self, inChans, outChans, nConvs, elu, dropout=False): super(UpTransition, self).__init__() self.up_conv = nn.ConvTranspose3d(inChans, outChans // 2, kernel_size=2, stride=2) self.bn1 = torch.nn.BatchNorm3d(outChans // 2) self.do1 = passthrough self.do2 = nn.Dropout3d() self.relu1 = ELUCons(elu, outChans // 2) self.relu2 = ELUCons(elu, outChans) if dropout: self.do1 = nn.Dropout3d() self.ops = _make_nConv(outChans, nConvs, elu)
Example #25
Source File: ResNet3D_VAE.py From MedicalZooPytorch with MIT License | 5 votes |
def __init__(self, in_channels, start_channels=32): super(ResNetEncoder, self).__init__() self.start_channels = start_channels self.down_channels_1 = 2 * self.start_channels self.down_channels_2 = 2 * self.down_channels_1 self.down_channels_3 = 2 * self.down_channels_2 # print("self.down_channels_3", self.down_channels_3) self.blue_1 = BlueBlock(in_channels=in_channels, out_channels=self.start_channels) self.drop = nn.Dropout3d(0.2) self.green_1 = GreenBlock(in_channels=self.start_channels) self.down_1 = DownBlock(in_channels=self.start_channels, out_channels=self.down_channels_1) self.green_2_1 = GreenBlock(in_channels=self.down_channels_1) self.green_2_2 = GreenBlock(in_channels=self.down_channels_1) self.down_2 = DownBlock(in_channels=self.down_channels_1, out_channels=self.down_channels_2) self.green_3_1 = GreenBlock(in_channels=self.down_channels_2) self.green_3_2 = GreenBlock(in_channels=self.down_channels_2) self.down_3 = DownBlock(in_channels=self.down_channels_2, out_channels=self.down_channels_3) self.green_4_1 = GreenBlock(in_channels=self.down_channels_3) self.green_4_2 = GreenBlock(in_channels=self.down_channels_3) self.green_4_3 = GreenBlock(in_channels=self.down_channels_3) self.green_4_4 = GreenBlock(in_channels=self.down_channels_3)
Example #26
Source File: vnet.py From vnet.pytorch with BSD 3-Clause "New" or "Revised" License | 5 votes |
def __init__(self, inChans, outChans, nConvs, elu, dropout=False): super(UpTransition, self).__init__() self.up_conv = nn.ConvTranspose3d(inChans, outChans // 2, kernel_size=2, stride=2) self.bn1 = ContBatchNorm3d(outChans // 2) self.do1 = passthrough self.do2 = nn.Dropout3d() self.relu1 = ELUCons(elu, outChans // 2) self.relu2 = ELUCons(elu, outChans) if dropout: self.do1 = nn.Dropout3d() self.ops = _make_nConv(outChans, nConvs, elu)
Example #27
Source File: nnUNetTrainer.py From nnUNet with Apache License 2.0 | 5 votes |
def initialize_network(self): """ This is specific to the U-Net and must be adapted for other network architectures :return: """ # self.print_to_log_file(self.net_num_pool_op_kernel_sizes) # self.print_to_log_file(self.net_conv_kernel_sizes) net_numpool = len(self.net_num_pool_op_kernel_sizes) if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'negative_slope': 1e-2, 'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, net_numpool, self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, False, False, lambda x: x, InitWeights_He(1e-2), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) self.network.inference_apply_nonlin = softmax_helper if torch.cuda.is_available(): self.network.cuda()
Example #28
Source File: nnUNetTrainerV2_DDP.py From nnUNet with Apache License 2.0 | 5 votes |
def initialize_network(self): """ This is specific to the U-Net and must be adapted for other network architectures :return: """ self.print_to_log_file(self.net_num_pool_op_kernel_sizes) self.print_to_log_file(self.net_conv_kernel_sizes) if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.InstanceNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.InstanceNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'negative_slope': 1e-2, 'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(1e-2), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #29
Source File: nnUNetTrainerV2_BN.py From nnUNet with Apache License 2.0 | 5 votes |
def initialize_network(self): """ changed deep supervision to False :return: """ if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = nn.BatchNorm3d else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = nn.BatchNorm2d norm_op_kwargs = {'eps': 1e-5, 'affine': True} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'negative_slope': 1e-2, 'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(1e-2), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper
Example #30
Source File: nnUNetTrainerV2_GN.py From nnUNet with Apache License 2.0 | 5 votes |
def initialize_network(self): """ changed deep supervision to False :return: """ if self.threeD: conv_op = nn.Conv3d dropout_op = nn.Dropout3d norm_op = MyGroupNorm else: conv_op = nn.Conv2d dropout_op = nn.Dropout2d norm_op = MyGroupNorm norm_op_kwargs = {'eps': 1e-5, 'affine': True, 'num_groups': 8} dropout_op_kwargs = {'p': 0, 'inplace': True} net_nonlin = nn.LeakyReLU net_nonlin_kwargs = {'negative_slope': 1e-2, 'inplace': True} self.network = Generic_UNet(self.num_input_channels, self.base_num_features, self.num_classes, len(self.net_num_pool_op_kernel_sizes), self.conv_per_stage, 2, conv_op, norm_op, norm_op_kwargs, dropout_op, dropout_op_kwargs, net_nonlin, net_nonlin_kwargs, True, False, lambda x: x, InitWeights_He(1e-2), self.net_num_pool_op_kernel_sizes, self.net_conv_kernel_sizes, False, True, True) if torch.cuda.is_available(): self.network.cuda() self.network.inference_apply_nonlin = softmax_helper