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

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第1张图片

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++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第2张图片

  • 先确定好每一个局部区域,接下来对局部区域执行pointnet:
    PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第3张图片

例如我们现在需要输入1024个点,要选择128个中心点(簇),要如何采样呢:

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第4张图片

选簇的这个感觉有点像是下采样的感觉,要尽可能地覆盖全部的数据,所以提出了最远点采样。比如最开始我们将点设置在了点云的头部,那么下一个点必须离我当前这个点最远,这样尽可能能覆盖;那么第三个点的确定,首先我们先画下两个点,需要确定这两个点距离第一个点的距离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)

那么在这里就结束了我们的特征提取了,接下来就是要对我们的特征进行分类。

(四)分类整体网络架构

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第5张图片

那么先开始输入:其中的N可以理解为我们现在得到了多少个样本点,d可以代表我们现在当前的位置,C可以代表当前的特征。之后我们就做了一些簇,进行了pointnet,进行了最远采样操作,位置信息保持不变,C的特征数就进行改变了,通过不断的sampling与grouping,最终可以不断地更新C的值,接下来就是进行分类任务了。

首先先进行一次pointnet操作,其实也就是max操作,就可以得到一个实际的向量,再连全连接层,做一个分类任务。

(五)分割整体网络架构

在这里插入图片描述

分割任务有些不同,要得到每个点的特征,还需要进行上采样的操作。因为我们取了特征,点变少了,我们需要分割的话,要对大体进行分割,需要多一些的点,所以需要上采样,这个感觉会不会比较像是我们的点云补全?补全的时候是通过权重参数与距离相结合,得到新的特征后在与原先的点进行拼接;再继续做上采样,再次拼接,直到补全了我们输入的大小。

0x03 PointNet++遇到的问题

上面是整个PointNet++网络的基本流程,其实它很容易遇到这么一个问题,那就是样本点的个数,很容易受样本点的个数影响

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第6张图片

随着点的减小,准确率会越来越低。那么如何改进呢:

(一)点云分布不一致的处理方法

点云分布不一致时,每个区域中如果生成的时候使用相同的半径r,会导致有些区域采样点过少。作者提到这个问题需要解决,并且提出了两个方法:Multi-scale grouping (MSG) and Multi-resolution grouping (MRG)

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第7张图片

多半径进行特征拼接 或者 跨层来提取不同分辨率特征。

MSG:使用了不同的半径进行读取特征,最后将其拼接在一起。(源码中做的)

MRG:使用不同的分辨率,也就是分层来进行提取特征,最后将其拼接在一起。

改进之后的效果如下:

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第8张图片

可以发现采样点个数下降时候不会严重影响结果,稳定性也得以提升。

论文的最后也提出了,PointNet++相比于PointNet还是取得了很好的效果,主要还是应用于分类与分割中:

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第9张图片

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第10张图片

0x04 源码阅读

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第11张图片

在上面可以看到pointnet的一些文件,这是作为特征提取器的,也是原来的pointnet的代码。可以注意到文件名有msg以及ssg为文件名,区别在于msg使用的是多个半径来取特征点,而ssg只使用了一个半径。

接下来是设置训练的参数:

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第12张图片

在开始训练的时候只需要:

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

可以看看对应的数据集:

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第13张图片

之后将其类别以及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:

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第14张图片

那么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

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第15张图片

可以发现其参数都是差不多的,大同小异,然后其不一样的地方在于,在参数的规定中,我们都规定了这输入的点的个数为2048个点:

PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第16张图片

那么对于要达到这个2048个点的指标,我们也有进行上采样的操作:

在这里插入图片描述

其具体操作其实跟我们的分类任务很像:
PointNet++:Deep Hierarchical Feature Learning on Point Sets in a Metric Space_第17张图片

 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)

这个就是分割任务的细节实现了,只不过相比于分类任务多了一个上采样。

你可能感兴趣的:(深度学习,人工智能,计算机视觉,3D点云,神经网络)