2、PF-Net 点云补全
PF-Net论文链接：PF-Net
PF-Net （Point Fractal Network for 3D Point Cloud Completion）是一种专门为三维点云补全设计的深度学习模型。
点云补全实际上和图片补全是一个逻辑，都是采用GAN模型的思想来进行补全，在图片补全中，将部分像素点删除并且标记，然后卷积特征提取预测、判别器判别，来训练模型，生成的像素点与原来像素点比较完成模型的训练。而PF-Net就是采用GAN的思想在3D点云上的应用。
模型架构
**Multi-Resolution Encoder(MRE)：**编码器，PF-Net在特征提取方面，在PointNet的基础上进行了改进，在不同层面进行采样，但是与PointNet++的多层面采样不一样，PF-Net没有像PointNet++一样提取某个点周围的点的特征，进行分组提取特征，而是采用最远距离采样，选取不同个个数的采样点，从细节到轮廓多层次采样,其次在进行卷积时，对于PointNet只在最后一层进行maxpooling来获得最终特征值，但是PF-Net则在提取的过程中，在卷积提取过程中，对卷积结果进行maxpooling提取特征，最终将多次maxpooling提取到的特征拼接，使特征既有轮廓信息，又有细节信息。
**Point Pyramid Deconder(PPD)：**解码器，在进行预测时，先是预测出一个轮廓，再将轮廓信息加入到下面，逐级预测更多的细节，慢慢加入特征，使预测更急准确。
**Discriminator：**判別器，与GAN中的判别器逻辑一模一样，有两组输入，对比是否预测准确，实际上就是做了一个二分类，输出每个点结果为True或False，表示预测是否正确。
对于训练参数的更新，主要CD和判别器的Loss，CD计算的是每个预测点和距离他最近的正确点的距离，同时正确的点也会和预测点计算CD值，获得Loss值，更新参数。
模型架构图
数据准备
for i, data in enumerate(dataloader, 0):
real_point, target = data # 从dataloader中获取真实的点云数据和对应的目标标签
batch_size = real_point.size()[0] # 获取批量大小
real_center = torch.FloatTensor(batch_size, 1, opt.crop_point_num, 3) # 初始化用于存储被裁剪的点
print(real_center.shape) # 输出 real_center 的形状
input_cropped1 = torch.FloatTensor(batch_size, opt.pnum, 3) # 初始化裁剪后的输入点云数据
print(input_cropped1.shape) # 输出 input_cropped1 的形状 ([4, 2048, 3])
# 将 real_point 复制到 input_cropped1 中
input_cropped1 = input_cropped1.data.copy_(real_point)
print(input_cropped1.shape) # 输出复制后的 input_cropped1 的形状 ([4, 2048, 3])
# 添加一个维度到 real_point，方便之后的操作
real_point = torch.unsqueeze(real_point, 1)
print(real_point.shape) # 输出添加维度后的形状 ([4, 1, 2048, 3])
# 添加一个维度到 input_cropped1，方便之后的操作
input_cropped1 = torch.unsqueeze(input_cropped1,1)
print(input_cropped1.shape) # 输出添加维度后的 input_cropped1 的形状
p_origin = [0,0,0] # 设置原点位置
# 根据不同的裁剪方法裁剪点云
if opt.cropmethod == 'random_center':
# 设置随机视角的选项
choice = [torch.Tensor([1,0,0]), torch.Tensor([0,0,1]), torch.Tensor([1,0,1]), torch.Tensor([-1,0,0]), torch.Tensor([-1,1,0])]
for m in range(batch_size):
# 从选择中随机选取一个视角
index = random.sample(choice,1)
distance_list = []
p_center = index[0] # 选取的视角作为中心点
for n in range(opt.pnum):
# 计算每个点与中心点之间的距离
distance_list.append(distance_squre(real_point[m,0,n], p_center))
# 将距离排序，得到每个点的索引和值
distance_order = sorted(enumerate(distance_list), key=lambda x: x[1])
print(distance_order) # 输出距离排序
# 裁剪掉距离中心点最近的 opt.crop_point_num 个点
for sp in range(opt.crop_point_num):
input_cropped1.data[m, 0, distance_order[sp][0]] = torch.FloatTensor([0,0,0]) # 用 [0,0,0] 替换裁剪掉的点
real_center.data[m, 0, sp] = real_point[m, 0, distance_order[sp][0]] # 保存被裁剪的点到 real_center 中
# 重新调整标签的大小并赋值
label.resize_([batch_size, 1]).fill_(real_label)
print(label.shape) # 输出标签的形状
# 将数据移到 GPU 设备上
real_point = real_point.to(device)
real_center = real_center.to(device)
input_cropped1 = input_cropped1.to(device)
label = label.to(device)
############################
# (1) 准备数据
############################
# 将 real_center 设置为可求导变量
real_center = Variable(real_center, requires_grad=True)
real_center = torch.squeeze(real_center, 1) # 去除多余的维度
# 通过最远点采样算法从 real_center 中选取64个关键点
real_center_key1_idx = utils.farthest_point_sample(real_center, 64, RAN=False)
real_center_key1 = utils.index_points(real_center, real_center_key1_idx)
real_center_key1 = Variable(real_center_key1, requires_grad=True) # 设置为可求导变量
print(real_center_key1.shape) # 输出关键点的形状
# 通过随机最远点采样算法从 real_center 中选取128个关键点
real_center_key2_idx = utils.farthest_point_sample(real_center, 128, RAN=True)
real_center_key2 = utils.index_points(real_center, real_center_key2_idx)
real_center_key2 = Variable(real_center_key2, requires_grad=True) # 设置为可求导变量
print(real_center_key2.shape) # 输出关键点的形状
# 去除 input_cropped1 的多余维度
input_cropped1 = torch.squeeze(input_cropped1, 1)
print(input_cropped1.shape) # 输出去除维度后的形状
# 从 input_cropped1 中采样不同数量的点
input_cropped2_idx = utils.farthest_point_sample(input_cropped1, opt.point_scales_list[1], RAN=True)
input_cropped2 = utils.index_points(input_cropped1, input_cropped2_idx)
input_cropped3_idx = utils.farthest_point_sample(input_cropped1, opt.point_scales_list[2], RAN=False)
input_cropped3 = utils.index_points(input_cropped1, input_cropped3_idx)
# 将裁剪后的点云设置为可求导变量
input_cropped1 = Variable(input_cropped1, requires_grad=True)
print(input_cropped1.shape) # 输出裁剪后的 input_cropped1 形状
input_cropped2 = Variable(input_cropped2, requires_grad=True)
print(input_cropped2.shape) # 输出裁剪后的 input_cropped2 形状
input_cropped3 = Variable(input_cropped3, requires_grad=True)
print(input_cropped3.shape) # 输出裁剪后的 input_cropped3 形状
# 将裁剪后的数据移到 GPU 设备上
input_cropped2 = input_cropped2.to(device)
input_cropped3 = input_cropped3.to(device)
# 将不同尺度的裁剪数据保存到列表中
input_cropped = [input_cropped1, input_cropped2, input_cropped3]
Multi-Resolution Encoder(MRE)
**Multi-Resolution Encoder(MRE)：**编码器，PF-Net在特征提取方面，在PointNet的基础上进行了改进，在不同层面进行采样，但是与PointNet++的多层面采样不一样，PF-Net没有像PointNet++一样提取某个点周围的点的特征，进行分组提取特征，而是采用最远距离采样，选取不同个个数的采样点，从细节到轮廓多层次采样,其次在进行卷积时，对于PointNet只在最后一层进行maxpooling来获得最终特征值，但是PF-Net则在提取的过程中，在卷积提取过程中，对卷积结果进行maxpooling提取特征，最终将多次maxpooling提取到的特征拼接，使特征既有轮廓信息，又有细节信息。
class Latentfeature(nn.Module):
# ..
def forward(self, x):
outs = [] # 用于存储各层的输出结果
print(x[0].shape) # 打印输入数据第一个尺度的形状
# 对第一个尺度的数据进行卷积处理，并将结果存入 outs 列表
for i in range(self.each_scales_size):
outs.append(self.Convlayers1[i](x[0]))
# 对第二个尺度的数据进行卷积处理，并将结果存入 outs 列表
for j in range(self.each_scales_size):
outs.append(self.Convlayers2[j](x[1]))
# 对第三个尺度的数据进行卷积处理，并将结果存入 outs 列表
for k in range(self.each_scales_size):
outs.append(self.Convlayers3[k](x[2]))
# 将不同尺度的卷积输出在维度2上拼接起来，得到拼接后的特征
latentfeature = torch.cat(outs, 2)
# 将拼接后的特征进行转置操作，交换维度1和维度2
latentfeature = latentfeature.transpose(1, 2)
# 通过卷积层和批归一化层，对拼接特征进行卷积和激活处理
latentfeature = F.relu(self.bn1(self.conv1(latentfeature)))
# 压缩特征图的一个维度，将其从 (batch_size, 1, ...) 变为 (batch_size, ...)
latentfeature = torch.squeeze(latentfeature, 1)
return latentfeature # 返回最终的特征图
# 来源 self.Convlayers1[i](x[0])
class Convlayer(nn.Module):
# ..
def forward(self, x):
x = torch.unsqueeze(x, 1) # 在输入的维度上增加一个维度，转换为 (batch_size, 1, point_num, 3)
# 通过第一层卷积+批归一化+ReLU激活
x = F.relu(self.bn1(self.conv1(x)))
# 通过第二层卷积+批归一化+ReLU激活
x = F.relu(self.bn2(self.conv2(x)))
# 通过第三层卷积，提取128通道的特征
x_128 = F.relu(self.bn3(self.conv3(x)))
# 通过第四层卷积，提取256通道的特征
x_256 = F.relu(self.bn4(self.conv4(x_128)))
# 通过第五层卷积，提取512通道的特征
x_512 = F.relu(self.bn5(self.conv5(x_256)))
# 通过第六层卷积，提取1024通道的特征
x_1024 = F.relu(self.bn6(self.conv6(x_512)))
# 使用最大池化层对 x_128 进行池化，去除掉特征图的某一维度
x_128 = torch.squeeze(self.maxpool(x_128), 2)
# 对其他特征图 x_256, x_512, x_1024 同样进行池化操作
x_256 = torch.squeeze(self.maxpool(x_256), 2)
x_512 = torch.squeeze(self.maxpool(x_512), 2)
x_1024 = torch.squeeze(self.maxpool(x_1024), 2)
# 将各层的特征图按通道拼接
L = [x_1024, x_512, x_256, x_128]
x = torch.cat(L, 1) # 将四层特征拼接在一起
return x # 返回最终特征
这样的过程会进行三次，对于不同采样点个数都进行处理
Point Pyramid Deconder(PPD)
解码器，在进行预测时，先是预测出一个轮廓，再将轮廓信息加入到下面，逐级预测更多的细节，慢慢加入特征，使预测更急准确。
class _netG(nn.Module):
def forward(self, x):
# 获取输入特征
x = self.latentfeature(x)
# 通过全连接层并激活处理，逐步缩小特征维度
x_1 = F.relu(self.fc1(x)) # 1024维度的特征处理
x_2 = F.relu(self.fc2(x_1)) # 512维度的特征处理
x_3 = F.relu(self.fc3(x_2)) # 256维度的特征处理
# 第一阶段输出特征并 reshape 成 64x3 的中心点特征
pc1_feat = self.fc3_1(x_3)
pc1_xyz = pc1_feat.reshape(-1, 64, 3) # 中心点1，形状为64x3
# 第二阶段输出特征，并 reshape 为 128x64 的特征
pc2_feat = F.relu(self.fc2_1(x_2))
pc2_feat = pc2_feat.reshape(-1, 128, 64) # 中心点2的特征
pc2_xyz = self.conv2_1(pc2_feat) # 处理中心点2
# 第三阶段输出特征，并经过多个卷积层处理，最终 reshape 为 512x128 的特征
pc3_feat = F.relu(self.fc1_1(x_1))
pc3_feat = pc3_feat.reshape(-1, 512, 128)
pc3_feat = F.relu(self.conv1_1(pc3_feat))
pc3_feat = F.relu(self.conv1_2(pc3_feat))
pc3_xyz = self.conv1_3(pc3_feat) # 细化点云的特征
# 扩展 pc1_xyz 的维度以便与 pc2_xyz 相加
pc1_xyz_expand = torch.unsqueeze(pc1_xyz, 2)
# 转置并 reshape pc2_xyz，然后与扩展后的 pc1_xyz 相加
pc2_xyz = pc2_xyz.transpose(1, 2)
pc2_xyz = pc2_xyz.reshape(-1, 64, 2, 3)
pc2_xyz = pc1_xyz_expand + pc2_xyz
pc2_xyz = pc2_xyz.reshape(-1, 128, 3) # 中心点2的坐标
# 扩展 pc2_xyz 的维度以便与 pc3_xyz 相加
pc2_xyz_expand = torch.unsqueeze(pc2_xyz, 2)
# 转置并 reshape pc3_xyz，然后与扩展后的 pc2_xyz 相加
pc3_xyz = pc3_xyz.transpose(1, 2)
pc3_xyz = pc3_xyz.reshape(-1, 128, int(self.crop_point_num / 128), 3)
pc3_xyz = pc2_xyz_expand + pc3_xyz
pc3_xyz = pc3_xyz.reshape(-1, self.crop_point_num, 3) # 细化后的点云坐标
# 返回第一阶段、第二阶段和最终阶段的点云坐标
return pc1_xyz, pc2_xyz, pc3_xyz # 返回中心点1、中心点2和细化点
Discriminator
判別器，与GAN中的判别器逻辑一模一样，有两组输入，对比是否预测准确，实际上就是做了一个二分类，输出每个点结果为True或False，表示预测是否正确。
class _netlocalD(nn.Module)：
# ...
def forward(self, x):
# 输入经过第一个卷积层和批归一化后激活
x = F.relu(self.bn1(self.conv1(x)))
# 输入经过第二个卷积层和批归一化后激活，得到 64 维的特征
x_64 = F.relu(self.bn2(self.conv2(x)))
# 输入经过第三个卷积层和批归一化后激活，得到 128 维的特征
x_128 = F.relu(self.bn3(self.conv3(x_64)))
# 输入经过第四个卷积层和批归一化后激活，得到 256 维的特征
x_256 = F.relu(self.bn4(self.conv4(x_128)))
# 对 64 维特征进行最大池化并 squeeze 以减少维度
x_64 = torch.squeeze(self.maxpool(x_64))
# 对 128 维特征进行最大池化并 squeeze 以减少维度
x_128 = torch.squeeze(self.maxpool(x_128))
# 对 256 维特征进行最大池化并 squeeze 以减少维度
x_256 = torch.squeeze(self.maxpool(x_256))
# 将 64、128 和 256 维的特征拼接在一起
Layers = [x_256, x_128, x_64]
x = torch.cat(Layers, 1)
# 全连接层逐层缩小特征维度并进行激活
x = F.relu(self.bn_1(self.fc1(x)))
x = F.relu(self.bn_2(self.fc2(x)))
x = F.relu(self.bn_3(self.fc3(x)))
# 最后一层全连接层输出结果
x = self.fc4(x)
return x
