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, in_channels):
super(PointNetfeat, self).__init__()
self.pool = ME.MinkowskiGlobalPooling()
self.broadcast = ME.MinkowskiBroadcast()
self.stn = STN3d(D=3)
self.conv1 = nn.Conv1d(in_channels + 3, 128, 1, bias=False)
self.conv2 = nn.Conv1d(128, 256, 1, bias=False)
self.bn1 = nn.BatchNorm1d(128)
self.bn2 = nn.BatchNorm1d(256)
self.relu = nn.ReLU()
def __init__(self, D=3):
super(STN3d, self).__init__()
k = self.KERNEL_SIZES
s = self.STRIDES
c = self.CONV_CHANNELS
self.conv1 = ME.MinkowskiConvolution(3,
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)
# Use the kernelsize 1 convolution for linear layers. If kernel size ==
# 1, minkowski engine internally uses a linear function.
self.fc4 = ME.MinkowskiConvolution(c[2],
c[3],
kernel_size=1,
has_bias=False,
dimension=3)
self.fc5 = ME.MinkowskiConvolution(c[3],
c[4],
kernel_size=1,
has_bias=False,
dimension=3)
self.fc6 = ME.MinkowskiConvolution(c[4],
9,
kernel_size=1,
has_bias=True,
dimension=3)
self.relu = ME.MinkowskiReLU(inplace=True)
self.avgpool = ME.MinkowskiGlobalPooling()
self.broadcast = ME.MinkowskiBroadcast()
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.bn4 = ME.MinkowskiInstanceNorm(c[3], dimension=3)
self.bn5 = ME.MinkowskiInstanceNorm(c[4], dimension=3)
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 __init__(self, D=3):
super(STN3d, self).__init__()
self.conv1 = nn.Conv1d(3, 64, 1, bias=False)
self.conv2 = nn.Conv1d(64, 128, 1, bias=False)
self.conv3 = nn.Conv1d(128, 256, 1, bias=False)
self.fc1 = nn.Linear(256, 128, bias=False)
self.fc2 = nn.Linear(128, 64, bias=False)
self.fc3 = nn.Linear(64, 9)
self.relu = nn.ReLU()
self.pool = ME.MinkowskiGlobalPooling()
self.bn1 = nn.BatchNorm1d(64)
self.bn2 = nn.BatchNorm1d(128)
self.bn3 = nn.BatchNorm1d(256)
self.bn4 = nn.BatchNorm1d(128)
self.bn5 = nn.BatchNorm1d(64)
self.broadcast = ME.MinkowskiBroadcast()
