def conv_tr(in_channels,
out_channels,
kernel_size,
stride=1,
dilation=1,
bias=False,
region_type=ME.RegionType.HYPER_CUBE,
dimension=-1):
assert dimension > 0, 'Dimension must be a positive integer'
kernel_generator = ME.KernelGenerator(kernel_size,
stride,
dilation,
is_transpose=True,
region_type=region_type,
dimension=dimension)
kernel_generator = ME.KernelGenerator(kernel_size,
stride,
dilation,
is_transpose=True,
region_type=region_type,
dimension=dimension)
return ME.MinkowskiConvolutionTranspose(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
bias=bias,
kernel_generator=kernel_generator,
dimension=dimension)
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 conv_tr(in_planes,
out_planes,
kernel_size,
upsample_stride=1,
dilation=1,
bias=False,
conv_type=ConvType.HYPERCUBE,
D=-1):
assert D > 0, 'Dimension must be a positive integer'
region_type, axis_types, kernel_size = convert_conv_type(conv_type, kernel_size, D)
kernel_generator = ME.KernelGenerator(
kernel_size,
upsample_stride,
dilation,
region_type=region_type,
axis_types=axis_types,
dimension=D)
return ME.MinkowskiConvolutionTranspose(
in_channels=in_planes,
out_channels=out_planes,
kernel_size=kernel_size,
stride=upsample_stride,
dilation=dilation,
has_bias=bias,
kernel_generator=kernel_generator,
dimension=D)
def conv(in_channels,
out_channels,
kernel_size=3,
stride=1,
dilation=1,
bias=False,
region_type=0,
dimension=3):
if not isinstance(region_type, ME.RegionType):
if region_type == 0:
region_type = ME.RegionType.HYPER_CUBE
elif region_type == 1:
region_type = ME.RegionType.HYPER_CROSS
else:
raise ValueError('Unsupported region type')
kernel_generator = ME.KernelGenerator(kernel_size=kernel_size,
stride=stride,
dilation=dilation,
region_type=region_type,
dimension=dimension)
return ME.MinkowskiConvolution(in_channels,
out_channels,
kernel_size=kernel_size,
stride=stride,
kernel_generator=kernel_generator,
dimension=dimension)
def sum_pool(kernel_size, stride=1, dilation=1, conv_type=ConvType.HYPERCUBE, D=-1):
assert D > 0, 'Dimension must be a positive integer'
region_type, axis_types, kernel_size = convert_conv_type(conv_type, kernel_size, D)
kernel_generator = ME.KernelGenerator(
kernel_size, stride, dilation, region_type=region_type, axis_types=axis_types, dimension=D)
return ME.MinkowskiSumPooling(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
kernel_generator=kernel_generator,
dimension=D)
def __init__(self, inc, outc, ks=3, stride=1, dilation=1, D=3):
super(BasicConvolutionBlock4d, self).__init__()
self.net = nn.Sequential(
ME.MinkowskiConvolution(
inc, outc, dilation=dilation, stride=stride, dimension=D,
kernel_generator=ME.KernelGenerator(
kernel_size=(ks, ks, ks, 1), dimension=D,
region_type=ME.RegionType.HYPERCUBE)),
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)
"dilation": 2,
# "region_type":ME.RegionType.HYPER_CROSS,
"region_type": ME.RegionType.CUSTOM,
"region_offsets": ro0,
"dimension": 3,
}
print(ro0)
# import ipdb; ipdb.set_trace()
kg0 = ME.KernelGenerator(
# **kgargs
kernel_size=2,
stride=1,
dilation=2,
region_type=ME.RegionType.CUSTOM,
region_offsets=ro0,
dimension=3
)
conv = ME.MinkowskiChannelwiseConvolution(
in_channels=1,
kernel_size=2,
stride=1,
dilation=1,
bias=False,
kernel_generator=kg0,
dimension=3
)
def __init__(self, cfg):
super(MinkUNet4d, self).__init__()
self.stem = nn.Sequential(
ME.MinkowskiConvolution(
3, 32, dimension=4,
kernel_generator=ME.KernelGenerator(
kernel_size=(5, 5, 5, 1), dimension=4,
region_type=ME.RegionType.HYPERCUBE)),
ME.MinkowskiBatchNorm(32),
ME.MinkowskiReLU(True))
nn.init.constant_(self.stem[1].bn.weight, 1.0)
nn.init.constant_(self.stem[1].bn.bias, 0.0)
self.stage1 = nn.Sequential(
BasicConvolutionBlock4d(32, 32, ks=2, stride=(2, 2, 2, 1), D=4),
ResidualBlock4d(32, 32, ks=3),
ResidualBlock4d(32, 32, ks=3),
)
self.stage2 = nn.Sequential(
BasicConvolutionBlock4d(32, 32, ks=2, stride=(2, 2, 2, 1), D=4),
ResidualBlock4d(32, 64, ks=3),
ResidualBlock4d(64, 64, ks=3)
)
self.stage3 = nn.Sequential(
BasicConvolutionBlock4d(64, 64, ks=2, stride=(2, 2, 2, 1), D=4),
ResidualBlock4d(64, 128, ks=3),
ResidualBlock4d(128, 128, ks=3),
)
self.stage4 = nn.Sequential(
BasicConvolutionBlock4d(128, 128, ks=2, stride=(2, 2, 2, 1), D=4),
ResidualBlock4d(128, 256, ks=3),
ResidualBlock4d(256, 256, ks=3),
)
self.up1 = nn.ModuleList([
BasicDeconvolutionBlock4d(
256, 256, ks=2, stride=(2, 2, 2, 1), D=4),
nn.Sequential(
ResidualBlock4d(384, 256, ks=3),
ResidualBlock4d(256, 256, ks=3),
)
])
self.up2 = nn.ModuleList([
BasicDeconvolutionBlock4d(
256, 128, ks=2, stride=(2, 2, 2, 1), D=4),
nn.Sequential(
ResidualBlock4d(192, 128, ks=3),
ResidualBlock4d(128, 128, ks=3),
)
])
self.up3 = nn.ModuleList([
BasicDeconvolutionBlock4d(128, 96, ks=2, stride=(2, 2, 2, 1), D=4),
nn.Sequential(
ResidualBlock4d(128, 96, ks=3),
ResidualBlock4d(96, 96, ks=3),
)
])
self.up4 = nn.ModuleList([
BasicDeconvolutionBlock4d(96, 96, ks=2, stride=(2, 2, 2, 1), D=4),
nn.Sequential(
ResidualBlock4d(128, 96, ks=3),
ResidualBlock4d(96, 96, ks=3),
)
])
self.classifier = nn.Sequential(
ME.MinkowskiConvolution(
96, cfg.MODEL.NUM_CLASSES,
kernel_size=1, dimension=4))