def __init__(self):
super(backbone_pointnet2, self).__init__()
self.sa1 = PointnetSAModule(mlp=[6, 32, 32, 64],
npoint=1024,
radius=0.1,
nsample=32,
bn=True)
self.sa2 = PointnetSAModule(mlp=[64, 64, 64, 128],
npoint=256,
radius=0.2,
nsample=64,
bn=True)
self.sa3 = PointnetSAModule(mlp=[128, 128, 128, 256],
npoint=64,
radius=0.4,
nsample=128,
bn=True)
self.sa4 = PointnetSAModule(mlp=[256, 256, 256, 512],
npoint=None,
radius=None,
nsample=None,
bn=True)
self.fp4 = PointnetFPModule(mlp=[768, 256, 256])
self.fp3 = PointnetFPModule(mlp=[384, 256, 256])
self.fp2 = PointnetFPModule(mlp=[320, 256, 128])
self.fp1 = PointnetFPModule(mlp=[137, 128, 128, 128, 128])
def __init__(self, input_channels=6, do_interpolation=False):
super().__init__()
print('PNv2_ASAP-1')
self.do_interpolation = do_interpolation
self.SA_modules = nn.ModuleList()
channel_in = input_channels
skip_channel_list = [input_channels]
for k in range(NPOINTS.__len__()):
mlps = MLPS[k].copy()
channel_out = 0
for idx in range(mlps.__len__()):
mlps[idx] = [channel_in] + mlps[idx]
channel_out += mlps[idx][-1]
self.SA_modules.append(
PointnetSAModuleMSG(npoint=NPOINTS[k],
radii=RADIUS[k],
nsamples=NSAMPLE[k],
mlps=mlps,
use_xyz=True,
bn=True))
skip_channel_list.append(channel_out)
channel_in = channel_out
self.tem_sa1 = PointnetSAModule(mlp=MLP1,
npoint=NPOINT1,
nsample=NSAMPLE1,
radius=RADIUS1)
self.fuse_layer1_atten = nn.Conv1d(MLP1[-1] * 2,
2,
kernel_size=1,
stride=1)
self.fuse_layer1 = nn.Conv1d(MLP1[-1], 384, kernel_size=1, stride=1)
self.tem_fp1 = PointnetFPModule(mlp=FP_MLP1)
self.tem_dropout = nn.Dropout(DP_RATIO)
self.FP_modules = nn.ModuleList()
for k in range(FP_MLPS.__len__()):
pre_channel = FP_MLPS[
k + 1][-1] if k + 1 < len(FP_MLPS) else channel_out
self.FP_modules.append(
PointnetFPModule(mlp=[pre_channel + skip_channel_list[k]] +
FP_MLPS[k]))
cls_layers = []
pre_channel = FP_MLPS[0][-1]
for k in range(0, CLS_FC.__len__()):
cls_layers.append(pt_utils.Conv1d(pre_channel, CLS_FC[k], bn=True))
pre_channel = CLS_FC[k]
cls_layers.append(pt_utils.Conv1d(pre_channel, 20, activation=None))
cls_layers.insert(1, nn.Dropout(0.5))
self.cls_layer = nn.Sequential(*cls_layers)
def __init__(self,
npoint=1024,
up_ratio=2,
use_normal=False,
use_bn=False,
use_res=False):
super().__init__()
self.npoint = npoint
self.use_normal = use_normal
self.up_ratio = up_ratio
self.npoints = [npoint, npoint // 2, npoint // 4, npoint // 8]
mlps = [[32, 32, 64], [64, 64, 128], [128, 128, 256], [256, 256, 512]]
radius = [0.05, 0.1, 0.2, 0.3]
nsamples = [32, 32, 32, 32]
## for 4 downsample layers
in_ch = 0 if not use_normal else 3
self.SA_modules = nn.ModuleList()
for k in range(len(self.npoints)):
self.SA_modules.append(
PointnetSAModule(npoint=self.npoints[k],
radius=radius[k],
nsample=nsamples[k],
mlp=[in_ch] + mlps[k],
use_xyz=True,
use_res=use_res,
bn=use_bn))
in_ch = mlps[k][-1]
## upsamples for layer 2 ~ 4
self.FP_Modules = nn.ModuleList()
for k in range(len(self.npoints) - 1):
self.FP_Modules.append(
PointnetFPModule(mlp=[mlps[k + 1][-1] + 64, 64], bn=use_bn))
## feature Expansion
in_ch = len(self.npoints) * 64 + 3 # 4 layers + input xyz
self.FC_Modules = nn.ModuleList()
for k in range(up_ratio):
self.FC_Modules.append(
pt_utils.SharedMLP([in_ch, 256, 128], bn=use_bn))
## coordinate reconstruction
in_ch = 128
self.pcd_layer = nn.Sequential(
pt_utils.SharedMLP([in_ch, 64], bn=use_bn),
pt_utils.SharedMLP([64, 3], activation=None, bn=False))
def __init__(self, input_channels=6):
super().__init__()
self.SA_modules = nn.ModuleList()
channel_in = input_channels
skip_channel_list = [input_channels]
for k in range(NPOINTS.__len__()): # k = 0,1,2,3
mlps = MLPS[k].copy() # mlps=MLPS[0], MLPS[1], MLPS[2], MLPS[3]
channel_out = 0
for idx in range(mlps.__len__()): # idx = 0,1
mlps[idx] = [channel_in] + mlps[
idx] #mlps=[0] = [0, 16, 16, 32] mlps[1] = [0, 32, 32, 64]
channel_out += mlps[idx][-1] # channel_out = 32+64 = 96
self.SA_modules.append(
PointnetSAModuleMSG(
npoint=NPOINTS[k],
radii=RADIUS[k],
nsamples=NSAMPLE[k],
mlps=mlps, #[[0, 16, 16, 32], [0, 32, 32, 64]]
use_xyz=True,
bn=True))
skip_channel_list.append(channel_out)
channel_in = channel_out
self.FP_modules = nn.ModuleList()
for k in range(FP_MLPS.__len__()):
pre_channel = FP_MLPS[
k + 1][-1] if k + 1 < len(FP_MLPS) else channel_out
self.FP_modules.append(
PointnetFPModule(mlp=[pre_channel + skip_channel_list[k]] +
FP_MLPS[k]))
cls_layers = []
pre_channel = FP_MLPS[0][-1]
for k in range(0, CLS_FC.__len__()):
cls_layers.append(pt_utils.Conv1d(pre_channel, CLS_FC[k], bn=True))
pre_channel = CLS_FC[k]
cls_layers.append(pt_utils.Conv1d(pre_channel, 1, activation=None))
cls_layers.insert(1, nn.Dropout(0.5))
self.cls_layer = nn.Sequential(*cls_layers)
def __init__(self,
input_channels=6,
out_dim=32,
npoints=[4096, 1024, 256, 64],
radius=[[0.1, 0.5], [0.5, 1.0], [1.0, 2.0], [2.0, 4.0]]):
super().__init__()
NPOINTS = npoints
RADIUS = radius
FP_MLPS[0] = [out_dim, out_dim]
self.SA_modules = nn.ModuleList()
channel_in = input_channels
skip_channel_list = [input_channels]
for k in range(NPOINTS.__len__()):
mlps = MLPS[k].copy()
channel_out = 0
for idx in range(mlps.__len__()):
mlps[idx] = [channel_in] + mlps[idx]
channel_out += mlps[idx][-1]
self.SA_modules.append(
PointnetSAModuleMSG(npoint=NPOINTS[k],
radii=RADIUS[k],
nsamples=NSAMPLE[k],
mlps=mlps,
use_xyz=True,
bn=True))
skip_channel_list.append(channel_out)
channel_in = channel_out
self.FP_modules = nn.ModuleList()
for k in range(FP_MLPS.__len__()):
pre_channel = FP_MLPS[
k + 1][-1] if k + 1 < len(FP_MLPS) else channel_out
self.FP_modules.append(
PointnetFPModule(mlp=[pre_channel + skip_channel_list[k]] +
FP_MLPS[k]))
'''
def __init__(self,
npoint=1024,
up_ratio=2,
use_normal=False,
use_bn=False,
use_res=False):
super().__init__()
self.npoint = npoint
self.use_normal = use_normal
self.up_ratio = up_ratio
self.npoints = [npoint // 2, npoint // 4, npoint // 8]
mlps = [[64, 64, 128], [128, 128, 256], [256, 256, 512]]
fp_mlps = [[128, 128, 128], [256, 128], [256, 256]]
radius = [0.1, 0.2, 0.3]
nsamples = [32, 32, 32, 32]
in_ch = 0 if not use_normal else 3
self.conv0 = PointnetSAModule(npoint=self.npoint,
radius=radius[0] / 2,
nsample=nsamples[0],
mlp=[in_ch, 32, 32, 64],
use_xyz=True,
use_res=use_res,
bn=use_bn)
## for 4 downsample layers
in_ch = 64
skip_ch_list = [in_ch]
self.SA_modules = nn.ModuleList()
for k in range(len(self.npoints)):
sa_mlpk = [in_ch] + mlps[k]
print(' -- sa_mlpk {}, radius {}, nsample {}, npoint {}.'.format(
sa_mlpk, radius[k], nsamples[k], self.npoints[k]))
self.SA_modules.append(
PointnetSAModule(npoint=self.npoints[k],
radius=radius[k],
nsample=nsamples[k],
mlp=sa_mlpk,
use_xyz=True,
use_res=use_res,
bn=use_bn))
in_ch = mlps[k][-1]
skip_ch_list.append(in_ch)
## upsamples for layer 2 ~ 4
self.FP_Modules = nn.ModuleList()
for k in range(len(self.npoints)):
pre_ch = fp_mlps[
k + 1][-1] if k < len(self.npoints) - 1 else skip_ch_list[-1]
fp_mlpk = [pre_ch + skip_ch_list[k]] + fp_mlps[k]
print(' -- fp_mlpk:', fp_mlpk)
self.FP_Modules.append(PointnetFPModule(mlp=fp_mlpk, bn=use_bn))
## feature Expansion
in_ch = fp_mlps[0][-1] + 3 # fp output + input xyz
self.FC_Modules = nn.ModuleList()
for k in range(up_ratio):
self.FC_Modules.append(
pt_utils.SharedMLP([in_ch, 256, 128], bn=use_bn))
## coordinate reconstruction
in_ch = 128
self.pcd_layer = nn.Sequential(
pt_utils.SharedMLP([in_ch, 64], bn=use_bn),
pt_utils.SharedMLP([64, 3], activation=None, bn=False))