updates

Author: BinaryOracle

src/.vuepress/public/assets/cover/PointNet++.png

@@ -8,7 +8,7 @@ tag:
   - 编辑中
 footer: 技术共建，知识共享
 date: 2025-05-25
-cover: assets/cover/PointNet.png
+cover: assets/cover/PointNet++.png
 author:
   - BinaryOracle
 ---
@@ -19,3 +19,289 @@ author:
 
 # 简析PointNet++
 
+> 论文: [https://arxiv.org/abs/1706.02413](https://arxiv.org/abs/1706.02413)
+> TensorFlow 版本代码: [https://github.com/charlesq34/pointnet2](https://github.com/charlesq34/pointnet2)
+> Pytorch 版本代码: [https://github.com/yanx27/Pointnet_Pointnet2_pytorch](https://github.com/yanx27/Pointnet_Pointnet2_pytorch)
+
+## 背景
+
+在PointNet中，网络对每一个点做低维到高维的映射，进行特征学习，然后把所有点映射到高维的特征通过最大池化最终表示全局特征。从本质上来说，要么对一个点做操作，要么对所有点做操作，实际上没有**局部的概念(loal context)** 。同时缺少 local context 在**平移不变性**上也有局限性（世界坐标系和局部坐标系）。对点云数据做平移操作后，所有的数据都将发生变化，导致所有的特征，全局特征都不一样了。对于单个的物体还好，可以将其平移到坐标系的中心，把他的大小归一化到一个球中，但是在一个场景中有多个物体时则不好办，需要对哪个物体做归一化呢？
+
+PointNet++ 解决了两个问题：如何生成点集的划分（Partitioning），以及如何通过局部特征学习器（Local Feature Learner）抽象点集或局部特征。
+
+**生成点集的划分（Partitioning）：**
+
+点集划分是指如何将一个大的点云分割成更小的、更易于管理的子集。这个过程类似于在传统的卷积神经网络中如何处理图像的小区域（或“patches”），以便可以在这些区域上应用局部操作。PointNet++需要一种方法来有效地将点云分割成多个部分，这样可以在每个部分上独立地学习特征。
+
+**通过局部特征学习器（Local Feature Learner）抽象点集或局部特征：**
+
+一旦点云被划分成小的子集，PointNet++的下一个任务是学习这些子集（或局部区域）的特征。这需要一个“局部特征学习器”，它能够从每个子集中提取有用的信息或特征。这与在传统CNN中学习图像局部区域特征的过程相似。
+
+**两个问题是相关联的，因为：**
+
+点集的划分必须产生跨分区的共同结构：为了能够在不同的局部子集上共享权重（类似于在CNN中权重共享的概念），PointNet++在进行点集划分时，需要确保这些划分具有一定的一致性或共同结构。这意味着即使是不同的局部子集，也应该以一种方式被处理，使得在它们之间可以共享学习到的特征表示的权重。这样做的目的是提高模型的效率和泛化能力，因为学习到的特征和权重可以在多个局部区域中复用。
+
+上述即为PointNet++设计中的两个核心挑战：
+- 如何有效地对点云进行分区，以便可以在这些分区上独立地学习特征。
+- 如何设计一个能够从这些局部分区中学习有用特征的机制，同时确保这些分区的处理方式允许在它们之间共享模型权重。
+  - 为了模仿传统卷积网络中的权重共享机制以提高学习效率和模型的泛化能力。
+
+PointNet++选择PointNet作为局部特征学习器（它是无序点云数据特征提取的高效算法）。
+
+> 可以理解为：PointNet++应用PointNet递归地对输入集进行嵌套分区。
+
+## 模型结构
+
+![以二维欧几里得空间为例，网络的分割和分类模型](简析PointNet++/1.png)
+
+网络的每一组set abstraction layers主要包括3个部分：
+
+- Sample layer : 对输入点进行采样，在这些点中选出若干个中心点。
+
+- Grouping layer : 利用上一步得到的中心点将点集划分成若干个区域。
+
+- PointNet layer : 对上述得到的每个区域进行编码，变成特征向量。
+
+### 层次化点集特征学习
+
+层次化结构由多个set abstraction layers组成，在每个层上，一组点云被处理和抽象，以产生一个更少元素的新集合。set abstraction layers 由 Sampling layer、Grouping layer 和 PointNet layer 三部分组成。
+
+- Sampling layer ：采样层 从输入点中选取一组点，定义局部区域的形心。
+
+- Grouping layer ：通过查找形心点周围的“邻近点”来构建局部区域点集。
+
+- PointNet layer ：使用mini-PointNet将局部区域编码为特征向量。
+
+#### Sampling layer
+
+使用farthest point sampling（FPS）选择𝑁个点（相比于随机采样，该方法能更好的覆盖整个点集，具体选择多少个中心点以及邻域内的数量由超参数确定）
+
+FPS是一种在点云、图像处理或其他数据集中用于抽样的算法。目的是从一个大的数据集中选出一组代表性强的点，这些点彼此之间的最小距离尽可能大。
+
+作者通过FPS来抽样点集中较为重要的点。（即任务是找到点云集中的局部区域的中心点）
+
+> 可能存在的问题：计算成本、样本分布偏差（可能导致样本在高密度区域内过度集中，低密度区域则过于稀缺）、参数依赖（依赖初始点和距离度量方式的选择）、可能无法捕捉重要的几何细节。
+
+#### Grouping layer
+
+文中作者通过Ball query来查询形心的邻居点。
+
+具体做法：给定两个超参数（每个区域中点的数量𝐾和query的半径𝑟），对于某个形心，Ball query找到该查询点在半径为𝑟范围内点，该范围确保局部区域的尺度是固定的。
+
+与K最近邻（kNN）查询相比，Ball query通过固定区域尺度而不是固定邻居数量来定义邻域。kNN查询寻找最近的K个邻居，但这可能导致所选邻域的实际尺寸随点的密度变化而变化，这在处理非均匀采样的数据时可能不是最优的选择。相反，Ball query通过确保每个局部区域都有一个固定的尺度，提高了模型在空间上的泛化能力。在实现时，通常会设置一个上限K，以限制每个局部区域中考虑的点的数量，以保持计算的可管理性。
+
+> **可改进的地方**：对点云密度变换较为敏感、对参数选择依赖性高（半径太小可能无法有效捕获足够的局部详细，太大则可能导致不相关的点增多，使局部特征的表示不够精确）、计算效率问题、均匀性假设（Ball query是基于欧氏距离的均匀性假设）
+> - 欧式距离的均匀性假设：即在欧氏空间中，两点的距离反映了这两点的实际相似度或关联度。
+> - 基于以下前提：
+>    - 空间均匀性：空间是均匀和各向同性的，即任何方向上的度量都是等价的，距离的度量不受空间中位置的影响。
+>    - 距离直观性：在屋里空间或某些特定的抽象空间中，两个点之间的直线距离被认为是相似度或连接强度的直观表示。
+>    - 规模一致性：假设空间中所有区域的尺度或特征分布具有一定的一致性，即空间中的任何距离值具有相似的含义。
+
+总结: Grouping layer的任务是通过中心点找到邻居点，并将它们组织称为局部区域集。
+
+#### PointNet layer
+
+局部坐标系转换：局部区域中的点转换成相对于形心的局部坐标系。 
+
+> 局部区域中的每个点将相对于形心所在位置进行调整，以反映其相对位置。
+
+实现方法：通过将局部区域中的每个点-形心点的坐标来实现。
+
+特征编码：将转换后的坐标以及点的附加特征（文中的𝐶所表示的其他信息）一起送入mini-PointNet来提取局部区域中的特征。
+
+输出：利用相对坐标与点特征相结合的方式可以捕获局部区域中点与点之间的关系。
+
+#### 代码实现
+
+PointNetSetAbstraction（点集抽象层） 是 PointNet++ 中的核心模块 ， 它的作用是负责从输入的点云数据中采样关键点，构建它们的局部邻域区域，并通过一个小型 PointNet 提取这些区域的高维特征，从而实现点云的分层特征学习。
+
+```python
+class PointNetSetAbstraction(nn.Module):
+    def __init__(self, npoint, radius, nsample, in_channel, mlp, group_all):
+        super(PointNetSetAbstraction, self).__init__()
+        self.npoint = npoint # 采样的关键点数量
+        self.radius = radius # 构建局部邻域的半径
+        self.nsample = nsample # 每个邻域内采样的关键点数量
+        self.mlp_convs = nn.ModuleList()
+        self.mlp_bns = nn.ModuleList()
+        last_channel = in_channel # 输入点的特征维度
+        for out_channel in mlp:
+            self.mlp_convs.append(nn.Conv2d(last_channel, out_channel, 1))
+            self.mlp_bns.append(nn.BatchNorm2d(out_channel))
+            last_channel = out_channel
+        self.group_all = group_all
+
+    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) # [B, N, C]
+        if points is not None:
+            points = points.permute(0, 2, 1)
+
+        # 如果 group_all=True，则对整个点云做全局特征提取。
+        if self.group_all:
+            new_xyz, new_points = sample_and_group_all(xyz, points)
+        else:  
+        # 否则使用 FPS（最远点采样）选关键点，再用 Ball Query 找出每个点的局部邻近点。    
+            # 参数: 质点数量，采样半径，采样点数量，点坐标，点额外特征
+            new_xyz, new_points = sample_and_group(self.npoint, self.radius, self.nsample, xyz, points)
+        # 局部特征编码（Mini-PointNet）    
+        # new_xyz: sampled points position data, [B, npoint, C]
+        # new_points: sampled points data, [B, npoint, nsample, C+D]
+        # 把邻域点的数据整理成适合卷积的格式 [B, C+D, nsample, npoint]
+        new_points = new_points.permute(0, 3, 2, 1)
+        # 使用多个 Conv2d + BatchNorm + ReLU 层提取特征
+        for i, conv in enumerate(self.mlp_convs):
+            bn = self.mlp_bns[i]
+            new_points =  F.relu(bn(conv(new_points))) # [B, out_channel , nsample, npoint]
+        
+        # 对每个局部区域内所有点的最大响应值进行池化，得到该区域的固定长度特征表示。
+        # 输出形状为 [B, out_channel, nsample]，即每个查询点有一个特征向量。
+        new_points = torch.max(new_points, 2)[0]
+        new_xyz = new_xyz.permute(0, 2, 1) # [B, C, npoint]
+        return new_xyz, new_points
+```
+
+sample_and_group 这个函数的作用是从输入点云中：
+- 采样一些关键点
+- 为每个关键点构建局部邻域（局部区域）
+- 提取这些局部区域中的点及其特征
+
+```python
+def sample_and_group(npoint, radius, nsample, xyz, points, returnfps=False):
+    """
+    Input:
+        npoint: 采样的关键点数量
+        radius: 构建局部邻域的半径
+        nsample: 每个邻域内采样的关键点数量
+        xyz: 点云坐标数据 , [B, N, 3]
+        points: 点的特征数据（可选）, [B, N, D]
+    Return:
+        new_xyz: 采样得到的关键点坐标, [B, npoint, nsample, 3]
+        new_points: 每个关键点对应的局部区域点和特征, [B, npoint, nsample, 3+D]
+    """
+    B, N, C = xyz.shape
+    S = npoint
+    # 使用 最远点采样（FPS） 从原始点云中选出 npoint 个具有代表性的点。
+    fps_idx = farthest_point_sample(xyz, npoint) # [B, npoint]
+    new_xyz = index_points(xyz, fps_idx) # [B, npoint, 3]
+    # 对于每个选中的关键点，使用 球查询（Ball Query） 找出它周围距离小于 radius 的所有邻近点。
+    # 最多保留 nsample 个点，如果不够就重复最近的点来填充。
+    idx = query_ball_point(radius, nsample, xyz, new_xyz)
+    # 把刚才找到的邻近点的坐标提取出来。
+    grouped_xyz = index_points(xyz, idx) # [B, npoint, nsample, 3]
+    # 把它们相对于关键点的位置进行归一化（平移中心到以关键点为原点的局部坐标系上）。
+    grouped_xyz_norm = grouped_xyz - new_xyz.view(B, S, 1, C) # [B, npoint, nsample, 3]
+
+    # 如果有额外的点特征（比如颜色、法线等），也一并提取。 
+    if points is not None:
+        grouped_points = index_points(points, idx)
+        # 把邻近点的坐标和特征拼接在一起，形成最终的局部区域表示。
+        new_points = torch.cat([grouped_xyz_norm, grouped_points], dim=-1) # [B, npoint, nsample, C+D]
+    else:
+        new_points = grouped_xyz_norm
+
+    if returnfps:
+        return new_xyz, new_points, grouped_xyz, fps_idx
+    else:
+        return new_xyz, new_points
+```
+
+farthest_point_sample 这个函数实现的是最远点采样（Farthest Point Sampling, FPS）, 这是 PointNet++ 中用于从点云中选择具有代表性的采样点的一种策略。它的核心思想是：**在点云中逐步选择离已选点尽可能远的点，使得采样点在整个点云空间中分布尽可能均匀** 。
+
+```python
+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) # 存储每次选出的“最远点”的索引。
+    distance = torch.ones(B, N).to(device) * 1e10 # 每个点到当前所有已选中心点的最小距离，初始设为一个极大值（1e10）。
+    farthest = torch.randint(0, N, (B,), dtype=torch.long).to(device) # 初始时随机选择一个点作为第一个中心点。
+    batch_indices = torch.arange(B, dtype=torch.long).to(device) # 批次索引，用于快速访问每个 batch 的点。
+    # 重复 npoint 次，最终得到 npoint 个分布尽可能均匀的采样点索引。
+    for i in range(npoint):
+        # 将当前选中的“最远点”索引保存下来；
+        centroids[:, i] = farthest # （batch,npoint)
+        # 取出当前最远点的坐标，用于后续计算其他点到该点的距离; 
+        centroid = xyz[batch_indices, farthest, :].view(B, 1, 3) # # （batch, 1 , 3)
+        # 计算当前中心点与所有点之间的欧氏距离平方。
+        dist = torch.sum((xyz - centroid) ** 2, -1) # （batch,npoint)
+        # 如果某个点到新中心点的距离比之前记录的“最小距离”还小，就更新它。
+        mask = dist < distance
+        # 在 distance 中找到最大的那个距离对应的点，这就是下一个“最远点”。
+        distance[mask] = dist[mask]   # （batch,npoint)
+        # 在 distance 中找到最大的那个距离对应的点，这就是下一个“最远点”。
+        # 返回：一个元组：(values, indices)，分别是最大值和它们的位置索引。
+        farthest = torch.max(distance, -1)[1] # 返回位置索引
+    return centroids
+```
+
+index_points 这个函数实现的是根据给定的索引 idx，从输入点云 points 中提取对应的点，形成一个新的子集。
+
+```python
+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) # 将view_shape的形状从[B, S]变成[B, 1]，便于广播
+    repeat_shape = list(idx.shape) 
+    repeat_shape[0] = 1 # 从[B, S]变成[1, S]
+    # 从点云中根据索引提取特定点 (看不懂下面两行代码的话，可以先去了解一下python中的高级索引机制)。
+    batch_indices = torch.arange(B, dtype=torch.long).to(device).view(view_shape).repeat(repeat_shape)
+    new_points = points[batch_indices, idx, :] # （batch,npoint,3)
+    return new_points 
+```
+query_ball_point 这个函数的作用是从点云中找出每个查询点周围一定半径范围内的邻近点索引。这个操作被称为 球查询（Ball Query）。
+
+```python
+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 # 查询点数量（比如通过 FPS 得到的质心）
+    # 构造一个从 0 到 N-1 的索引数组，代表原始点云中每个点的“身份证号”
+    # 然后复制这个索引数组到每个 batch 和每个查询点上，形成 [B, S, N] 的结构    
+    group_idx = torch.arange(N, dtype=torch.long).to(device).view(1, 1, N).repeat([B, S, 1])
+    # 计算每个查询点（new_xyz）与原始点（xyz）之间的平方欧氏距离
+    # 输出形状为 [B, S, N]：每个查询点对所有原始点的距离
+    sqrdists = square_distance(new_xyz, xyz)
+    # 把距离超过 radius^2 的点全部替换为 N（一个非法索引），表示“这些人离我太远了，我不感兴趣。”   
+    group_idx[sqrdists > radius ** 2] = N
+    # 对每个查询点的邻近点按索引排序（因为前面有 N，所以小的才是有效点）
+    # 然后只保留前 nsample 个点
+    group_idx = group_idx.sort(dim=-1)[0][:, :, :nsample]
+    # 如果某个查询点附近的点太少，有些位置被标记为 N（无效）。
+    # 我们就用该查询点最近的那个点（第一个点）去填充这些空缺。
+    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 # （batch,npoint,nsample)
+```
+