本文介绍基于Paddle2.0实现Kd-Networks对点云分类处理。Kd-Networks引入Kd-Tree结构，将非结构化点云转为结构化数据，用1*1卷积近似KD算子。使用ShapeNet的.h5数据集，经数据处理、网络定义等步骤，训练20轮后，训练集准确率0.978，测试集0.9375，展示了其处理点云分类的效果。
☞☞☞AI 智能聊天, 问答助手, AI 智能搜索, 免费无限量使用 DeepSeek R1 模型☜☜☜
Kd-Networks于2017发表于ICCV上。创新性地引入了Kd-Tree结构用于处理点云。
论文：Escape from Cells: Deep Kd-Networks for the Recognition of 3D Point Cloud Models
训练二十轮后的准确率：
| 训练集上 | 测试集上 | |
|---|---|---|
| Accuracy | 0.978 | 0.9375 |
本次用到的数据集是ShapeNet，储存格式是.h5文件。
.h5储存的key值分别为：
1、data：这一份数据中所有点的xyz坐标，
2、label：这一份数据所属类别，如airplane等，
3、pid：这一份数据中所有点所属的类型，如这一份数据属airplane类，则它包含的所有点的类型有机翼、机身等类型。
一、Kd-Networks最大的创新点在于引入了Kd-Tree这一结构，Kd-Tree将非结构化点云变成结构化数据，构建了处理非结构化点云的特征工程。
二、该项目利用1*1卷积近似实现KD算子的功能，因此在构建Kd-Networks网络时，构建的是一个类Kd-Tree的网络，也就是说Kd-Networks将数据处理中Kd-Tree化的过程复刻到网络上（例如在index_select处可以看到，index_select复刻的是数据处理时Kd-Tree化中二叉时切割的维度），网络因此类Kd-Tree。
!unzip data/data67117/shapenet_part_seg_hdf5_data.zip!mv hdf5_data dataset
import osimport numpy as npimport randomimport h5pyimport paddleimport paddle.nn as nnimport paddle.nn.functional as Ffrom tools.build_KDTree import build_KDTree
train_list = ['ply_data_train0.h5', 'ply_data_train1.h5', 'ply_data_train2.h5', 'ply_data_train3.h5', 'ply_data_train4.h5', 'ply_data_train5.h5'] test_list = ['ply_data_test0.h5', 'ply_data_test1.h5'] val_list = ['ply_data_val0.h5']
注：在数据读取这里，可以借助scipy.spatial中的cKDTree很快地生成kdTree。
def pointDataLoader(mode='train'):
path = './dataset/'
BATCHSIZE = 64
MAX_POINT = 1024
LEVELS = (np.log(MAX_POINT) / np.log(2)).astype(int)
datas = []
split_dims_v = []
points_v = []
labels = [] if mode == 'train': for file_list in train_list:
f = h5py.File(os.path.join(path, file_list), 'r')
datas.extend(f['data'][:, :MAX_POINT, :])
labels.extend(f['label'])
f.close() elif mode == 'test': for file_list in test_list:
f = h5py.File(os.path.join(path, file_list), 'r')
datas.extend(f['data'][:, :MAX_POINT, :])
labels.extend(f['label'])
f.close() else: for file_list in val_list:
f = h5py.File(os.path.join(path, file_list), 'r')
datas.extend(f['data'][:, :MAX_POINT, :])
labels.extend(f['label'])
f.close()
datas = np.array(datas) for i in range(len(datas)):
split_dim, tree = build_KDTree(datas[i], depth=LEVELS)
split_dim_v = [np.array(item).astype(np.int64) for item in split_dim]
split_dims_v.append(split_dim_v)
points_v.append(tree[-1].transpose(0, 2, 1))
split_dims_v = np.array(split_dims_v)
points_v = np.array(points_v)
labels = np.array(labels) print('==========load over==========')
index_list = list(range(len(datas))) def pointDataGenerator():
if mode == 'train':
random.shuffle(index_list)
split_dims_v_list = []
points_v_list = []
labels_list = [] for i in index_list:
split_dims_v_list.append(split_dims_v[i])
points_v_list.append(points_v[i].astype('float32'))
labels_list.append(labels[i].astype('int64')) if len(labels_list) == BATCHSIZE: yield np.array(split_dims_v_list), np.array(points_v_list), np.array(labels_list)
split_dims_v_list = []
points_v_list = []
labels_list = [] if len(labels_list) > 0: yield np.array(split_dims_v_list), np.array(points_v_list), np.array(labels_list) return pointDataGeneratorclass KDNet(nn.Layer):
def __init__(self, k=16):
super(KDNet, self).__init__()
self.conv1 = nn.Conv1D(3, 32*3, 1, 1)
self.conv2 = nn.Conv1D(32, 64*3, 1, 1)
self.conv3 = nn.Conv1D(64, 64*3, 1, 1)
self.conv4 = nn.Conv1D(64, 128*3, 1, 1)
self.conv5 = nn.Conv1D(128, 128*3, 1, 1)
self.conv6 = nn.Conv1D(128, 256*3, 1, 1)
self.conv7 = nn.Conv1D(256, 256*3, 1, 1)
self.conv8 = nn.Conv1D(256, 512*3, 1, 1)
self.conv9 = nn.Conv1D(512, 512*3, 1, 1)
self.conv10 = nn.Conv1D(512, 128*3, 1, 1)
self.fc = nn.Linear(128, k) def forward(self, x, split_dims_v):
def kdconv(x, dim, featdim, select, conv):
x = F.relu(conv(x))
x = paddle.reshape(x, (-1, featdim, 3, dim))
x = paddle.reshape(x, (-1, featdim, 3 * dim))
select = paddle.to_tensor(select) + (paddle.arange(0, dim) * 3)
x = paddle.index_select(x, axis=2, index=select)
x = paddle.reshape(x, (-1, featdim, int(dim/2), 2))
x = paddle.max(x, axis=-1) return x
x = kdconv(x, 1024, 32, split_dims_v[0], self.conv1)
x = kdconv(x, 512, 64, split_dims_v[1], self.conv2)
x = kdconv(x, 256, 64, split_dims_v[2], self.conv3)
x = kdconv(x, 128, 128, split_dims_v[3], self.conv4)
x = kdconv(x, 64, 128, split_dims_v[4], self.conv5)
x = kdconv(x, 32, 256, split_dims_v[5], self.conv6)
x = kdconv(x, 16, 256, split_dims_v[6], self.conv7)
x = kdconv(x, 8, 512, split_dims_v[7], self.conv8)
x = kdconv(x, 4, 512, split_dims_v[8], self.conv9)
x = kdconv(x, 2, 128, split_dims_v[9], self.conv10)
x = paddle.reshape(x, (-1, 128))
x = F.log_softmax(self.fc(x)) return x 注：由于训练数据预处理比较慢，所以先创建训练数据读取器（创建同时会对数据进行预处理），这样在训练时候直接导入就显得训练过程快很多（实际上并没有节省时间，只不过是为了调试方便和读者尝试，把训练数据读取器单独拿出来创建）。
train_loader = pointDataLoader(mode='train')
==========load over==========
def train():
model = KDNet()
model.train()
optim = paddle.optimizer.Adam(parameters=model.parameters(), weight_decay=0.001)
epoch_num = 40
for epoch in range(epoch_num): for batch_id, data in enumerate(train_loader()):
split_dims_v = data[0]
points_v = data[1]
labels = data[2]
inputs = paddle.to_tensor(points_v)
labels = paddle.to_tensor(labels)
predict = [] for i in range(split_dims_v.shape[0]):
predict.extend(model(inputs[i], split_dims_v[i]))
predicts = paddle.stack(predict)
loss = F.nll_loss(predicts, labels)
acc = paddle.metric.accuracy(predicts, labels)
if batch_id % 10 == 0:
print("epoch: {}, batch_id: {}, loss is: {}, accuracy is: {}".format(epoch, batch_id, loss.numpy(), acc.numpy()))
loss.backward()
optim.step()
optim.clear_grad() if epoch % 2 == 0:
paddle.save(model.state_dict(), './model/KDNet.pdparams')
paddle.save(optim.state_dict(), './model/KDNet.pdopt')if __name__ == '__main__':
train()def evaluation():
test_loader = pointDataLoader(mode='test')
model = KDNet()
model_state_dict = paddle.load('./model/KDNet.pdparams')
model.load_dict(model_state_dict) for batch_id, data in enumerate(test_loader()):
split_dims_v = data[0]
points_v = data[1]
labels = data[2]
inputs = paddle.to_tensor(points_v)
labels = paddle.to_tensor(labels)
predict = [] for i in range(split_dims_v.shape[0]):
predict.extend(model(inputs[i], split_dims_v[i]))
predicts = paddle.stack(predict)
acc = paddle.metric.accuracy(predicts, labels) print("eval accuracy is: {}".format(acc.numpy())) break;if __name__ == '__main__':
evaluation()==========load over========== eval accuracy is: [0.9375]
以上就是点云处理：基于Paddle2.0实现Kd-Networks对点云进行分类处理的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
310
收藏
