PointNet++：Deep Hierarchical Feature Learning on Point Sets in a Metric Space
在上一篇文章中，提及了3D点云分类与分割的开山鼻祖——PointNet：https://blog.csdn.net/Alkaid2000/article/details/127253473，但是这篇PointNet是存在有很多不足之处的，在文章的末尾也提及了，它没有能力捕获局部结构，这使得在复杂的场景中也很难进行分析，道理也很简单，这篇文章只使用了Max操作以及MLP操作，也不符合当前神经网络的主流。PointNet++的作者主要通过两个主要的方法进行了改进，使得网络能更好的提取局部特征：
- 一是利用空间距离(metric space distances)，使用PointNet对点集局部区域进行特征迭代提取，使其能够学到局部尺度越来越大的特征。
- 二是由于点集分布很多时候是不均匀的，如果默认是均匀的，会使得网络性能变差，所以作者提出了一种自适应密度的特征提取方法。
文章目录
-
- 0x01 PointNet的存在问题
- 0x02 PointNet++算法解读
-
- （一）最远采样方法（farthest point sampling）
- （二）分组（grouping）
- （三）对各组进行特征提取
- （四）分类整体网络架构
- （五）分割整体网络架构
- 0x03 PointNet++遇到的问题
-
- （一）点云分布不一致的处理方法
- 0x04 源码阅读
-
- （一）环境配置
- （二）数据读取模块配置
- （二）网络模型架构
-
论文地址： https://arxiv.org/pdf/1706.02413.pdf
GitHub：https://github.com/yanx27/Pointnet_Pointnet2_pytorch
0x01 PointNet的存在问题
首先我们可以明显的感觉到这个网络与当下主流网络不符，没有局部特征融合，要不自己，要么一个整体。这个PointNet网络也没有关系概念，局部样本点之间肯定存在关系的，它没有考虑到这一层。于是PointNet++就从局部入手，多利用了局部特征。整体思想是不变的，只不过是在特征提取处使用类似图卷积的方式来整合特征。
-
PointNet的MLP，仅仅是对每个点的表征，对局部结构信息整合能力太弱（PointNet++改进：sampling和grouping整合局部邻域）
-
global feature直接由max pooling获得，无论对分类还是对分割任务，都会造成巨大的信息损失（PointNet++改进：hierarchical feature learning framework，通过多个set abstraction逐级降采样，获得不同规模不同层次的local-global feature）
-
分割任务的全局特征global feature是直接复制与local feature拼接，生成discriminative feature能力有限（PointNet++的改进：分割任务设计了encoder-decoder结构，先降采样再上采样，使用skip connection将对应层的local-global feature拼接）
PointNet++需要解决两个关键的问题：第一，如何将点集划分为不同的区域；第二，如何利用特征提取器获取不同区域的局部特征。
提到这个局部特征提取，可能大家都会想到CNN，因为在二维的图像中，卷积块成为了基本的特征提取器；但在3D点云中，我们同样需要找到结构相同的子区域和对应的区域特征提取器。在本文中，作者使用了PointNet作为特征提取器，另外一个问题就是如何来划分点集从而产生结构相同的区域，作者使用邻域球来定义分区，每个区域可以通过中心坐标和半径来确定。中心坐标的选取，作者使用了最远采样点算法来实现。
0x02 PointNet++算法解读
PointNet++是PointNet的延伸，在PointNet的基础上加入了多层次结构（hierarchical structure），使得网络能够在越来越大的区域上提供更高级别的特征。网络中的每一组set abstraction layers主要包括三个部分：
- Sample layer：主要是对输入点进行采样，在这些点中选出若干个中心点。
- Grouping layer：是利用上一步得到的中心点将点集划分成若干个区域。
- PointNet layer：是对上述得到的每个区域进行编码，变成特征向量。
（一）最远采样方法（farthest point sampling）
基于半径选择局部区域（类似于得到很多个簇），之后针对得到的每个区域进行特征提取（卷积），那么要解决的问题就是：如何选择区域（簇中心点选择），簇的半径大小如何定义，每个簇中选择多少个样本点。
- 先确定好每一个局部区域，接下来对局部区域执行pointnet：
例如我们现在需要输入1024个点，要选择128个中心点（簇），要如何采样呢：
选簇的这个感觉有点像是下采样的感觉，要尽可能地覆盖全部的数据，所以提出了最远点采样。比如最开始我们将点设置在了点云的头部，那么下一个点必须离我当前这个点最远，这样尽可能能覆盖；那么第三个点的确定，首先我们先画下两个点，需要确定这两个点距离第一个点的距离d1和第二个点距离d2，根据最远采样原则，我们要保留距离最大的那个点，成为我们第三个点。原则：离我其他已采样点是最远的。这样才可以尽可能覆盖到我们整个点云。
（二）分组（grouping）
假设我们现在得到了128个中心点，那么我们原始的输入其实是batch * 1024 * 6（1024个点，每个点对应3个坐标3个法向量信息），那么我经过最远采样后，我们将中心点以一定的半径将其包裹起来，所有的中心点圈到的点的数量必须一致，如果这个范围内不满足我们要求的点，那我们就会复制离中心点最近的点，直到补齐；如果比我们设定的点多的话，那么首先我们需要进行排序，以距离中心点的距离排序，从小到大排序，排序完后我们剔除离我们远的那些点，直到满足条件。假设我们一个圈中，需要有16个样本，分组后输出为：batch* 128 * 16 * 6（128个中心点，每个簇16个样本）。实际计算时是选择多种半径，多种样本点个数，目的是为了特征更丰富：例如半径=（0.1，0.2，0.4），那么对应簇的样本个数（16，32，64）。这样就可以通过多种半径的圈，可以得到多种特征，兼顾了局部与全局。
（三）对各组进行特征提取
- 先进行维度变换(b* npoints * nsample * features，8128 * 16 * 6-> 8 6 * 16* 128)，其中的npoints可以理解为channel。
- 进行卷积操作（例如：in：6，out：64）就得到提取的特征（8 * 64 * 16 *128）。
- 注意当前每个簇都是16个样本点，我们要每一个簇对应一个特征。
- 按照pointnet，做max操作，得到8 * 64 * 128（得到64维特征）
- 继续做多次采样，分组，卷积。
- 例如：采样中心点（1024->512->128）
- 每一次操作时，都要进行特征拼接（无论半径为0.1，0.2，0.4；以及簇采样点个数）
- 最终都得到batch* 中心点个数 * 特征（但是特征个数可能不同）
- 执行拼接操作（b * 512 * 128,b* 512 * 256,b* 512 * 512）->（b* 512 * 869）
那么在这里就结束了我们的特征提取了，接下来就是要对我们的特征进行分类。
（四）分类整体网络架构
那么先开始输入：其中的N可以理解为我们现在得到了多少个样本点，d可以代表我们现在当前的位置，C可以代表当前的特征。之后我们就做了一些簇，进行了pointnet，进行了最远采样操作，位置信息保持不变，C的特征数就进行改变了，通过不断的sampling与grouping，最终可以不断地更新C的值，接下来就是进行分类任务了。
首先先进行一次pointnet操作，其实也就是max操作，就可以得到一个实际的向量，再连全连接层，做一个分类任务。
（五）分割整体网络架构
在这里插入图片描述
分割任务有些不同，要得到每个点的特征，还需要进行上采样的操作。因为我们取了特征，点变少了，我们需要分割的话，要对大体进行分割，需要多一些的点，所以需要上采样，这个感觉会不会比较像是我们的点云补全？补全的时候是通过权重参数与距离相结合，得到新的特征后在与原先的点进行拼接；再继续做上采样，再次拼接，直到补全了我们输入的大小。
0x03 PointNet++遇到的问题
上面是整个PointNet++网络的基本流程，其实它很容易遇到这么一个问题，那就是样本点的个数，很容易受样本点的个数影响：
随着点的减小，准确率会越来越低。那么如何改进呢：
（一）点云分布不一致的处理方法
点云分布不一致时，每个区域中如果生成的时候使用相同的半径r，会导致有些区域采样点过少。作者提到这个问题需要解决，并且提出了两个方法：Multi-scale grouping (MSG) and Multi-resolution grouping (MRG)。
多半径进行特征拼接 或者 跨层来提取不同分辨率特征。
MSG：使用了不同的半径进行读取特征，最后将其拼接在一起。（源码中做的）
MRG：使用不同的分辨率，也就是分层来进行提取特征，最后将其拼接在一起。
改进之后的效果如下：
可以发现采样点个数下降时候不会严重影响结果，稳定性也得以提升。
论文的最后也提出了，PointNet++相比于PointNet还是取得了很好的效果，主要还是应用于分类与分割中：
0x04 源码阅读
在上面可以看到pointnet的一些文件，这是作为特征提取器的，也是原来的pointnet的代码。可以注意到文件名有msg以及ssg为文件名，区别在于msg使用的是多个半径来取特征点，而ssg只使用了一个半径。
接下来是设置训练的参数：
在开始训练的时候只需要：
python test_cls.py --model pointnet2_cls_msg --normal --log_dir pointnet2_cls_msg
（一）环境配置
conda create -n PointNet++ python==3.7
conda activate PointNet++
conda install pytorch==1.6.0 cudatoolkit=10.1 -c pytorch
pip install tqdm
（二）数据读取模块配置
其读取数据模块位于ModelNetDataLoader.py文件中的ModelNetDataLoader，首先要进行相关的初始化：
def __init__(self, root, npoint=1024, split='train', uniform=False, normal_channel=True, cache_size=15000):
self.root = root
self.npoints = npoint
self.uniform = uniform
self.catfile = os.path.join(self.root, 'modelnet40_shape_names.txt')
self.cat = [line.rstrip() for line in open(self.catfile)]
self.classes = dict(zip(self.cat, range(len(self.cat))))
self.normal_channel = normal_channel
shape_ids = {}
shape_ids['train'] = [line.rstrip() for line in open(os.path.join(self.root, 'modelnet40_train.txt'))]
shape_ids['test'] = [line.rstrip() for line in open(os.path.join(self.root, 'modelnet40_test.txt'))]
assert (split == 'train' or split == 'test')
shape_names = ['_'.join(x.split('_')[0:-1]) for x in shape_ids[split]]
# list of (shape_name, shape_txt_file_path) tuple
self.datapath = [(shape_names[i], os.path.join(self.root, shape_names[i], shape_ids[split][i]) + '.txt') for i
in range(len(shape_ids[split]))]
print('The size of %s data is %d'%(split,len(self.datapath)))
self.cache_size = cache_size # how many data points to cache in memory
self.cache = {} # from index to (point_set, cls) tuple
可以看看对应的数据集：
之后将其类别以及id存进来，再读对应的坐标点：
def _get_item(self, index):
if index in self.cache:
point_set, cls = self.cache[index]
else:
fn = self.datapath[index]
cls = self.classes[self.datapath[index][0]]
cls = np.array([cls]).astype(np.int32)
point_set = np.loadtxt(fn[1], delimiter=',').astype(np.float32)
#读入xyz特征以及额外信息特征
if self.uniform:
point_set = farthest_point_sample(point_set, self.npoints)
#采样，只取其中一部分
else:
point_set = point_set[0:self.npoints,:]
point_set[:, 0:3] = pc_normalize(point_set[:, 0:3])#相当于3列值，做坐标值标准化
if not self.normal_channel:
point_set = point_set[:, 0:3]
if len(self.cache) < self.cache_size:
#标准化以及标签
self.cache[index] = (point_set, cls)
return point_set, cls
（二）网络模型架构
可以在文件pointnet2_cls_msg.py中可以看到forward函数：
def forward(self, xyz):
B, _, _ = xyz.shape
if self.normal_channel:
norm = xyz[:, 3:, :]
xyz = xyz[:, :3, :] #位置信息
else:
norm = None
print(xyz.shape)
print(norm.shape)
l1_xyz, l1_points = self.sa1(xyz, norm)
l2_xyz, l2_points = self.sa2(l1_xyz, l1_points)
l3_xyz, l3_points = self.sa3(l2_xyz, l2_points)
x = l3_points.view(B, 1024)
x = self.drop1(F.relu(self.bn1(self.fc1(x))))
x = self.drop2(F.relu(self.bn2(self.fc2(x))))
x = self.fc3(x)
x = F.log_softmax(x, -1)
return x,l3_points
在进入forward之前，我们首先要看看这些东西它经历了哪些层：
def __init__(self,num_class,normal_channel=True):
super(get_model, self).__init__()
in_channel = 3 if normal_channel else 0
self.normal_channel = normal_channel
self.sa1 = PointNetSetAbstractionMsg(512, [0.1, 0.2, 0.4], [16, 32, 128], in_channel,[[32, 32, 64], [64, 64, 128], [64, 96, 128]])
self.sa2 = PointNetSetAbstractionMsg(128, [0.2, 0.4, 0.8], [32, 64, 128], 320,[[64, 64, 128], [128, 128, 256], [128, 128, 256]])
self.sa3 = PointNetSetAbstraction(None, None, None, 640 + 3, [256, 512, 1024], True)
self.fc1 = nn.Linear(1024, 512)
self.bn1 = nn.BatchNorm1d(512)
self.drop1 = nn.Dropout(0.4)
self.fc2 = nn.Linear(512, 256)
self.bn2 = nn.BatchNorm1d(256)
self.drop2 = nn.Dropout(0.5)
self.fc3 = nn.Linear(256, num_class)
那么其中的PointNetSetAbstractionMsg，其实就是规定了多少个中心点以及圆的半径，下面就是各种采样的操作了。
那么在这句开始，我们就已经进入网络了：
l1_xyz, l1_points = self.sa1(xyz, norm)
他会进入pointnet_util.py这个文件中的PointNetSetAbstractionMsg类中，也就是我们网络模型开始取特征的开始啦：
def forward(self, xyz, points):
"""
Input:
xyz: input points position data, [B, C, N]
points: input points data, [B, D, N]
Return:
new_xyz: sampled points position data, [B, C, S]
new_points_concat: sample points feature data, [B, D', S]
"""
xyz = xyz.permute(0, 2, 1) #就是坐标点位置特征
print(xyz.shape)
if points is not None:
points = points.permute(0, 2, 1) #就是额外提取的特征，第一次的时候就是那个法向量特征
print(points.shape)
B, N, C = xyz.shape
S = self.npoint #表示选多少个中心点
new_xyz = index_points(xyz, farthest_point_sample(xyz, S))#采样后的点，最远点采样函数
print(new_xyz.shape)
new_points_list = []
for i, radius in enumerate(self.radius_list):
K = self.nsample_list[i]
group_idx = query_ball_point(radius, K, xyz, new_xyz)#返回的是索引
grouped_xyz = index_points(xyz, group_idx)#得到各个组中实际点
grouped_xyz -= new_xyz.view(B, S, 1, C)#去mean new_xyz相当于簇的中心点
if points is not None:
grouped_points = index_points(points, group_idx)
grouped_points = torch.cat([grouped_points, grouped_xyz], dim=-1)
print(grouped_points.shape)
else:
grouped_points = grouped_xyz
grouped_points = grouped_points.permute(0, 3, 2, 1) # [B, D, K, S]
print(grouped_points.shape)
for j in range(len(self.conv_blocks[i])):
conv = self.conv_blocks[i][j]
bn = self.bn_blocks[i][j]
grouped_points = F.relu(bn(conv(grouped_points)))
print(grouped_points.shape)
new_points = torch.max(grouped_points, 2)[0] # [B, D', S] 就是pointnet里的maxpool操作
print(new_points.shape)
new_points_list.append(new_points)
new_xyz = new_xyz.permute(0, 2, 1)
new_points_concat = torch.cat(new_points_list, dim=1)
print(new_points_concat.shape)
return new_xyz, new_points_concat
上面函数输入了位置信息xyz以及特征信息points，原始输入的话那么这个points就是我们的法向量啦，接下来这个返回值，就是我们计算后得到的这个点，下一步要进行下采样或者是各种操作，提特征也是通过多种半径进行提取的，最后将其拼接在一起。
那么最远点采样的实现细节：
def farthest_point_sample(xyz, npoint):
"""
Input:
xyz: pointcloud data, [B, N, 3]
npoint: number of samples
Return:
centroids: sampled pointcloud index, [B, npoint]
"""
device = xyz.device
B, N, C = xyz.shape
centroids = torch.zeros(B, npoint, dtype=torch.long).to(device)# 8*512
#距离矩阵
distance = torch.ones(B, N).to(device) * 1e10 # 8*1024
#第一个点是随机来的，后面的点才有距离计算
farthest = torch.randint(0, N, (B,), dtype=torch.long).to(device)# batch里每个样本随机初始化一个最远点的索引
batch_indices = torch.arange(B, dtype=torch.long).to(device)
for i in range(npoint):
centroids[:, i] = farthest # 第一个采样点选随机初始化的索引
centroid = xyz[batch_indices, farthest, :].view(B, 1, 3)# 得到当前采样点的坐标 B*3
dist = torch.sum((xyz - centroid) ** 2, -1)# 计算当前采样点与其他点的距离
mask = dist < distance# 选择距离最近的来更新距离（更新维护这个表）
distance[mask] = dist[mask]# 把最近的那个距离存下来
farthest = torch.max(distance, -1)[1]# 重新计算得到最远点索引（在更新的表中选择距离最大的那个点），在最小距离中选择距离最大的点
return centroids
他的返回值是告诉采样后的点哪个点是中心点，最后就可以得到所有的中心点啦，这个函数也是sampling的环节。那么这个函数结束后，他会把结果给到这个函数index_points：
def index_points(points, idx):
"""
Input:
points: input points data, [B, N, C]
idx: sample index data, [B, S]
Return:
new_points:, indexed points data, [B, S, C]
"""
device = points.device
B = points.shape[0]
view_shape = list(idx.shape)
view_shape[1:] = [1] * (len(view_shape) - 1)
repeat_shape = list(idx.shape)
repeat_shape[0] = 1
batch_indices = torch.arange(B, dtype=torch.long).to(device).view(view_shape).repeat(repeat_shape)
new_points = points[batch_indices, idx, :]
return new_points
这个函数是将索引与得到的位置索引，传到point中，得到实际的特征，得到了每个中心点的特征。接下来就是MSG了：
for i, radius in enumerate(self.radius_list):
K = self.nsample_list[i]
group_idx = query_ball_point(radius, K, xyz, new_xyz)#返回的是索引，以中心点为圆心，画圈
grouped_xyz = index_points(xyz, group_idx) # 得到各个组中实际点
grouped_xyz -= new_xyz.view(B, S, 1, C) # 去mean new_xyz相当于簇的中心点，每个值都减去中心点，给人一种去均值的感觉
if points is not None:
# 基于关系提特征，要将位置信息以及法向量进行拼接
grouped_points = index_points(points, group_idx)
grouped_points = torch.cat([grouped_points, grouped_xyz], dim=-1)
print(grouped_points.shape)
else:
grouped_points = grouped_xyz
半径在上面的__init _ _中已经初始化成功了。那么我们重点看看这个函数query_ball_point：
def query_ball_point(radius, nsample, xyz, new_xyz):
"""
Input:
radius: local region radius
nsample: max sample number in local region
xyz: all points, [B, N, 3]
new_xyz: query points, [B, S, 3]
Return:
group_idx: grouped points index, [B, S, nsample]
"""
device = xyz.device
B, N, C = xyz.shape
_, S, _ = new_xyz.shape
#每个组大小规模都一样
group_idx = torch.arange(N, dtype=torch.long).to(device).view(1, 1, N).repeat([B, S, 1])
sqrdists = square_distance(new_xyz, xyz)# 得到B N M （就是N个点中每一个和M中每一个的欧氏距离）
group_idx[sqrdists > radius ** 2] = N # 找到距离大于给定半径的设置成一个N值（1024）索引，表示不在我们半径当中
group_idx = group_idx.sort(dim=-1)[0][:, :, :nsample]#做升序排序，后面的都是大的值（1024），排序后才可以进行筛选
group_first = group_idx[:, :, 0].view(B, S, 1).repeat([1, 1, nsample])#如果半径内的点没那么多，就直接用第一个点来代替了，直接就是赋值到我们规定的那个数
mask = group_idx == N # 剔除不在半径中的点
group_idx[mask] = group_first[mask]
return group_idx
最后返回的是每个组的所有用到的点，也就是我们圈中的点。得到我们的中心点后，接下来就要提取特征啦：
for i, radius in enumerate(self.radius_list):
K = self.nsample_list[i]
group_idx = query_ball_point(radius, K, xyz, new_xyz)#返回的是索引，以中心点为圆心，画圈
grouped_xyz = index_points(xyz, group_idx) # 得到各个组中实际点
grouped_xyz -= new_xyz.view(B, S, 1, C) # 去mean new_xyz相当于簇的中心点，每个值都减去中心点，给人一种去均值的感觉
if points is not None:
# 基于关系提特征，要将位置信息以及法向量进行拼接
grouped_points = index_points(points, group_idx)
grouped_points = torch.cat([grouped_points, grouped_xyz], dim=-1)
print(grouped_points.shape)
else:
grouped_points = grouped_xyz
# 维度转换
grouped_points = grouped_points.permute(0, 3, 2, 1) # [B, D, K, S]
print(grouped_points.shape)
# 输入几个特征
for j in range(len(self.conv_blocks[i])):
conv = self.conv_blocks[i][j]
bn = self.bn_blocks[i][j]
# 提特征
grouped_points = F.relu(bn(conv(grouped_points)))
print(grouped_points.shape)
new_points = torch.max(grouped_points, 2)[0] # [B, D', S] 就是pointnet里的maxpool操作，取最大值
print(new_points.shape)
new_points_list.append(new_points)
最后把我们所有半径找到的特征都拼接在一起：
new_xyz = new_xyz.permute(0, 2, 1)
new_points_concat = torch.cat(new_points_list, dim=1)
print(new_points_concat.shape)
return new_xyz, new_points_concat
那么经过上面层层的考核，我们终于把前向传播的sa1走完了，接下来就是sa2：
那么sa1与sa2有什么区别：
其实就是改变了参数，可以发现这一次的目的是要在512中选128个特征了。之后又要经历我们上面所说的东西了，一模一样的过程，只不过第二次输入进来的特征变成上一次得到的特征数了。
接下来就是sa3了，可以看到这个参数与sa1、sa2不一样，sa3并不是多半径：
他把所有的点都归为一个组，之后进行MLP，进行一次maxpooling，最后得到了我们最终的特征，每个点取最大值，这一点跟pointnet中的操作是一模一样的。
之后进行全连接层，1024->512，512->256，256->40，最终对1024个特征完成40类别的分类，最后softmax一下就可以得到输出结果。
以上就结束了分类任务。那么接下来就轮到分割任务啦：
分割任务需要这么配置：
python train_partseg.py --model pointnet2_part_seg_msg --normal --log_dir pointnet2_part_seg_msg
可以发现其参数都是差不多的，大同小异，然后其不一样的地方在于，在参数的规定中，我们都规定了这输入的点的个数为2048个点：
那么对于要达到这个2048个点的指标，我们也有进行上采样的操作：
其具体操作其实跟我们的分类任务很像：
def forward(self, xyz1, xyz2, points1, points2):
"""
Input:
xyz1: input points position data, [B, C, N]
xyz2: sampled input points position data, [B, C, S]
points1: input points data, [B, D, N]
points2: input points data, [B, D, S]
Return:
new_points: upsampled points data, [B, D', N]
"""
xyz1 = xyz1.permute(0, 2, 1)
xyz2 = xyz2.permute(0, 2, 1)
print(xyz1.shape)
print(xyz2.shape)
points2 = points2.permute(0, 2, 1)
print(points2.shape)
B, N, C = xyz1.shape
_, S, _ = xyz2.shape
if S == 1:
# 复制操作，为了达到指标（第一次）
interpolated_points = points2.repeat(1, N, 1)
print(interpolated_points.shape)
else:
#根据距离插值，把最近的点进行插值扩充
dists = square_distance(xyz1, xyz2)
print(dists.shape)
dists, idx = dists.sort(dim=-1)
dists, idx = dists[:, :, :3], idx[:, :, :3] # [B, N, 3]
dist_recip = 1.0 / (dists + 1e-8)
norm = torch.sum(dist_recip, dim=2, keepdim=True)
weight = dist_recip / norm
print(weight.shape)
print(index_points(points2, idx).shape)
interpolated_points = torch.sum(index_points(points2, idx) * weight.view(B, N, 3, 1), dim=2)
print(interpolated_points.shape)
if points1 is not None:
points1 = points1.permute(0, 2, 1)
# 拼接操作
new_points = torch.cat([points1, interpolated_points], dim=-1)
else:
new_points = interpolated_points
print(new_points.shape)
new_points = new_points.permute(0, 2, 1)
print(new_points.shape)
#MLP 找到特征
for i, conv in enumerate(self.mlp_convs):
bn = self.mlp_bns[i]
new_points = F.relu(bn(conv(new_points)))
print(new_points.shape)
return new_points
之后得到的这个特征又要进行上采样操作，使用的近距离插值，加权得到我们下一个点，最终得到了2048个点，都走上面那个代码。
之后对我们的点进行做分类任务，也就是相当于分割了：
feat = F.relu(self.bn1(self.conv1(l0_points)))
x = self.drop1(feat)
x = self.conv2(x)
x = F.log_softmax(x, dim=1)
x = x.permute(0, 2, 1)
这个就是分割任务的细节实现了，只不过相比于分类任务多了一个上采样。