代码学习_KPConv_kernels.kernel_points

本文链接：https://blog.csdn.net/weixin_44109545/article/details/115600332

本文记录了作者在学习代码过程中对KPConv的kernel点优化和加载的探索。通过`kernel_point_optimization_debug()`函数，随机生成三维点，并设定不同方式固定的kernel点。`load_kernels()`用于根据优化过程的梯度信息更新kernel点，最终经过噪声、半径缩放和旋转处理，以期达到论文中类似的效果。

摘要由CSDN通过智能技术生成

代码学习_KPConv_kernels.kernel_points

kernel_point_optimization_debug()
load_kernels()

文章只是个人学习过程中的记录，因水平极其有限，仅供参考，欢迎一起交流

kernel_point_optimization_debug()

    """
        Creation of kernel point via optimization of potentials.
    Args:
        radius: Radius of the kernels, 1
        num_kpoints: points composing kernels, 15
        num_kernels: number of wanted kernels, 100
        dimension: dimension of the space
        fixed: fix position of certain kernel points ('none', 'center' or 'verticals')
        ratio: ratio of the radius where you want the kernels points to be placed
    Returns:
        kernel_points [num_kernels, num_kpoints, dimension]
        saved_gradient_norms [10000, num_kernels] / [step+1, num_kernels]
    """

radius0 = 1
diameter0 = 2
# Random kernel points
kernel_points = np.random.rand(num_kernels * num_kpoints - 1, dimension) * diameter0 - radius0  # [-1, 1)
while (kernel_points.shape[0] < num_kernels * num_kpoints):
    new_points = np.random.rand(num_kernels * num_kpoints - 1, dimension) * diameter0 - radius0
    kernel_points = np.vstack((kernel_points, new_points))
    d2 = np.sum(np.power(kernel_points, 2), axis=1)
    kernel_points = kernel_points[d2 < 0.5 * radius0 * radius0, :]

kernel_points = kernel_points[:num_kernels * num_kpoints, :].reshape((num_kernels, num_kpoints, -1))

以(0,0)为球心，根号0.5半径内随机产生 num_kernels * num_kpoints 个三维点
kernel_points：[num_kernels, num_kpoints, dimension=3]

# Optionnal fixing
if fixed == 'center':
    kernel_points[:, 0, :] *= 0
if fixed == 'verticals':
    kernel_points[:, :3, :] *= 0
    kernel_points[:, 1, -1] += 2 * radius0 / 3
    kernel_points[:, 2, -1] -= 2 * radius0 / 3

固定方式
- center:
  - num_kpoints=0对应的 num_kernels 个点，其坐标(0, 0, 0)
- vertical:
  - num_kpoints=0对应的 num_kernels 个点，其坐标(0, 0 ,0)
  - num_kpoints=1对应的 num_kernels 个点，其坐标(0, 0 ,2/3)
  - num_kpoints=2对应的 num_kernels 个点，其坐标(0, 0 ,-2/3)

#####################
# Kernel optimization
#####################
saved_gradient_norms = np.zeros((10000, num_kernels))
old_gradient_norms = np.zeros((num_kernels, num_kpoints))
step = -1
while step < 10000:

    # Increment
    step += 1

    # Compute gradients
    # *****************

    # Derivative of the sum of potentials of all points
    A = np.expand_dims(kernel_points, axis=2)  # (num_kernels, num_kpoints, 1, dimension)
    B = np.expand_dims(kernel_points, axis=1)  # (num_kernels, 1, num_kpoints, dimension)
    interd2 = np.sum(np.power(A - B, 2), axis=-1)  # (num_kernels, num_kpoints, num_kpoints)
    inter_grads = (A - B) / (np.power(np.expand_dims(interd2, -1), 3/2) + 1e-6)
    inter_grads = np.sum(inter_grads, axis=1)  # (num_kernels, num_kpoints, dimension)

    # Derivative of the radius potential
    circle_grads = 10*kernel_points  # (num_kernels, num_kpoints, dimension)

    # All gradients
    gradients = inter_grads + circle_grads  # (num_kernels, num_kpoints, dimension)

    if fixed == 'verticals':
        gradients[:, 1:3, :-1] = 0

(num_kernels, num_kpoints, dimension)的理解：
- 每个 num_kpoints=100 对应 num_kernels=15 个点，坐标(x,y,z)
- 或者每个 num_kernels=15 对应 num_kpoints=100 个点，坐标(x,y,z)
interd2: 表示距离矩阵
inter_grads: 可能表示近似的微分（待学习）
- Example

kernel_points = torch.randint(3, (4,2,3))
A = kernel_points.unsqueeze(2)  # (num_kernels, num_kpoints, 1, dimension)
B = kernel_points.unsqueeze(1)  # (num_kernels, 1, num_kpoints, dimension)
interd2 = torch.sum(torch.pow((A - B), 2), axis=-1)
print(A)
print(B)
print(interd2)

>>>
tensor([[[[1, 0, 0]],						
         [[1, 1, 0]],						
         [[1, 1, 0]],
         [[0, 0, 0]]]