def __init__(self): super(PointNetFeature, self).__init__() k = self.KERNEL_SIZES s = self.STRIDES c = self.CONV_CHANNELS self.stn = STN3d(D=3) self.block1 = nn.Sequential( ME.MinkowskiConvolution(6, c[0], kernel_size=k[0], stride=s[0], has_bias=False, dimension=3), ME.MinkowskiInstanceNorm(c[0]), ME.MinkowskiReLU()) self.block2 = nn.Sequential( ME.MinkowskiConvolution(c[0], c[1], kernel_size=k[1], stride=s[1], has_bias=False, dimension=3), ME.MinkowskiInstanceNorm(c[1]), ME.MinkowskiReLU()) self.block3 = nn.Sequential( ME.MinkowskiConvolution(c[1], c[2], kernel_size=k[2], stride=s[2], has_bias=False, dimension=3), ME.MinkowskiInstanceNorm(c[2]), ME.MinkowskiReLU()) self.avgpool = ME.MinkowskiGlobalPooling() self.concat = ME.MinkowskiBroadcastConcatenation()
def __init__(self, inc, outc, ks=3, stride=1, dilation=1, D=4): super(ResidualBlock4d, self).__init__() self.net = nn.Sequential( ME.MinkowskiConvolution( inc, outc, dimension=D, kernel_generator=ME.KernelGenerator( kernel_size=ks, dimension=D, region_type=ME.RegionType.HYBRID, axis_types=(ME.RegionType.HYPERCUBE, ME.RegionType.HYPERCUBE, ME.RegionType.HYPERCUBE, ME.RegionType.HYPERCROSS))), ME.MinkowskiBatchNorm(outc), ME.MinkowskiReLU(True), ME.MinkowskiConvolution( outc, outc, dimension=D, kernel_generator=ME.KernelGenerator( kernel_size=ks, dimension=D, region_type=ME.RegionType.HYBRID, axis_types=(ME.RegionType.HYPERCUBE, ME.RegionType.HYPERCUBE, ME.RegionType.HYPERCUBE, ME.RegionType.HYPERCROSS))), ME.MinkowskiBatchNorm(outc)) nn.init.constant_(self.net[1].bn.weight, 1.0) nn.init.constant_(self.net[1].bn.bias, 0.0) nn.init.constant_(self.net[4].bn.weight, 1.0) nn.init.constant_(self.net[4].bn.bias, 0.0) self.downsample = nn.Sequential() if (inc == outc and stride == 1) else nn.Sequential( ME.MinkowskiConvolution( inc, outc, kernel_size=1, dilation=1, stride=stride, dimension=D), ME.MinkowskiBatchNorm(outc)) if len(self.downsample) > 0: nn.init.constant_(self.downsample[1].bn.weight, 1.0) nn.init.constant_(self.downsample[1].bn.bias, 0.0) self.relu = ME.MinkowskiReLU(True)
def __init__(self, input_a_dim, input_b_dim, out_dim, kernel_size=2): super().__init__() ''' Deconv x_a concat with x_b then apply output-projection ''' self.input_a_dim = input_a_dim self.input_b_dim = input_b_dim self.out_dim = out_dim self.conv_a = nn.Sequential( ME.MinkowskiConvolutionTranspose(in_channels=input_a_dim, out_channels=input_a_dim, kernel_size=4, stride=4, dimension=3), ME.MinkowskiBatchNorm(input_a_dim), ME.MinkowskiReLU(), ) self.conv_proj = nn.Sequential( ME.MinkowskiConvolution(in_channels=input_a_dim + input_b_dim, out_channels=out_dim, kernel_size=3, stride=1, dimension=3), ME.MinkowskiBatchNorm(out_dim), ME.MinkowskiReLU(), )
def network_initialization(self, in_channels, out_channels, D): self.inplanes = self.INIT_DIM self.conv1 = ME.MinkowskiConvolution( in_channels, self.inplanes, kernel_size=5, stride=1, dimension=D) self.bn1 = ME.MinkowskiBatchNorm(self.inplanes) self.relu = ME.MinkowskiReLU(inplace=True) self.pool = ME.MinkowskiSumPooling(kernel_size=2, stride=2, dimension=D) self.layer1 = self._make_layer( self.BLOCK, self.PLANES[0], self.LAYERS[0], stride=2) self.layer2 = self._make_layer( self.BLOCK, self.PLANES[1], self.LAYERS[1], stride=2) self.layer3 = self._make_layer( self.BLOCK, self.PLANES[2], self.LAYERS[2], stride=2) self.layer4 = self._make_layer( self.BLOCK, self.PLANES[3], self.LAYERS[3], stride=2) self.glob_avg = ME.MinkowskiGlobalPooling(dimension=D) self.classification_block = nn.Sequential( ME.MinkowskiLinear(self.inplanes, self.inplanes, bias=False), ME.MinkowskiBatchNorm(self.inplanes), ME.MinkowskiReLU(), ME.MinkowskiLinear(self.inplanes, self.inplanes, bias=False), ME.MinkowskiBatchNorm(self.inplanes)) self.final = ME.MinkowskiLinear(self.inplanes, out_channels, bias=True)
def __init__(self, inc, outc, ks=3, stride=1, dilation=1, D=3): super(ResidualBlock, self).__init__() self.net = nn.Sequential( ME.MinkowskiConvolution( inc, outc, kernel_size=ks, dilation=dilation, stride=stride, dimension=D), ME.MinkowskiBatchNorm(outc), ME.MinkowskiReLU(True), ME.MinkowskiConvolution( outc, outc, kernel_size=ks, dilation=dilation, stride=1, dimension=D), ME.MinkowskiBatchNorm(outc)) nn.init.constant_(self.net[1].bn.weight, 1.0) nn.init.constant_(self.net[1].bn.bias, 0.0) nn.init.constant_(self.net[4].bn.weight, 1.0) nn.init.constant_(self.net[4].bn.bias, 0.0) self.downsample = nn.Sequential() if (inc == outc and stride == 1) else \ nn.Sequential( ME.MinkowskiConvolution( inc, outc, kernel_size=1, dilation=1, stride=stride, dimension=D), ME.MinkowskiBatchNorm(outc)) if len(self.downsample) > 0: nn.init.constant_(self.downsample[1].bn.weight, 1.0) nn.init.constant_(self.downsample[1].bn.bias, 0.0) self.relu = ME.MinkowskiReLU(True)
def __init__(self, D=3): super(STN3d, self).__init__() k = self.KERNEL_SIZES s = self.STRIDES c = self.CONV_CHANNELS self.block1 = nn.Sequential( ME.MinkowskiConvolution(3, c[0], kernel_size=k[0], stride=s[0], has_bias=False, dimension=3), ME.MinkowskiInstanceNorm(c[0]), ME.MinkowskiReLU()) self.block2 = nn.Sequential( ME.MinkowskiConvolution(c[0], c[1], kernel_size=k[1], stride=s[1], has_bias=False, dimension=3), ME.MinkowskiInstanceNorm(c[1]), ME.MinkowskiReLU()) self.block3 = nn.Sequential( ME.MinkowskiConvolution(c[1], c[2], kernel_size=k[2], stride=s[2], has_bias=False, dimension=3), ME.MinkowskiInstanceNorm(c[2]), ME.MinkowskiReLU()) # Use the kernelsize 1 convolution for linear layers. If kernel size == # 1, minkowski engine internally uses a linear function. self.block4 = nn.Sequential( ME.MinkowskiConvolution(c[2], c[3], kernel_size=1, has_bias=False, dimension=3), ME.MinkowskiInstanceNorm(c[3]), ME.MinkowskiReLU()) self.block5 = nn.Sequential( ME.MinkowskiConvolution(c[3], c[4], kernel_size=1, has_bias=False, dimension=3), ME.MinkowskiInstanceNorm(c[4]), ME.MinkowskiReLU()) self.fc6 = ME.MinkowskiConvolution(c[4], 9, kernel_size=1, has_bias=True, dimension=3) self.avgpool = ME.MinkowskiGlobalPooling() self.broadcast = ME.MinkowskiBroadcast()
def __init__(self, input_nc, output_nc, convolution, dimension=3, reduction=4): self.block = (Seq().append( convolution( in_channels=input_nc, out_channels=output_nc // reduction, kernel_size=1, stride=1, dilation=1, bias=False, dimension=dimension, )).append(ME.MinkowskiBatchNorm(output_nc // reduction)).append( ME.MinkowskiReLU()).append( convolution( output_nc // reduction, output_nc // reduction, kernel_size=3, stride=1, dilation=1, bias=False, dimension=dimension, )).append(ME.MinkowskiBatchNorm( output_nc // reduction)).append(ME.MinkowskiReLU()).append( convolution( output_nc // reduction, output_nc, kernel_size=1, stride=1, dilation=1, bias=False, dimension=dimension, )).append(ME.MinkowskiBatchNorm(output_nc)).append( ME.MinkowskiReLU())) if input_nc != output_nc: self.downsample = (Seq().append( convolution( in_channels=input_nc, out_channels=output_nc, kernel_size=1, stride=1, dilation=1, bias=False, dimension=dimension, )).append(ME.MinkowskiBatchNorm(output_nc))) else: self.downsample = None
def __init__(self, in_channels, out_channels, D=3): nn.Module.__init__(self) self.net = nn.Sequential( ME.MinkowskiConvolution(in_channels, 32, 3, dimension=D), ME.MinkowskiBatchNorm(32), ME.MinkowskiReLU(), ME.MinkowskiConvolution(32, 64, 3, stride=2, dimension=D), ME.MinkowskiBatchNorm(64), ME.MinkowskiReLU(), ME.MinkowskiConvolutionTranspose(64, 32, 3, stride=2, dimension=D), ME.MinkowskiBatchNorm(32), ME.MinkowskiReLU(), ME.MinkowskiConvolution(32, out_channels, kernel_size=1, dimension=D), )
def __init__(self): super(PointNetFeature, self).__init__() k = self.KERNEL_SIZES s = self.STRIDES c = self.CONV_CHANNELS self.stn = STN3d(D=3) self.conv1 = ME.MinkowskiConvolution(6, c[0], kernel_size=k[0], stride=s[0], has_bias=False, dimension=3) self.conv2 = ME.MinkowskiConvolution(c[0], c[1], kernel_size=k[1], stride=s[1], has_bias=False, dimension=3) self.conv3 = ME.MinkowskiConvolution(c[1], c[2], kernel_size=k[2], stride=s[2], has_bias=False, dimension=3) self.bn1 = ME.MinkowskiInstanceNorm(c[0], dimension=3) self.bn2 = ME.MinkowskiInstanceNorm(c[1], dimension=3) self.bn3 = ME.MinkowskiInstanceNorm(c[2], dimension=3) self.relu = ME.MinkowskiReLU(inplace=True) self.avgpool = ME.MinkowskiGlobalPooling() self.concat = ME.MinkowskiBroadcastConcatenation()
def network_initialization(self, in_channels, out_channels, D): self.inplanes = self.init_dim self.conv1 = ME.MinkowskiConvolution( in_channels, self.inplanes, kernel_size=5, stride=2, dimension=D) self.bn1 = ME.MinkowskiBatchNorm(self.inplanes) self.relu = ME.MinkowskiReLU(inplace=True) self.pool = ME.MinkowskiAvgPooling(kernel_size=2, stride=2, dimension=D) self.layer1 = self._make_layer( self.block, self.planes[0], self.layers[0], stride=2) self.layer2 = self._make_layer( self.block, self.planes[1], self.layers[1], stride=2) self.layer3 = self._make_layer( self.block, self.planes[2], self.layers[2], stride=2) self.layer4 = self._make_layer( self.block, self.planes[3], self.layers[3], stride=2) self.conv5 = ME.MinkowskiConvolution( self.inplanes, self.inplanes, kernel_size=3, stride=3, dimension=D) self.bn5 = ME.MinkowskiBatchNorm(self.inplanes) self.glob_avg = ME.MinkowskiGlobalMaxPooling() self.final = ME.MinkowskiLinear(self.inplanes, out_channels, bias=True)
def _make_stem_layer(self, in_channels): self.conv1s = [] if self.stem_stride == 4: s0, s1 = 2, 2 if self.stem_stride == 2: s0, s1 = 2, 1 if self.stem_stride == 1: s0, s1 = 1, 1 if not DEBUG_CFG.SPARSE_BEV: kernels = [(3, 3, 5), (3, 3, 5), (3, 3, 3)] strides = [(s0, s0, 2), (1, 1, 2), (s1, s1, 2)] paddings = [(1, 1, 0), (1, 1, 0), (1, 1, 0)] else: kernels = [ (7, 7, 1), ] strides = [ (s0, s0, 1), ] paddings = [(3, 3, 0)] out_planes = [self.basic_planes, self.basic_planes * 2] num_layers = len(kernels) - 1 in_channels_i = in_channels self.conv1s = [] self.norm1s = [] for i in range(num_layers): conv1_i = build_conv_layer(self.conv_cfg, in_channels_i, out_planes[i], kernel_size=kernels[i], stride=strides[i], padding=paddings[i], bias=False) in_channels_i = out_planes[i] norm1_name, norm1 = build_norm_layer(self.norm_cfg, in_channels_i, postfix=i + 1) self.add_module(f'conv1_{i}', conv1_i) self.add_module(norm1_name, norm1) self.conv1s.append(conv1_i) self.norm1s.append(norm1) self.relu = ME.MinkowskiReLU(inplace=True) if not DEBUG_CFG.SPARSE_BEV: self.maxpool = mink_max_pool(kernel_size=3, stride=(s1, s1, 2), padding=(1, 1, 0)) else: self.maxpool = mink_max_pool(kernel_size=(3, 3, 1), stride=(s1, s1, 1), padding=1) self.stem_stride_z = np.product([s[-1] for s in strides]) assert self.stem_stride_z == self.stem_stride_z_design assert self.stem_stride == np.product([s[0] for s in strides])
def __init__(self, up_conv_nn=[], kernel_size=3, stride=1, dilation=1, has_bias=False, activation=ME.MinkowskiReLU(inplace=True), bn_momentum=0.01, dimension=-1, **kwargs): """ Block convolution which consists of a convolution a batch norm a block operation and an activation. the block operation is usually a resnetBlock """ # instantiate convolution # instantiate batchnorm # instantiate block # activation super(SimpleBlockUp, self).__init__() self.conv_tr = ME.MinkowskiConvolutionTranspose( up_conv_nn[0], up_conv_nn[1], kernel_size=kernel_size, stride=stride, dilation=dilation, dimension=dimension) self.bn = ME.MinkowskiBatchNorm(up_conv_nn[1], momentum=bn_momentum) self.block = BasicBlock(up_conv_nn[1], up_conv_nn[1], bn_momentum=bn_momentum, dimension=dimension) self.activation = activation
def network_initialization(self, in_channels, out_channels, config, D): def space_n_time_m(n, m): return n if D == 3 else [n, n, n, m] if D == 4: self.OUT_PIXEL_DIST = space_n_time_m(self.OUT_PIXEL_DIST, 1) dilations = config.dilations bn_momentum = config.bn_momentum self.inplanes = self.INIT_DIM self.conv1 = conv( in_channels, self.inplanes, kernel_size=space_n_time_m(config.conv1_kernel_size, 1), stride=1, D=D) self.bn1 = get_norm(NormType.BATCH_NORM, self.inplanes, D=self.D, bn_momentum=bn_momentum) self.relu = ME.MinkowskiReLU(inplace=True) self.pool = sum_pool(kernel_size=space_n_time_m(2, 1), stride=space_n_time_m(2, 1), D=D) self.layer1 = self._make_layer( self.BLOCK, self.PLANES[0], self.LAYERS[0], stride=space_n_time_m(2, 1), dilation=space_n_time_m(dilations[0], 1)) self.layer2 = self._make_layer( self.BLOCK, self.PLANES[1], self.LAYERS[1], stride=space_n_time_m(2, 1), dilation=space_n_time_m(dilations[1], 1)) self.layer3 = self._make_layer( self.BLOCK, self.PLANES[2], self.LAYERS[2], stride=space_n_time_m(2, 1), dilation=space_n_time_m(dilations[2], 1)) self.layer4 = self._make_layer( self.BLOCK, self.PLANES[3], self.LAYERS[3], stride=space_n_time_m(2, 1), dilation=space_n_time_m(dilations[3], 1)) if self.NETWORK_TYPE == NetworkType.CLASSIFICATION: self.glob_avg = ME.MinkowskiGlobalPooling(dimension=D) if self.HAS_LAST_BLOCK: self.final1 = nn.Linear(self.inplanes, self.inplanes, bias=False) self.bnfinal1 = nn.BatchNorm1d(self.inplanes) self.final2 = nn.Linear(self.inplanes, self.inplanes, bias=False) self.bnfinal2 = nn.BatchNorm1d(self.inplanes) self.final = nn.Linear(self.inplanes, out_channels, bias=True) else: self.final = conv( self.PLANES[3] * self.BLOCK.expansion, out_channels, kernel_size=1, bias=True, D=D)
def __init__(self, dims, use_bn=False, use_relu=False, use_dropout=False, use_bias=True): super().__init__() layers = [] last_dim = dims[0] counter = 1 for dim in dims[1:]: layers.append(ME.MinkowskiLinear(last_dim, dim, bias=use_bias)) counter += 1 if use_bn: layers.append( ME.MinkowskiBatchNorm( dim, eps=1e-5, momentum=0.1, )) if (counter < len(dims)) and use_relu: layers.append(ME.MinkowskiReLU(inplace=True)) last_dim = dim if use_dropout: layers.append(MinkowskiDropout.Dropout()) self.clf = nn.Sequential(*layers)
def post_act_block(in_channels, out_channels, kernel_size=1, stride=1, padding=0, dimension=None): ''' :param in_channels: :param out_channels: :param kernel_size: :param stride: :param padding: :param dimension: :return: ''' m = nn.Sequential( ME.MinkowskiConvolution(in_channels, out_channels, kernel_size, padding=padding, stride=stride, dilation=1, has_bias=False, dimension=dimension), ME.MinkowskiBatchNorm(out_channels), ME.MinkowskiReLU()) return m
def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None, bn_momentum=0.1, dimension=-1): super(Bottleneck, self).__init__() assert dimension > 0 self.conv1 = ME.MinkowskiConvolution(inplanes, planes, kernel_size=1, dimension=dimension) self.norm1 = ME.MinkowskiBatchNorm(planes, momentum=bn_momentum) self.conv2 = ME.MinkowskiConvolution(planes, planes, kernel_size=3, stride=stride, dilation=dilation, dimension=dimension) self.norm2 = ME.MinkowskiBatchNorm(planes, momentum=bn_momentum) self.conv3 = ME.MinkowskiConvolution(planes, planes * self.expansion, kernel_size=1, dimension=dimension) self.norm3 = ME.MinkowskiBatchNorm(planes * self.expansion, momentum=bn_momentum) self.relu = ME.MinkowskiReLU(inplace=True) self.downsample = downsample
def __init__(self, use_cuda=True, kernel_sizes=[3], channels=[1], symmetric_mode=True, bn=False, dimension=6): super(GeometricSparseNeighConsensus, self).__init__() self.symmetric_mode = symmetric_mode self.kernel_sizes = kernel_sizes self.channels = channels num_layers = len(kernel_sizes) nn_modules = list() ch_in = 1 ch_out = channels[0] k_size = kernel_sizes[0] nn_modules.append(ME.MinkowskiReLU(inplace=True)) nn_modules.append( ME.MinkowskiConvolution(1, 1, kernel_size=k_size, bias=False, dimension=dimension)) #nn_modules.append(ME.MinkowskiConvolution(8,1,kernel_size=k_size,bias=False,dimension=dimension)) #nn_modules.append(ME.MinkowskiSigmoid()) nn_modules.append(ME.MinkowskiSigmoid()) self.conv = nn.Sequential(*nn_modules) if use_cuda: self.conv.cuda()
def network_initialization(self, in_channels, out_channels, D): def space_n_time_m(n, m): return n if D == 3 else [n, n, n, m] if D == 4: self.OUT_PIXEL_DIST = space_n_time_m(self.OUT_PIXEL_DIST, 1) dilations = self.dilations bn_momentum = 1 self.inplanes = self.INIT_DIM self.conv1 = conv(in_channels, self.inplanes, kernel_size=space_n_time_m(self.conv1_kernel_size, 1), stride=1, D=D) self.bn1 = get_norm(NormType.BATCH_NORM, self.inplanes, D=self.D, bn_momentum=bn_momentum) self.relu = ME.MinkowskiReLU(inplace=True) self.pool = sum_pool(kernel_size=space_n_time_m(2, 1), stride=space_n_time_m(2, 1), D=D) self.layer1 = self._make_layer( self.BLOCK, self.PLANES[0], self.LAYERS[0], stride=space_n_time_m(2, 1), dilation=space_n_time_m(dilations[0], 1), ) self.layer2 = self._make_layer( self.BLOCK, self.PLANES[1], self.LAYERS[1], stride=space_n_time_m(2, 1), dilation=space_n_time_m(dilations[1], 1), ) self.layer3 = self._make_layer( self.BLOCK, self.PLANES[2], self.LAYERS[2], stride=space_n_time_m(2, 1), dilation=space_n_time_m(dilations[2], 1), ) self.layer4 = self._make_layer( self.BLOCK, self.PLANES[3], self.LAYERS[3], stride=space_n_time_m(2, 1), dilation=space_n_time_m(dilations[3], 1), ) self.final = conv(self.PLANES[3] * self.BLOCK.expansion, out_channels, kernel_size=1, bias=True, D=D)
def _make_layer(self, inplanes, planes, num_blocks, idx, stride=1): print("NUM BLOCKS:", num_blocks, "STRIDE:", stride) if self._use_norm: BatchNorm2d = change_default_args( eps=1e-3, momentum=0.01)(ME.MinkowskiBatchNorm) Conv2d = change_default_args(bias=False, dimension=2)(ME.MinkowskiConvolution) SubMConv2d = change_default_args(bias=False, dimension=2)(ME.MinkowskiConvolution) ConvTranspose2d = change_default_args(bias=False, dimension=2)( ME.MinkowskiConvolutionTranspose) else: BatchNorm2d = Empty Conv2d = change_default_args(bias=True, dimension=2)(ME.MinkowskiConvolution) SubMConv2d = change_default_args(bias=True, dimension=2)(ME.MinkowskiConvolution) ConvTranspose2d = change_default_args(bias=True, dimension=2)( ME.MinkowskiConvolutionTranspose) ReLU = ME.MinkowskiReLU() block = Sequential( # PrintLayer(0), Conv2d(inplanes, planes, 2, stride=stride), BatchNorm2d(planes), ReLU, # PrintLayer(1), ) for j in range(num_blocks): block.add(SubMConv2d(planes, planes, 3)) block.add(BatchNorm2d(planes)), block.add(ReLU) # block.add(PrintLayer(2 + j)) return block, planes
def __init__(self, channels, block_layers, block): nn.Module.__init__(self) in_nchannels = 1 ch = [16, 32, 64, 32, channels] if block == 'ResNet': self.block = ResNet elif block == 'InceptionResNet': self.block = InceptionResNet self.conv0 = ME.MinkowskiConvolution(in_channels=in_nchannels, out_channels=ch[0], kernel_size=3, stride=1, bias=True, dimension=3) self.down0 = ME.MinkowskiConvolution(in_channels=ch[0], out_channels=ch[1], kernel_size=2, stride=2, bias=True, dimension=3) self.block0 = self.make_layer(self.block, block_layers, ch[1]) self.conv1 = ME.MinkowskiConvolution(in_channels=ch[1], out_channels=ch[1], kernel_size=3, stride=1, bias=True, dimension=3) self.down1 = ME.MinkowskiConvolution(in_channels=ch[1], out_channels=ch[2], kernel_size=2, stride=2, bias=True, dimension=3) self.block1 = self.make_layer(self.block, block_layers, ch[2]) self.conv2 = ME.MinkowskiConvolution(in_channels=ch[2], out_channels=ch[2], kernel_size=3, stride=1, bias=True, dimension=3) self.down2 = ME.MinkowskiConvolution(in_channels=ch[2], out_channels=ch[3], kernel_size=2, stride=2, bias=True, dimension=3) self.block2 = self.make_layer(self.block, block_layers, ch[3]) self.conv3 = ME.MinkowskiConvolution(in_channels=ch[3], out_channels=ch[4], kernel_size=3, stride=1, bias=True, dimension=3) self.relu = ME.MinkowskiReLU(inplace=True)
def get_nonlinearity(non_type): if non_type == 'ReLU': return ME.MinkowskiReLU() elif non_type == 'ELU': # return ME.MinkowskiInstanceNorm(num_feats, dimension=dimension) return ME.MinkowskiELU() else: raise ValueError(f'Type {non_type}, not defined')
def __init__(self, channel, reduction=16, D=-1): # Global coords does not require coords_key super(SELayer, self).__init__() self.fc = nn.Sequential( ME.MinkowskiLinear(channel, channel // reduction), ME.MinkowskiReLU(inplace=True), ME.MinkowskiLinear(channel // reduction, channel), ME.MinkowskiSigmoid()) self.pooling = ME.MinkowskiGlobalPooling(dimension=D) self.broadcast_mul = ME.MinkowskiBroadcastMultiplication(dimension=D)
def __init__(self, down_channels, skip_channels, out_channels, D=3): super().__init__() self.deconv = nn.Sequential( ME.MinkowskiConvolutionTranspose(down_channels, down_channels, kernel_size=3, stride=2, dimension=D), ME.MinkowskiReLU(inplace=True), ) self.conv = nn.Sequential( ME.MinkowskiConvolution(skip_channels + down_channels, out_channels, kernel_size=3, dimension=D), ME.MinkowskiReLU(inplace=True), )
def __init__(self, in_feat, out_feat, D): super(ExampleNetwork, self).__init__(D) self.net = nn.Sequential( ME.MinkowskiConvolution(in_channels=in_feat, out_channels=64, kernel_size=3, stride=2, dilation=1, has_bias=False, dimension=D), ME.MinkowskiBatchNorm(64), ME.MinkowskiReLU(), ME.MinkowskiConvolution(in_channels=64, out_channels=128, kernel_size=3, stride=2, dimension=D), ME.MinkowskiBatchNorm(128), ME.MinkowskiReLU(), ME.MinkowskiGlobalPooling(dimension=D), ME.MinkowskiLinear(128, out_feat))
def __init__(self, in_feats, out_feats, D): super(UNBlocks, self).__init__() self.convs, self.bns = {}, {} self.relu = ME.MinkowskiReLU(inplace=True) self.conv1 = conv(in_feats, out_feats, kernel_size=3, bias=False, D=D) self.bn1 = ME.MinkowskiBatchNorm(out_feats) self.conv2 = conv(out_feats, out_feats, kernel_size=3, bias=False, D=D) self.bn2 = ME.MinkowskiBatchNorm(out_feats)
def __init__(self, inc, outc, ks=3, stride=1, D=3): super(BasicDeconvolutionBlock, self).__init__() self.net = nn.Sequential( ME.MinkowskiConvolutionTranspose( inc, outc, kernel_size=ks, stride=stride, dimension=D), ME.MinkowskiBatchNorm(outc), ME.MinkowskiReLU(True)) nn.init.constant_(self.net[1].bn.weight, 1.0) nn.init.constant_(self.net[1].bn.bias, 0.0)
def network_initialization(self, in_channels, out_channels, D): self.inplanes = self.INIT_DIM self.conv1 = nn.Sequential( ME.MinkowskiConvolution(in_channels, self.inplanes, kernel_size=5, stride=2, dimension=D), ME.MinkowskiBatchNorm(self.inplanes), ME.MinkowskiReLU(inplace=True), ME.MinkowskiMaxPooling(kernel_size=2, stride=2, dimension=D), ) self.layer1 = self._make_layer(self.BLOCK, self.PLANES[0], self.LAYERS[0], stride=2) self.layer2 = self._make_layer(self.BLOCK, self.PLANES[1], self.LAYERS[1], stride=2) self.layer3 = self._make_layer(self.BLOCK, self.PLANES[2], self.LAYERS[2], stride=2) self.layer4 = self._make_layer(self.BLOCK, self.PLANES[3], self.LAYERS[3], stride=2) self.conv5 = nn.Sequential( ME.MinkowskiConvolution(self.inplanes, self.inplanes, kernel_size=3, stride=3, dimension=D), ME.MinkowskiBatchNorm(self.inplanes), ME.MinkowskiReLU(inplace=True), ) self.glob_avg = ME.MinkowskiGlobalMaxPooling() self.final = ME.MinkowskiLinear(self.inplanes, out_channels, bias=True)
def __init__(self, use_cuda=True, kernel_sizes=[3, 3, 3], channels=[10, 10, 1], symmetric_mode=True, bn=False): super(SparseNeighConsensus, self).__init__() self.symmetric_mode = symmetric_mode self.kernel_sizes = kernel_sizes self.channels = channels num_layers = len(kernel_sizes) nn_modules = list() for i in range(num_layers): if i == 0: nn_modules.append(ME.MinkowskiReLU(inplace=True)) ch_in = 1 else: ch_in = channels[i - 1] ch_out = channels[i] k_size = kernel_sizes[i] if ch_out == 1 or bn == False: nn_modules.append( ME.MinkowskiConvolution(ch_in, ch_out, kernel_size=k_size, has_bias=True, dimension=4)) elif bn == True: nn_modules.append( torch.nn.Sequential( ME.MinkowskiConvolution(ch_in, ch_out, kernel_size=k_size, has_bias=True, dimension=4), ME.MinkowskiBatchNorm(ch_out))) nn_modules.append(ME.MinkowskiReLU(inplace=True)) self.conv = nn.Sequential(*nn_modules) # self.add = ME.MinkowskiUnion() if use_cuda: self.conv.cuda()
def _make_deblock(self, num_out_filters, idx): print("CUSTOM MAKE DEBLOCK") stride = self._upsample_strides[idx - self._upsample_start_idx] if self._use_norm: if self._use_groupnorm: SparseBatchNorm2d = change_default_args( num_groups=self._num_groups, eps=1e-3)(GroupNorm) DenseBatchNorm2d = change_default_args( num_groups=self._num_groups, eps=1e-3)(GroupNorm) else: SparseBatchNorm2d = change_default_args( eps=1e-3, momentum=0.01)(ME.MinkowskiBatchNorm) DenseBatchNorm2d = change_default_args( eps=1e-3, momentum=0.01)(nn.BatchNorm2d) SparseConvTranspose2d = change_default_args(bias=False, dimension=2)( ME.MinkowskiConvolutionTranspose) DenseConvTranspose2d = change_default_args(bias=False)( nn.ConvTranspose2d) else: SparseBatchNorm2d = Empty DenseBatchNorm2d = Empty SparseConvTranspose2d = change_default_args(bias=True, dimension=2)( ME.MinkowskiConvolutionTranspose) DenseConvTranspose2d = change_default_args(bias=True)( nn.ConvTranspose2d) ReLU = ME.MinkowskiReLU() stride = np.round(stride).astype(np.int64) if (idx <= LAST_SPARSE_IDX): deblock = Sequential( SparseConvTranspose2d( num_out_filters, self._num_upsample_filters[idx - self._upsample_start_idx], stride, stride=stride), SparseBatchNorm2d( self._num_upsample_filters[idx - self._upsample_start_idx]), ReLU, ME.ToDense() ) else: stride = np.round(stride).astype(np.int64) deblock = Sequential( DenseConvTranspose2d( num_out_filters, self._num_upsample_filters[idx - self._upsample_start_idx], stride, stride=stride), DenseBatchNorm2d( self._num_upsample_filters[idx - self._upsample_start_idx]), ReLU, ) return deblock
def get_conv_block(self, in_channel, out_channel, kernel_size, stride): return nn.Sequential( ME.MinkowskiConvolution( in_channel, out_channel, kernel_size=kernel_size, stride=stride, dimension=self.D, ), ME.MinkowskiBatchNorm(out_channel), ME.MinkowskiReLU(), )