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, 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,
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 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 __init__(self, cfg, name='deeplab_chain'):
super(DeepLab_Chain, self).__init__()
self.model_cfg = cfg
self.net = DeepLabUNet(cfg, name='deeplab_unet')
self.F = self.model_cfg.get('num_filters', 16)
self.num_classes = self.model_cfg.get('num_classes', 5)
self.segmentation = ME.MinkowskiLinear(self.F * 2, self.num_classes)
def __init__(self, cfg, name='uresnet_chain'):
super(UResNet_Chain, self).__init__()
self.model_cfg = cfg
self.net = UResNet(cfg, name='uresnet')
self.F = self.model_cfg.get('num_filters', 16)
self.num_classes = self.model_cfg.get('num_classes', 5)
self.segmentation = ME.MinkowskiLinear(self.F, self.num_classes)
def __init__(self,
in_features,
out_features,
stride=1,
dilation=1,
downsample=None,
bn_momentum=0.1,
leakiness=0.0,
dimension=-1):
super(ResNetBlock, self).__init__()
assert dimension > 0
if in_features != out_features:
self.residual = ME.MinkowskiLinear(in_features, out_features)
else:
self.residual = Identity()
self.conv1 = ME.MinkowskiConvolution(in_features,
out_features,
kernel_size=3,
stride=stride,
dilation=dilation,
dimension=dimension)
self.norm1 = ME.MinkowskiBatchNorm(out_features, momentum=bn_momentum)
self.conv2 = ME.MinkowskiConvolution(out_features,
out_features,
kernel_size=3,
stride=1,
dilation=dilation,
dimension=dimension)
self.norm2 = ME.MinkowskiBatchNorm(out_features, momentum=bn_momentum)
self.leaky_relu = MinkowskiLeakyReLU(negative_slope=leakiness)
def __init__(self, cfg, name='acnn'):
super(ACNN_Chain, self).__init__()
self.model_cfg = cfg['modules'][name]
self.net = ACNN(cfg, name='acnn')
self.num_classes = self.model_cfg.get('num_classes', 5)
self.segmentation = ME.MinkowskiLinear(self.net.outputFeatures,
self.num_classes)
print('Total Number of Trainable Parameters = {}'.format(
sum(p.numel() for p in self.parameters() if p.requires_grad)))
def network_initialization(self, in_channels, out_channels, D):
field_ch = 32
field_ch2 = 64
self.field_network = nn.Sequential(
ME.MinkowskiSinusoidal(in_channels, field_ch),
ME.MinkowskiBatchNorm(field_ch),
ME.MinkowskiReLU(inplace=True),
ME.MinkowskiLinear(field_ch, field_ch),
ME.MinkowskiBatchNorm(field_ch),
ME.MinkowskiReLU(inplace=True),
ME.MinkowskiToSparseTensor(),
)
self.field_network2 = nn.Sequential(
ME.MinkowskiSinusoidal(field_ch + in_channels, field_ch2),
ME.MinkowskiBatchNorm(field_ch2),
ME.MinkowskiReLU(inplace=True),
ME.MinkowskiLinear(field_ch2, field_ch2),
ME.MinkowskiBatchNorm(field_ch2),
ME.MinkowskiReLU(inplace=True),
ME.MinkowskiToSparseTensor(),
)
ResNetBase.network_initialization(self, field_ch2, out_channels, D)
def __init__(self,
in_features,
out_features,
kernel_sizes=None,
dilations=None,
mode='avg',
D=3):
super(SPP, self).__init__()
if mode == 'avg':
self.pool_fn = ME.MinkowskiAvgPooling
elif mode == 'max':
self.pool_fn = ME.MinkowskiMaxPooling
elif mode == 'sum':
self.pool_fn = ME.MinkowskiSumPooling
else:
raise ValueError("Invalid pooling mode, must be one of \
'sum', 'max' or 'average'")
self.unpool_fn = ME.MinkowskiPoolingTranspose
# Include global pooling as first modules.
self.pool = [ME.MinkowskiGlobalPooling(dimension=D)]
self.unpool = [ME.MinkowskiBroadcast(dimension=D)]
multiplier = 1
# Define subregion poolings
self.spp = []
if kernel_sizes is not None:
if isinstance(dilations, int):
dilations = [dilations for _ in range(len(kernel_sizes))]
elif isinstance(dilations, list):
assert len(kernel_sizes) == len(dilations)
else:
raise ValueError("Invalid input to dilations, must be either \
int or list of ints")
multiplier = len(kernel_sizes) + 1 # Additional 1 for globalPool
for k, d in zip(kernel_sizes, dilations):
pooling_layer = self.pool_fn(kernel_size=k,
dilation=d,
stride=k,
dimension=D)
unpooling_layer = self.unpool_fn(kernel_size=k,
dilation=d,
stride=k,
dimension=D)
self.pool.append(pooling_layer)
self.unpool.append(unpooling_layer)
self.pool = nn.Sequential(*self.pool)
self.unpool = nn.Sequential(*self.unpool)
self.linear = ME.MinkowskiLinear(in_features * multiplier,
out_features)
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=3,
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.MinkowskiDropout(),
ME.MinkowskiConvolution(self.inplanes,
self.inplanes,
kernel_size=3,
stride=3,
dimension=D),
ME.MinkowskiBatchNorm(self.inplanes),
ME.MinkowskiGELU(),
)
self.glob_pool = ME.MinkowskiGlobalMaxPooling()
self.final = ME.MinkowskiLinear(self.inplanes, out_channels, bias=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_feat, out_feat, D):
super(ExampleNetwork, self).__init__(D)
self.conv1 = ME.MinkowskiConvolution(in_channels=in_feat,
out_channels=64,
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.bn1 = ME.MinkowskiBatchNorm(64)
self.conv2 = ME.MinkowskiConvolution(in_channels=64,
out_channels=128,
kernel_size=3,
stride=2,
dimension=D)
self.bn2 = ME.MinkowskiBatchNorm(128)
self.pooling = ME.MinkowskiGlobalPooling(dimension=D)
self.linear = ME.MinkowskiLinear(128, out_feat)
def network_initialization(
self, in_channel, out_channel, channels, embedding_channel, kernel_size, D=3,
):
self.mlp1 = self.get_mlp_block(in_channel, channels[0])
self.conv1 = self.get_conv_block(
channels[0], channels[1], kernel_size=kernel_size, stride=1,
)
self.conv2 = self.get_conv_block(
channels[1], channels[2], kernel_size=kernel_size, stride=2,
)
self.conv3 = self.get_conv_block(
channels[2], channels[3], kernel_size=kernel_size, stride=2,
)
self.conv4 = self.get_conv_block(
channels[3], channels[4], kernel_size=kernel_size, stride=2,
)
self.conv5 = nn.Sequential(
self.get_conv_block(
channels[1] + channels[2] + channels[3] + channels[4],
embedding_channel // 4,
kernel_size=3,
stride=2,
),
self.get_conv_block(
embedding_channel // 4, embedding_channel // 2, kernel_size=3, stride=2,
),
self.get_conv_block(
embedding_channel // 2, embedding_channel, kernel_size=3, stride=2,
),
)
self.pool = ME.MinkowskiMaxPooling(kernel_size=3, stride=2, dimension=D)
self.global_max_pool = ME.MinkowskiGlobalMaxPooling()
self.global_avg_pool = ME.MinkowskiGlobalAvgPooling()
self.final = nn.Sequential(
self.get_mlp_block(embedding_channel * 2, 512),
ME.MinkowskiDropout(),
self.get_mlp_block(512, 512),
ME.MinkowskiLinear(512, out_channel, bias=True),
)
def __init__(self,
in_channel,
out_channel,
embedding_channel=1024,
dimension=3):
ME.MinkowskiNetwork.__init__(self, dimension)
self.conv1 = nn.Sequential(
ME.MinkowskiLinear(3, 64, bias=False),
ME.MinkowskiBatchNorm(64),
ME.MinkowskiReLU(),
)
self.conv2 = nn.Sequential(
ME.MinkowskiLinear(64, 64, bias=False),
ME.MinkowskiBatchNorm(64),
ME.MinkowskiReLU(),
)
self.conv3 = nn.Sequential(
ME.MinkowskiLinear(64, 64, bias=False),
ME.MinkowskiBatchNorm(64),
ME.MinkowskiReLU(),
)
self.conv4 = nn.Sequential(
ME.MinkowskiLinear(64, 128, bias=False),
ME.MinkowskiBatchNorm(128),
ME.MinkowskiReLU(),
)
self.conv5 = nn.Sequential(
ME.MinkowskiLinear(128, embedding_channel, bias=False),
ME.MinkowskiBatchNorm(embedding_channel),
ME.MinkowskiReLU(),
)
self.max_pool = ME.MinkowskiGlobalMaxPooling()
self.linear1 = nn.Sequential(
ME.MinkowskiLinear(embedding_channel, 512, bias=False),
ME.MinkowskiBatchNorm(512),
ME.MinkowskiReLU(),
)
self.dp1 = ME.MinkowskiDropout()
self.linear2 = ME.MinkowskiLinear(512, out_channel, bias=True)
def __init__(self, in_features, out_features, dimension=3, leakiness=0.0):
super(AtrousIIBlock, self).__init__()
assert dimension > 0
self.D = dimension
if in_features != out_features:
self.residual = ME.MinkowskiLinear(in_features, out_features)
else:
self.residual = Identity()
self.conv1 = ME.MinkowskiConvolution(in_features,
out_features,
kernel_size=3,
stride=1,
dilation=1,
dimension=self.D)
self.norm1 = ME.MinkowskiInstanceNorm(out_features, dimension=self.D)
self.conv2 = ME.MinkowskiConvolution(out_features,
out_features,
kernel_size=3,
stride=1,
dilation=3,
dimension=self.D)
self.norm2 = ME.MinkowskiInstanceNorm(out_features, dimension=self.D)
self.leaky_relu = MinkowskiLeakyReLU(negative_slope=leakiness)
def __init__(self,
in_channel,
out_channel,
num_class,
embedding_channel=1024,
dimension=3):
ME.MinkowskiNetwork.__init__(self, dimension)
# The normal channel for Modelnet is 3, for scannet is 6, for scanobjnn is 0
normal_channel = 3
# in_channel = normal_channel+3 # normal ch + xyz
self.normal_channel = normal_channel
self.input_mlp = nn.Sequential(
ME.MinkowskiConvolution(in_channel, 32, kernel_size=1,
dimension=3), ME.MinkowskiBatchNorm(32),
ME.MinkowskiReLU(),
ME.MinkowskiConvolution(32, 32, kernel_size=1, dimension=3),
ME.MinkowskiBatchNorm(32))
self.in_dims = [32, 64, 128, 256]
self.out_dims = [64, 128, 256, 512]
self.neighbor_ks = [16, 32, 64, 16, 16]
# self.neighbor_ks = [8, 8, 8, 8, 8]
self.PTBlock0 = PTBlock(in_dim=self.in_dims[0],
n_sample=self.neighbor_ks[0])
self.TDLayer1 = TDLayer(input_dim=self.in_dims[0],
out_dim=self.out_dims[0])
self.PTBlock1 = PTBlock(in_dim=self.out_dims[0],
n_sample=self.neighbor_ks[1])
self.TDLayer2 = TDLayer(input_dim=self.in_dims[1],
out_dim=self.out_dims[1])
self.PTBlock2 = PTBlock(in_dim=self.out_dims[1],
n_sample=self.neighbor_ks[1])
self.TDLayer3 = TDLayer(input_dim=self.in_dims[2],
out_dim=self.out_dims[2])
self.PTBlock3 = PTBlock(in_dim=self.out_dims[2],
n_sample=self.neighbor_ks[2])
self.TDLayer4 = TDLayer(input_dim=self.in_dims[3],
out_dim=self.out_dims[3])
self.PTBlock4 = PTBlock(in_dim=self.out_dims[3],
n_sample=self.neighbor_ks[4])
self.middle_linear = ME.MinkowskiConvolution(self.out_dims[3],
self.out_dims[3],
kernel_size=1,
dimension=3)
self.PTBlock_middle = PTBlock(in_dim=self.out_dims[3],
n_sample=self.neighbor_ks[4])
self.TULayer5 = TULayer(input_dim=self.out_dims[3],
out_dim=self.in_dims[3])
self.PTBlock5 = PTBlock(in_dim=self.in_dims[3],
n_sample=self.neighbor_ks[4])
self.TULayer6 = TULayer(input_dim=self.out_dims[2],
out_dim=self.in_dims[2])
self.PTBlock6 = PTBlock(in_dim=self.in_dims[2],
n_sample=self.neighbor_ks[3])
self.TULayer7 = TULayer(input_dim=self.out_dims[1],
out_dim=self.in_dims[1])
self.PTBlock7 = PTBlock(in_dim=self.in_dims[1],
n_sample=self.neighbor_ks[2])
self.TULayer8 = TULayer(input_dim=self.out_dims[0],
out_dim=self.in_dims[0])
self.PTBlock8 = PTBlock(in_dim=self.in_dims[0],
n_sample=self.neighbor_ks[1])
self.fc = nn.Sequential(
# ME.MinkowskiLinear(32, 32),
ME.MinkowskiLinear(self.out_dims[3], 32),
ME.MinkowskiDropout(0.4),
ME.MinkowskiLinear(32, num_class))
self.global_avg_pool = ME.MinkowskiGlobalAvgPooling()
def __init__(self,
config,
in_channel,
out_channel,
final_dim=96,
dimension=3):
ME.MinkowskiNetwork.__init__(self, dimension)
# The normal channel for Modelnet is 3, for scannet is 6, for scanobjnn is 0
normal_channel = 3
self.CONV_TYPE = ConvType.SPATIAL_HYPERCUBE
# self.dims = np.array([32, 64, 128, 256])
self.dims = np.array([32, 64, 128, 256])
# self.neighbor_ks = np.array([4, 4, 4, 4])
# self.neighbor_ks = np.array([12, 12, 12, 12])
self.neighbor_ks = np.array([16, 16, 16, 16])
# self.neighbor_ks = np.array([32, 32, 32, 32])
# self.neighbor_ks = np.array([8, 8, 16, 16])
# self.neighbor_ks = np.array([32, 32, 32, 32])
# self.neighbor_ks = np.array([8, 12, 16, 24])
# self.neighbor_ks = np.array([8, 8, 8, 8])
self.final_dim = final_dim
stem_dim = self.dims[0]
if config.xyz_input:
in_channel = normal_channel + in_channel
else:
in_channel = in_channel
# pixel size 1
self.stem1 = nn.Sequential(
ME.MinkowskiConvolution(in_channel,
stem_dim,
kernel_size=config.ks,
dimension=3),
ME.MinkowskiBatchNorm(stem_dim),
ME.MinkowskiReLU(),
)
# self.stem2 = TDLayer(input_dim=self.dims[0], out_dim=self.dims[0])
self.stem2 = nn.Sequential(
ME.MinkowskiConvolution(stem_dim,
stem_dim,
kernel_size=3,
dimension=3,
stride=2),
ME.MinkowskiBatchNorm(stem_dim),
ME.MinkowskiReLU(),
)
# window_beta = 5
window_beta = None
base_r = 5
self.ALPHA_BLENDING_MID_TR = False
self.ALPHA_BLENDING_FIRST_TR = True
# self.PTBlock1 = PTBlock(in_dim=self.dims[0], hidden_dim = self.dims[0], n_sample=self.neighbor_ks[0], skip_attn=False, r=base_r, kernel_size=config.ks, window_beta=window_beta)
self.PTBlock2 = PTBlock(in_dim=self.dims[1],
hidden_dim=self.dims[1],
n_sample=self.neighbor_ks[1],
skip_attn=False,
r=2 * base_r,
kernel_size=config.ks,
window_beta=window_beta)
self.PTBlock3 = PTBlock(in_dim=self.dims[2],
hidden_dim=self.dims[2],
n_sample=self.neighbor_ks[2],
skip_attn=False,
r=2 * base_r,
kernel_size=config.ks,
window_beta=window_beta)
self.PTBlock4 = PTBlock(in_dim=self.dims[3],
hidden_dim=self.dims[3],
n_sample=self.neighbor_ks[3],
skip_attn=False,
r=4 * base_r,
kernel_size=config.ks,
window_beta=window_beta)
if self.ALPHA_BLENDING_MID_TR:
self.PTBlock4_branch = PTBlock(in_dim=self.dims[3],
hidden_dim=self.dims[3],
n_sample=self.neighbor_ks[3],
skip_attn=True,
r=4 * base_r,
kernel_size=config.ks)
self.PTBlock5_branch = PTBlock(in_dim=128,
hidden_dim=128,
n_sample=self.neighbor_ks[3],
skip_attn=True,
r=2 * base_r,
kernel_size=config.ks) # out: 256
if self.ALPHA_BLENDING_FIRST_TR:
self.PTBlock1_branch = PTBlock(in_dim=self.dims[0],
hidden_dim=self.dims[0],
n_sample=self.neighbor_ks[0],
skip_attn=False,
r=base_r,
kernel_size=config.ks,
window_beta=window_beta)
self.PTBlock5 = PTBlock(in_dim=128,
hidden_dim=128,
n_sample=self.neighbor_ks[3],
skip_attn=False,
r=2 * base_r,
kernel_size=config.ks,
window_beta=window_beta) # out: 256
self.PTBlock6 = PTBlock(in_dim=128,
hidden_dim=128,
n_sample=self.neighbor_ks[2],
skip_attn=False,
r=2 * base_r,
kernel_size=config.ks,
window_beta=window_beta) # out: 128
self.PTBlock7 = PTBlock(in_dim=96,
hidden_dim=96,
n_sample=self.neighbor_ks[1],
skip_attn=False,
r=base_r,
kernel_size=config.ks,
window_beta=window_beta) # out: 64
# self.PTBlock5 = StackedPTBlock(in_dim=128, hidden_dim=128,n_sample=self.neighbor_ks[3], skip_attn=False, r=2*base_r, kernel_size=config.ks) # out: 256
# self.PTBlock6 = StackedPTBlock(in_dim=128, hidden_dim=128, n_sample=self.neighbor_ks[2], skip_attn=False, r=2*base_r, kernel_size=config.ks) # out: 128
# self.PTBlock7 = StackedPTBlock(in_dim=96, hidden_dim=96, n_sample=self.neighbor_ks[1], skip_attn=False, r=base_r, kernel_size=config.ks) # out: 64
# BLOCK_TYPE = SingleConv
BLOCK_TYPE = BasicBlock
self.PTBlock1 = self._make_layer(block=BLOCK_TYPE,
inplanes=self.dims[0],
planes=self.dims[0],
num_blocks=1)
# self.PTBlock2 = self._make_layer(block=BLOCK_TYPE, inplanes=self.dims[1], planes=self.dims[1], num_blocks=1)
# self.PTBlock3 = self._make_layer(block=BLOCK_TYPE, inplanes=self.dims[2], planes=self.dims[2], num_blocks=1)
# self.PTBlock4 = self._make_layer(block=BLOCK_TYPE, inplanes=self.dims[3], planes=self.dims[3], num_blocks=1)
# self.PTBlock5 = self._make_layer(block=BLOCK_TYPE, inplanes=128, planes=128, num_blocks=1)
# self.PTBlock6 = self._make_layer(block=BLOCK_TYPE, inplanes=128, planes=128, num_blocks=1)
# self.PTBlock7 = self._make_layer(block=BLOCK_TYPE, inplanes=96, planes=96, num_blocks=1)
# pixel size 2
self.TDLayer1 = TDLayer(input_dim=self.dims[0],
out_dim=self.dims[1]) # strided conv
# pixel size 4
self.TDLayer2 = TDLayer(input_dim=self.dims[1], out_dim=self.dims[2])
# pixel size 8
self.TDLayer3 = TDLayer(input_dim=self.dims[2], out_dim=self.dims[3])
# pixel size 16: PTBlock4
# pixel size 8
# self.TULayer5 = TULayer(input_a_dim=self.dims[3], input_b_dim = self.dims[2], out_dim=self.dims[2]) # out: 256//2 + 128 = 256
self.TULayer5 = ResNetLikeTU(input_a_dim=256,
input_b_dim=128,
out_dim=128) # out: 256//2 + 128 = 256
# pixel size 4
# self.TULayer6 = TULayer(input_a_dim=self.dims[2], input_b_dim = self.dims[1], out_dim=self.dims[1]) # out: 256//2 + 64 = 192
self.TULayer6 = ResNetLikeTU(input_a_dim=128,
input_b_dim=64,
out_dim=128) # out: 256//2 + 64 = 192
# pixel size 2
# self.TULayer7 = TULayer(input_a_dim=self.dims[1], input_b_dim = self.dims[0], out_dim=self.dims[0]) # 128 // 2 + 32 = 96
self.TULayer7 = ResNetLikeTU(input_a_dim=128,
input_b_dim=32,
out_dim=96) # 128 // 2 + 32 = 96
# pixel size 1
# self.PTBlock8 = PTBlock(in_dim=self.dims[0], hidden_dim=self.dims[0], n_sample=self.neighbor_ks[1]) # 32
# self.TULayer8 = TULayer(input_a_dim=self.dims[0], input_b_dim = self.dims[0], out_dim=self.dims[0]) # 64 // 2 + 32
self.TULayer8 = ResNetLikeTU(input_a_dim=96,
input_b_dim=32,
out_dim=96) # 64 // 2 + 32
self.fc = ME.MinkowskiLinear(96, out_channel)
def __init__(self):
nn.Module.__init__(self)
# Input sparse tensor must have tensor stride 128.
ch = self.CHANNELS
# Block 1
self.block1 = nn.Sequential(
ME.MinkowskiConvolution(1, ch[0], kernel_size=3, stride=2, dimension=3),
ME.MinkowskiBatchNorm(ch[0]),
ME.MinkowskiELU(),
ME.MinkowskiConvolution(ch[0], ch[0], kernel_size=3, dimension=3),
ME.MinkowskiBatchNorm(ch[0]),
ME.MinkowskiELU(),
)
self.block2 = nn.Sequential(
ME.MinkowskiConvolution(ch[0], ch[1], kernel_size=3, stride=2, dimension=3),
ME.MinkowskiBatchNorm(ch[1]),
ME.MinkowskiELU(),
ME.MinkowskiConvolution(ch[1], ch[1], kernel_size=3, dimension=3),
ME.MinkowskiBatchNorm(ch[1]),
ME.MinkowskiELU(),
)
self.block3 = nn.Sequential(
ME.MinkowskiConvolution(ch[1], ch[2], kernel_size=3, stride=2, dimension=3),
ME.MinkowskiBatchNorm(ch[2]),
ME.MinkowskiELU(),
ME.MinkowskiConvolution(ch[2], ch[2], kernel_size=3, dimension=3),
ME.MinkowskiBatchNorm(ch[2]),
ME.MinkowskiELU(),
)
self.block4 = nn.Sequential(
ME.MinkowskiConvolution(ch[2], ch[3], kernel_size=3, stride=2, dimension=3),
ME.MinkowskiBatchNorm(ch[3]),
ME.MinkowskiELU(),
ME.MinkowskiConvolution(ch[3], ch[3], kernel_size=3, dimension=3),
ME.MinkowskiBatchNorm(ch[3]),
ME.MinkowskiELU(),
)
self.block5 = nn.Sequential(
ME.MinkowskiConvolution(ch[3], ch[4], kernel_size=3, stride=2, dimension=3),
ME.MinkowskiBatchNorm(ch[4]),
ME.MinkowskiELU(),
ME.MinkowskiConvolution(ch[4], ch[4], kernel_size=3, dimension=3),
ME.MinkowskiBatchNorm(ch[4]),
ME.MinkowskiELU(),
)
self.block6 = nn.Sequential(
ME.MinkowskiConvolution(ch[4], ch[5], kernel_size=3, stride=2, dimension=3),
ME.MinkowskiBatchNorm(ch[5]),
ME.MinkowskiELU(),
ME.MinkowskiConvolution(ch[5], ch[5], kernel_size=3, dimension=3),
ME.MinkowskiBatchNorm(ch[5]),
ME.MinkowskiELU(),
)
self.block7 = nn.Sequential(
ME.MinkowskiConvolution(ch[5], ch[6], kernel_size=3, stride=2, dimension=3),
ME.MinkowskiBatchNorm(ch[6]),
ME.MinkowskiELU(),
ME.MinkowskiConvolution(ch[6], ch[6], kernel_size=3, dimension=3),
ME.MinkowskiBatchNorm(ch[6]),
ME.MinkowskiELU(),
)
self.global_pool = ME.MinkowskiGlobalPooling()
self.linear_mean = ME.MinkowskiLinear(ch[6], ch[6], bias=True)
self.linear_log_var = ME.MinkowskiLinear(ch[6], ch[6], bias=True)
self.weight_initialization()
def get_mlp_block(self, in_channel, out_channel):
return nn.Sequential(
ME.MinkowskiLinear(in_channel, out_channel, bias=False),
ME.MinkowskiBatchNorm(out_channel),
ME.MinkowskiReLU(),
)
def __init__(self, config, in_channel, out_channel, final_dim=96, dimension=3):
ME.MinkowskiNetwork.__init__(self, dimension)
# The normal channel for Modelnet is 3, for scannet is 6, for scanobjnn is 0
normal_channel = 3
self.CONV_TYPE = ConvType.SPATIAL_HYPERCUBE
# self.dims = np.array([32, 64, 128, 256])
self.dims = np.array([64, 64, 256, 256])
# self.neighbor_ks = np.array([12, 12, 12, 12])
self.neighbor_ks = np.array([16, 16, 16, 16])
# self.neighbor_ks = np.array([8, 12, 16, 24])
# self.neighbor_ks = np.array([8, 8, 8, 8])
self.final_dim = final_dim
stem_dim = 32
if config.xyz_input:
in_channel = normal_channel + in_channel
else:
in_channel = in_channel
# pixel size 1
self.stem1 = nn.Sequential(
ME.MinkowskiConvolution(in_channel, stem_dim, kernel_size=config.ks, dimension=3),
ME.MinkowskiBatchNorm(stem_dim),
ME.MinkowskiReLU(),
)
# self.stem2 = TDLayer(input_dim=self.dims[0], out_dim=self.dims[0])
# DEBUG ONLY!!
self.stem2 = nn.Sequential(
ME.MinkowskiConvolution(stem_dim, stem_dim*2, kernel_size=4, dimension=3, stride=4),
ME.MinkowskiBatchNorm(stem_dim*2),
ME.MinkowskiReLU(),
)
base_r = 5
self.PTBlock1 = PTBlock(in_dim=self.dims[0], hidden_dim = self.dims[0], n_sample=self.neighbor_ks[0], skip_knn=False, r=base_r, kernel_size=config.ks)
self.PTBlock2 = PTBlock(in_dim=self.dims[1], hidden_dim = self.dims[1], n_sample=self.neighbor_ks[1], skip_knn=False, r=2*base_r, kernel_size=config.ks)
self.PTBlock3 = PTBlock(in_dim=self.dims[2],hidden_dim = self.dims[2], n_sample=self.neighbor_ks[2], skip_knn=False, r=2*base_r, kernel_size=config.ks)
self.PTBlock4 = PTBlock(in_dim=self.dims[3], hidden_dim = self.dims[3], n_sample=self.neighbor_ks[3], skip_knn=False, r=4*base_r, kernel_size=config.ks)
# self.PTBlock5 = PTBlock(in_dim=self.dims[2], hidden_dim = self.dims[2], n_sample=self.neighbor_ks[3], skip_knn=False, r=2*base_r, kernel_size=config.ks) # out: 256
# self.PTBlock6 = PTBlock(in_dim=self.dims[1], hidden_dim=self.dims[1], n_sample=self.neighbor_ks[2], skip_knn=False, r=2*base_r, kernel_size=config.ks) # out: 128
# self.PTBlock7 = PTBlock(in_dim=self.dims[0], hidden_dim=self.dims[0], n_sample=self.neighbor_ks[1], skip_knn=False, r=base_r, kernel_size=config.ks) # out: 64
self.PTBlock5 = PTBlock(in_dim=256, hidden_dim=256,n_sample=self.neighbor_ks[3], skip_knn=False, r=2*base_r, kernel_size=config.ks) # out: 256
self.PTBlock6 = PTBlock(in_dim=128, hidden_dim=128, n_sample=self.neighbor_ks[2], skip_knn=False, r=2*base_r, kernel_size=config.ks) # out: 128
self.PTBlock7 = PTBlock(in_dim=128, hidden_dim=128, n_sample=self.neighbor_ks[1], skip_knn=False, r=base_r, kernel_size=config.ks) # out: 64
# self.PTBlock1 = StackedPTBlock(in_dim=self.dims[0], hidden_dim = self.dims[0], n_sample=self.neighbor_ks[0], skip_knn=False, r=base_r, kernel_size=config.ks)
# self.PTBlock2 = StackedPTBlock(in_dim=self.dims[1], hidden_dim = self.dims[1], n_sample=self.neighbor_ks[1], skip_knn=False, r=2*base_r, kernel_size=config.ks)
# self.PTBlock3 = StackedPTBlock(in_dim=self.dims[2],hidden_dim = self.dims[2], n_sample=self.neighbor_ks[2], skip_knn=False, r=2*base_r, kernel_size=config.ks)
# self.PTBlock4 = StackedPTBlock(in_dim=self.dims[3], hidden_dim = self.dims[3], n_sample=self.neighbor_ks[3], skip_knn=False, r=4*base_r, kernel_size=config.ks)
# self.PTBlock5 = StackedPTBlock(in_dim=self.dims[2], hidden_dim = self.dims[2], n_sample=self.neighbor_ks[3], skip_knn=False, r=2*base_r, kernel_size=config.ks) # out: 256
# self.PTBlock6 = StackedPTBlock(in_dim=self.dims[1], hidden_dim=self.dims[1], n_sample=self.neighbor_ks[2], skip_knn=False, r=2*base_r, kernel_size=config.ks) # out: 128
# self.PTBlock7 = StackedPTBlock(in_dim=self.dims[0], hidden_dim=self.dims[0], n_sample=self.neighbor_ks[1], skip_knn=False, r=base_r, kernel_size=config.ks) # out: 64
# self.PTBlock1 = self._make_layer(block=BasicBlock, inplanes=self.dims[0], planes=self.dims[0], num_blocks=2)
# self.PTBlock2 = self._make_layer(block=BasicBlock, inplanes=self.dims[1], planes=self.dims[1], num_blocks=2)
# self.PTBlock3 = self._make_layer(block=BasicBlock, inplanes=self.dims[2], planes=self.dims[2], num_blocks=2)
# self.PTBlock4 = self._make_layer(block=BasicBlock, inplanes=self.dims[3], planes=self.dims[3], num_blocks=2)
# self.PTBlock5 = self._make_layer(block=BasicBlock, inplanes=self.dims[2], planes=self.dims[2], num_blocks=2)
# self.PTBlock6 = self._make_layer(block=BasicBlock, inplanes=self.dims[1], planes=self.dims[1], num_blocks=2)
# self.PTBlock7 = self._make_layer(block=BasicBlock, inplanes=self.dims[0], planes=self.dims[0], num_blocks=2)
# pixel size 2
# self.TDLayer1 = TDLayer(input_dim=self.dims[0], out_dim=self.dims[1]) # strided conv
# pixel size 4
self.TDLayer2 = TDLayer(input_dim=self.dims[1], out_dim=self.dims[2])
# pixel size 8
# self.TDLayer3 = TDLayer(input_dim=self.dims[2], out_dim=self.dims[3])
# pixel size 16: PTBlock4
# pixel size 8
# self.TULayer5 = TULayer(input_a_dim=self.dims[3], input_b_dim = self.dims[2], out_dim=self.dims[2]) # out: 256//2 + 128 = 256
# self.TULayer5 = ResNetLikeTU(input_a_dim=256, input_b_dim = 128, out_dim=128) # out: 256//2 + 128 = 256
# pixel size 4
# self.TULayer6 = TULayer(input_a_dim=self.dims[2], input_b_dim = self.dims[1], out_dim=self.dims[1]) # out: 256//2 + 64 = 192
self.TULayer6 = ResNetLikeTU(input_a_dim=256, input_b_dim = 64, out_dim=128) # out: 256//2 + 64 = 192
# pixel size 2
# self.TULayer7 = TULayer(input_a_dim=self.dims[1], input_b_dim = self.dims[0], out_dim=self.dims[0]) # 128 // 2 + 32 = 96
# self.TULayer7 = ResNetLikeTU(input_a_dim=128, input_b_dim = 32, out_dim=96) # 128 // 2 + 32 = 96
# pixel size 1
# self.PTBlock8 = PTBlock(in_dim=self.dims[0], hidden_dim=self.dims[0], n_sample=self.neighbor_ks[1]) # 32
# self.TULayer8 = TULayer(input_a_dim=self.dims[0], input_b_dim = self.dims[0], out_dim=self.dims[0]) # 64 // 2 + 32
self.TULayer8 = ResNetLikeTU(input_a_dim=128, input_b_dim = 32, out_dim=96) # 64 // 2 + 32
self.fc = ME.MinkowskiLinear(96, out_channel)
def __init__(self,
config,
in_channel,
out_channel,
final_dim=96,
dimension=3):
ME.MinkowskiNetwork.__init__(
self, dimension
) # The normal channel for Modelnet is 3, for scannet is 6, for scanobjnn is 0
normal_channel = 3 # the RGB
self.CONV_TYPE = ConvType.SPATIAL_HYPERCUBE
self.dims = np.array([32, 64, 128, 256, 512])
self.neighbor_ks = np.array([32, 32, 32, 32, 32]) // 2
self.final_dim = final_dim
stem_dim = self.dims[0]
in_channel = normal_channel + 3 # normal ch + xyz
self.normal_channel = normal_channel
# pixel size 1
self.stem1 = nn.Sequential(
ME.MinkowskiConvolution(in_channel,
stem_dim,
kernel_size=1,
dimension=3),
ME.MinkowskiBatchNorm(stem_dim),
ME.MinkowskiReLU(),
)
# when using split-scnee, no stride here
split_scene = True
if split_scene:
self.stem2 = nn.Sequential(
ME.MinkowskiConvolution(stem_dim,
stem_dim,
kernel_size=1,
dimension=3,
stride=1),
ME.MinkowskiBatchNorm(stem_dim),
ME.MinkowskiReLU(),
)
# does the spatial downsampling
# pixel size 2
else:
self.stem2 = nn.Sequential(
ME.MinkowskiConvolution(stem_dim,
stem_dim,
kernel_size=2,
dimension=3,
stride=2),
ME.MinkowskiBatchNorm(stem_dim),
ME.MinkowskiReLU(),
)
base_r = 4
self.PTBlock0 = PTBlock(in_dim=self.dims[0],
hidden_dim=self.dims[0],
n_sample=self.neighbor_ks[0],
skip_knn=False,
r=base_r)
self.PTBlock1 = PTBlock(in_dim=self.dims[1],
hidden_dim=self.dims[1],
n_sample=self.neighbor_ks[1],
skip_knn=False,
r=base_r)
self.PTBlock2 = PTBlock(in_dim=self.dims[2],
hidden_dim=self.dims[2],
n_sample=self.neighbor_ks[2],
skip_knn=False,
r=2 * base_r)
self.PTBlock3 = PTBlock(in_dim=self.dims[3],
hidden_dim=self.dims[3],
n_sample=self.neighbor_ks[3],
skip_knn=False,
r=int(2 * base_r))
self.PTBlock4 = PTBlock(in_dim=self.dims[4],
hidden_dim=self.dims[4],
n_sample=self.neighbor_ks[3],
skip_knn=False,
r=int(4 * base_r))
self.PTBlock_middle = PTBlock(in_dim=self.dims[4],
hidden_dim=self.dims[4],
n_sample=self.neighbor_ks[3],
skip_knn=False,
r=int(4 * base_r))
self.PTBlock5 = PTBlock(in_dim=self.dims[3],
hidden_dim=self.dims[3],
n_sample=self.neighbor_ks[3],
skip_knn=False,
r=2 * base_r) # out: 256
self.PTBlock6 = PTBlock(in_dim=self.dims[2],
hidden_dim=self.dims[2],
n_sample=self.neighbor_ks[2],
skip_knn=False,
r=2 * base_r) # out: 128
self.PTBlock7 = PTBlock(in_dim=self.dims[1],
hidden_dim=self.dims[1],
n_sample=self.neighbor_ks[1],
skip_knn=False,
r=base_r) # out: 64
self.PTBlock8 = PTBlock(in_dim=self.dims[0],
hidden_dim=self.dims[0],
n_sample=self.neighbor_ks[1],
skip_knn=False,
r=base_r) # out: 64
# self.PTBlock0 = PTBlock(in_dim=self.dims[0], hidden_dim = self.dims[0], n_sample=self.neighbor_ks[0], skip_knn=True, r=base_r)
# self.PTBlock1 = PTBlock(in_dim=self.dims[1], hidden_dim = self.dims[1], n_sample=self.neighbor_ks[1], skip_knn=True, r=2*base_r)
# self.PTBlock2 = PTBlock(in_dim=self.dims[2],hidden_dim = self.dims[2], n_sample=self.neighbor_ks[2], skip_knn=True, r=2*base_r)
# self.PTBlock3 = PTBlock(in_dim=self.dims[3], hidden_dim = self.dims[3], n_sample=self.neighbor_ks[3], skip_knn=True, r=int(4*base_r))
# self.PTBlock4 = PTBlock(in_dim=self.dims[4], hidden_dim = self.dims[4], n_sample=self.neighbor_ks[3], skip_knn=True, r=int(16*base_r))
# self.PTBlock_middle = PTBlock(in_dim=self.dims[4], hidden_dim = self.dims[4], n_sample=self.neighbor_ks[3], skip_knn=True, r=int(16*base_r))
# self.PTBlock5 = PTBlock(in_dim=self.dims[3], hidden_dim = self.dims[3], n_sample=self.neighbor_ks[3], skip_knn=True, r=4*base_r) # out: 256
# self.PTBlock6 = PTBlock(in_dim=self.dims[2], hidden_dim=self.dims[2], n_sample=self.neighbor_ks[2], skip_knn=True, r=2*base_r) # out: 128
# self.PTBlock7 = PTBlock(in_dim=self.dims[1], hidden_dim=self.dims[1], n_sample=self.neighbor_ks[1], skip_knn=True, r=2*base_r) # out: 64
# self.PTBlock8 = PTBlock(in_dim=self.dims[0], hidden_dim=self.dims[0], n_sample=self.neighbor_ks[1], skip_knn=True, r=base_r) # out: 64
# self.PTBlock1 = self._make_layer(block=BasicBlock, inplanes=self.dims[0], planes=self.dims[0], num_blocks=2)
# self.PTBlock2 = self._make_layer(block=BasicBlock, inplanes=self.dims[1], planes=self.dims[1], num_blocks=2)
# self.PTBlock3 = self._make_layer(block=BasicBlock, inplanes=self.dims[2], planes=self.dims[2], num_blocks=2)
# self.PTBlock4 = self._make_layer(block=BasicBlock, inplanes=self.dims[3], planes=self.dims[3], num_blocks=2)
# self.PTBlock_middle = self._make_layer(block=BasicBlock, inplanes=self.dims[4], planes=self.dims[4], num_blocks=2)
# self.PTBlock5 = self._make_layer(block=BasicBlock, inplanes=self.dims[3], planes=self.dims[3], num_blocks=2)
# self.PTBlock6 = self._make_layer(block=BasicBlock, inplanes=self.dims[2], planes=self.dims[2], num_blocks=2)
# self.PTBlock7 = self._make_layer(block=BasicBlock, inplanes=self.dims[1], planes=self.dims[1], num_blocks=2)
# self.PTBlock8 = self._make_layer(block=BasicBlock, inplanes=self.dims[0], planes=self.dims[0], num_blocks=2)
TD_kernel_size = [4, 8, 12,
16] # only applied when using non-PointTRlike
# pixel size 2
self.TDLayer1 = TDLayer(input_dim=self.dims[0],
out_dim=self.dims[1],
kernel_size=TD_kernel_size[0]) # strided conv
# pixel size 4
self.TDLayer2 = TDLayer(input_dim=self.dims[1],
out_dim=self.dims[2],
kernel_size=TD_kernel_size[1])
# pixel size 8
self.TDLayer3 = TDLayer(input_dim=self.dims[2],
out_dim=self.dims[3],
kernel_size=TD_kernel_size[2])
# pixel size 16: PTBlock4
self.TDLayer4 = TDLayer(input_dim=self.dims[3],
out_dim=self.dims[4],
kernel_size=TD_kernel_size[3])
self.middle_linear = ME.MinkowskiConvolution(self.dims[4],
self.dims[4],
kernel_size=1,
dimension=3)
# pixel size 8
self.TULayer5 = TULayer(
input_a_dim=self.dims[4],
input_b_dim=self.dims[3],
out_dim=self.dims[3]) # out: 256//2 + 128 = 256
# pixel size 4
self.TULayer6 = TULayer(input_a_dim=self.dims[3],
input_b_dim=self.dims[2],
out_dim=self.dims[2]) # out: 256//2 + 64 = 192
# pixel size 2
self.TULayer7 = TULayer(input_a_dim=self.dims[2],
input_b_dim=self.dims[1],
out_dim=self.dims[1]) # 128 // 2 + 32 = 96
self.TULayer8 = TULayer(input_a_dim=self.dims[1],
input_b_dim=self.dims[0],
out_dim=self.dims[0]) # 128 // 2 + 32 = 96
self.final_dim = 32
if split_scene:
self.final_conv = nn.Sequential(
ME.MinkowskiConvolution(self.dims[0],
self.final_dim,
kernel_size=1,
stride=1,
dimension=3),
ME.MinkowskiDropout(0.4),
)
else:
self.final_conv = nn.Sequential(
ME.MinkowskiConvolutionTranspose(self.dims[0],
self.final_dim,
kernel_size=2,
stride=2,
dimension=3),
ME.MinkowskiDropout(0.4),
)
self.fc = ME.MinkowskiLinear(self.final_dim, out_channel)
def __init__(self, cfg, name='fpn'):
super(FPN, self).__init__(cfg)
model_cfg = cfg['modules'][name]
# UResNet Configurations
self.reps = model_cfg.get('reps', 2)
self.depth = model_cfg.get('depth', 5)
self.num_filters = model_cfg.get('num_filters', 16)
self.nPlanes = [i * self.num_filters for i in range(1, self.depth + 1)]
# self.kernel_size = cfg.get('kernel_size', 3)
# self.downsample = cfg.get(downsample, 2)
self.input_kernel = model_cfg.get('input_kernel', 3)
# Initialize Input Layer
self.input_layer = ME.MinkowskiConvolution(
in_channels=self.num_input,
out_channels=self.num_filters,
kernel_size=self.input_kernel,
stride=1,
dimension=self.D)
# Initialize Encoder
self.encoding_conv = []
self.encoding_block = []
for i, F in enumerate(self.nPlanes):
m = []
for _ in range(self.reps):
m.append(
ResNetBlock(F,
F,
dimension=self.D,
leakiness=self.leakiness))
m = nn.Sequential(*m)
self.encoding_block.append(m)
m = []
if i < self.depth - 1:
m.append(ME.MinkowskiBatchNorm(F))
m.append(MinkowskiLeakyReLU(negative_slope=self.leakiness))
m.append(
ME.MinkowskiConvolution(in_channels=self.nPlanes[i],
out_channels=self.nPlanes[i + 1],
kernel_size=2,
stride=2,
dimension=self.D))
m = nn.Sequential(*m)
self.encoding_conv.append(m)
self.encoding_conv = nn.Sequential(*self.encoding_conv)
self.encoding_block = nn.Sequential(*self.encoding_block)
# Lateral Connections
self.lateral = []
for i, F in enumerate(self.nPlanes[-2::-1]):
self.lateral.append(ME.MinkowskiLinear(F, F))
self.lateral = nn.Sequential(*self.lateral)
# Initialize Decoder
self.decoding_block = []
self.decoding_conv = []
for i in range(self.depth - 2, -1, -1):
m = []
m.append(ME.MinkowskiBatchNorm(self.nPlanes[i + 1]))
m.append(MinkowskiLeakyReLU(negative_slope=self.leakiness))
m.append(
ME.MinkowskiConvolutionTranspose(in_channels=self.nPlanes[i +
1],
out_channels=self.nPlanes[i],
kernel_size=2,
stride=2,
dimension=self.D))
m = nn.Sequential(*m)
self.decoding_conv.append(m)
m = []
for j in range(self.reps):
m.append(
ResNetBlock(self.nPlanes[i],
self.nPlanes[i],
dimension=self.D,
leakiness=self.leakiness))
m = nn.Sequential(*m)
self.decoding_block.append(m)
self.decoding_block = nn.Sequential(*self.decoding_block)
self.decoding_conv = nn.Sequential(*self.decoding_conv)
print('Total Number of Trainable Parameters = {}'.format(
sum(p.numel() for p in self.parameters() if p.requires_grad)))
def __init__(self,
in_features,
out_features,
dimension=3,
leakiness=0.0,
cardinality=4,
depth=1,
dilations=None,
kernel_sizes=3,
strides=1):
super(ResNeXtBlock, self).__init__()
assert dimension > 0
assert cardinality > 0
assert (in_features % cardinality == 0
and out_features % cardinality == 0)
self.D = dimension
nIn = in_features // cardinality
nOut = out_features // cardinality
self.dilations = []
if dilations is None:
# Default
self.dilations = [3**i for i in range(cardinality)]
elif isinstance(dilations, int):
self.dilations = [dilations for _ in range(cardinality)]
elif isinstance(dilations, list):
assert len(dilations) == cardinality
self.dilations = dilations
else:
raise ValueError(
'Invalid type for input strides, must be int or list!')
self.kernels = []
if isinstance(kernel_sizes, int):
self.kernels = [kernel_sizes for _ in range(cardinality)]
elif isinstance(kernel_sizes, list):
assert len(kernel_sizes) == cardinality
self.kernels = kernel_sizes
else:
raise ValueError(
'Invalid type for input strides, must be int or list!')
self.strides = []
if isinstance(strides, int):
self.strides = [strides for _ in range(cardinality)]
elif isinstance(strides, list):
assert len(strides) == cardinality
self.strides = strides
else:
raise ValueError(
'Invalid type for input strides, must be int or list!')
# For each path, generate sequentials
self.paths = []
for i in range(cardinality):
m = []
m.append(ME.MinkowskiLinear(in_features, nIn))
for j in range(depth):
in_C = (nIn if j == 0 else nOut)
m.append(
ME.MinkowskiConvolution(in_channels=in_C,
out_channels=nOut,
kernel_size=self.kernels[i],
stride=self.strides[i],
dilation=self.dilations[i],
dimension=self.D))
m.append(ME.MinkowskiBatchNorm(nOut))
m.append(MinkowskiLeakyReLU(negative_slope=leakiness))
m = nn.Sequential(*m)
self.paths.append(m)
self.paths = nn.Sequential(*self.paths)
self.linear = ME.MinkowskiLinear(out_features, out_features)
# Skip Connection
if in_features != out_features:
self.residual = ME.MinkowskiLinear(in_features, out_features)
else:
self.residual = Identity()