SpiderCNN: Deep Learning on Point Sets with Parameterized Convolutional Filters

Yifan Xu, Tianqi Fan, Mingye Xu, Long Zeng, Yu Qiao

Introduction

The family of filters is designed to be expressive while still being feasible to optimize. We combine simple step functions, which are used to capture the coarse geometry described by local geodesic distance, with order-3 Taylor expansions, which ensure the filters are complex enough to capture intricate local geometric variations. Experiments in Section 4 show that SpiderCNN with a relatively simple network architecture achieves the state-of-the-art performance for classification on ModelNet40 , and shows competitive performance for segmentation on ShapeNet-Part .

Related Work

First we discuss deep neural network based approaches that target point clouds data. Second, we give a partial overview of geometric deep learning.

Point clouds as input: PointNet is a pioneering work in using deep networks to directly process point sets. A spatial encoding of each point is learned through a shared MLP, and then all individual point features aggregate to a global signature through max-pooling, which is a symmetric operation that doesn’t depend on the order of input point sequence.

While PointNet works well to extract global features, its design limits its efficacy at encoding local structures. Various studies addressing this issue propose different grouping strategies of local features in order to mimic the hierarchical learning procedure at the core of classical convolutional neural networks. PointNet++ uses iterative farthest point sampling to select centroids of local regions, and PointNet to learn the local pattern. Kd-Network subdivides the space using K-d trees, whose hierarchical structure serves as the instruction to aggregate local features at different scales. In SpiderCNN, no additional choice for grouping or sampling is needed, for our filters handle the issue automatically.

The idea of using permutation-invariant functions for learning on unordered sets is further explored by DeepSet. We note that the output of SpiderCNN does not depend on the input order by design.

Voxels as input: VoxNet and Voxception-ResNet apply 3D convolution to a voxelization of point clouds. However, there is a high computational and memory cost associated with 3D convolutions. A variety of work has aimed at exploiting the sparsity of voxelized point clouds to improve the computational and memory efficiency. OctNet modified and implemented convolution operations to suit a hybrid grid-octree data structure. Vote3Deep uses a feature-centric voting scheme so that the computational cost is proportional to the number of points with non-zero features. Sparse Submanifold CNN computes the convolution only at activated points whose number does not increase when the convolution layers are stacked. In comparison, SpiderCNN can use point clouds as input directly and can handle very sparse input.

Convolution on non-Euclidean domain: There are two main philosophically different approaches to define convolutions for non-Euclidean domains: one is spatial and the other is spectral. The recent work ECC defines convolution-like operations on graphs where filter weights are conditioned on edge labels. Viewing point clouds as a graph, and taking the filters to be MLPs, SpiderCNN and ECC result in similar convolution. However, we show that our proposed family of filters outperforms MLPs.

SpiderConv

which is the discretization of the following integration

A natural choice is to take $g_{w}$ to be a multilayer perceptron (MLP) network, because theoretically an MLP with one hidden layer can approximate an arbitrary continuous function . However, in practice we find that MLPs do not work well. One possible reason is that MLP fails to account for the geometric prior of 3D point clouds. Another possible reason is that to ensure sufficient expressiveness the number of parameters in a MLP needs to be sufficiently large, which makes the optimization problem difficult.

To address the above issues, we propose the following family of filters $\{g_{w}\}$ :

The first component $g^{Step}_{w^{S}}$ is a step function in the radius variable of the local polar coordinates around a point. It encodes the local geodesic information, which is a critical quantity to describe the coarse local shape. Moreover, step functions are relatively easy to optimize using SGD.

The order-3 Taylor term $g^{Taylor}_{w^{T}}$ further enriches the complexity of the filters, complementary to $g^{Step}_{w^{S}}$ since it also captures the variations of the angular component. Let us be more precise about the reason for choosing Taylor expansions here from the perspective of interpolation. We can think of the classical 2D convolutional filters as a family of functions interpolating given values at 9 points $\{(i,j)\}_{i,j\in\{-1,0,1\}}$ , and the $9$ values serve as the parametrization of such a family. Analogously, in 3D consider the vertices of a cube $\{(i,j,k)\}_{i,j,k=0,1}$ , assume that at the vertex $(i,j,k)$ the value $a_{i,j,k}$ is assigned. The trilinear interpolation algorithm gives us a function of the form

where $w^{T}_{i}$ ’s are linear functions in $c_{ijk}$ . Therefore $f_{w^{T}}$ is a special form of $g^{Taylor}_{w^{T}}$ , and by varying $w^{T}$ , the family $\{g^{Taylor}_{w^{T}}\}$ can interpolate arbitrary values at the vertexes of a cube and capture rich spatial information.

3 Implementation

The following approximations are used based on the uniform sampling process constructing the point clouds:

K-nearest neighbors are used to measure the locality instead of the radius, so the summation in Equation 4 is over the K-nearest neighbors of $p$ .

The step function $g^{Step}_{w^{T}}$ is approximated by a permutation. Explicitly, let $X$ be the $1\times K$ matrix indexed by the K-nearest neighbors of $p$ including $p$ , and $X(1,i)$ is a feature at the $i$ -th K-nearest neighbors of $p$ . Then $F\ast g^{Step}_{w^{T}}(p)$ is approximated by $Xw$ , where $w$ is a $K\times 1$ matrix with $w(i,1)$ corresponds to $w^{T}_{i}$ in Equation 6.

Later in the article, we omit the parameters $w$ , $w^{S}$ and $w^{T}$ , and just write $g=g^{Step}\cdot g^{Taylor}$ to simplify our notations.

Experiments

We analyze and evaluate SpiderCNN on 3D point clouds classification and segmentation. We empirically examine the key hyper-parameters of a 3-layer SpiderCNN, and compare our models with the state-of-the-art methods.

Implementation Details: All models are prototyped with Tensorflow 1.3 on 1080Ti GPU and trained using the Adam optimizer with a learning rate of $10^{-3}$ . A dropout rate of 0.5 is used with the the fully connected layers. Batch normalization is used at the end of each SpiderConv with decay set to 0.5. On a GTX 1080Ti, the forward-pass time of a SpiderConv layer (batch size 8) with in-channel 64 and out-channel 64 is 7.50 ms. For the 4-layer SpiderCNN (batch size 8), the total forward-pass time is 71.68 ms.

ModelNet40 contains 12,311 CAD models which belong to 40 different categories with 9,843 used for training and 2,468 for testing. We use the source code for PointNet to sample 1,024 points uniformly and compute the normal vectors from the mesh models. The same data augmentation strategy as is applied: the point cloud is randomly rotated along the up-axis and the position of each point is jittered by a Gaussian noise with zero mean and 0.02 standard deviation. The batch size is 32 for all the experiments in Section 4.1. We use the $(x,y,z)$ -coordinates and normal vectors of the 1,024 points as the input for SpiderCNN for the experiments on ModelNet40 unless otherwise specified.

3-layer SpiderCNN: Figure 3 illustrates a SpiderCNN with 3 layers of SpiderConvs each with 3 Taylor terms, and the respective out-channels for each layer being 32, 64, 128. See Section 3.3 for the definition of a SpiderConv with $c_{1}$ in-channels, $c_{2}$ out-channels and $b$ Taylor terms. ReLU activation function is used here. The output features of the three SpiderConvs are concatenated in the end. Top- $k$ pooling among all the points is used to extract global features.

Two important hyperparameters in SpiderCNN are studied: the number of nearest neighbors $K$ chosen in SpiderConv, and the number of pooled features $k$ after the concatenation. The results are summarized in Figure 4. The number of nearest-neighbors $K$ is analogous to size of the filter in the usual convolution. We see that 20 is the optimal choice among 12, 16, 20, and 24-nearest neighbors. In Figure 5 we provide visualization for top-2 pooling. The points that contribute to the top-2 pooling features are plotted. We see that similar to PointNet, Spider CNN picks up representative critical points.

SpiderCNN + PointNet: We train a 3-layer SpiderCNN (top-2 pooling and 20-nearest neighbors) and PointNet with only $(x,y,z)$ -coordinates as input to predict the classical robust local geometric descriptor FPFH on point clouds in ModelNet40. The training loss of SpiderCNN is only $\frac{1}{4}$ that of PointNet’s. As a result, we believe that a 3-layer SpiderCNN and PointNet are complementary to each other, for SpiderCNN is good at learning local geometric features and PointNet is good at capturing global features. By concatenating the 128 dimensional features from PointNet with the 128 dimensional features from SpiderCNN, we improve the classification accuracy to $92.2\%$ .

4-layer SpiderCNN: Experiments show that 1-layer SpiderCNN with a SpiderConv of 32 channels can achieve classification accuracy $85.5\%$ , and the performance of SpiderCNN improves with the increasing number of layers of SpiderConv. A 4-layer SpiderCNN consists of SpiderConv with out-channels 32, 64, 128, and 258. Feature concatenation, 20-nearest neighbors and top-2 pooling are used. To prevent overfitting, while training we apply the data augmentation method DP (random input dropout) introduced in . Table 1 shows a comparison between SpiderCNN and other models. The 4-layer SpiderCNN achieves accuracy of $92.4\%$ which improves over the best reported result of models with input 1024 points and normals. For 5 runs, the mean accuracy of a 4-layer SpiderCNN is $92.0\%$ .

Ablative Study: Compared to max-pooling, top-2 pooling enables the model to learn richer geometric information. For example, in Figure 6, we see top-2 pooling preserves more points where the curvature is non-zero. Using max-pooling, the classification accuracy is $92.0\%$ for a 4-layer SpiderCNN, and is $90.4\%$ for a 3-layer SpiderCNN.

In comparison, using top-2 pooling, the accuracy is $92.4\%$ for a 4-layer SpiderCNN, and is $91.5\%$ for a 3-layer SpiderCNN.

MLP filters do not perform as well in our setting. The accuracy of a 3-layer SpiderCNN is $71.3\%$ with $g_{w}=\text{MLP}(16,1)$ , and is $72.8\%$ with $g_{w}=\text{MLP}(16,32,1)$ .

Without normals, the accuracy of a 4-layer SpiderCNN using only the 1,024 points is $90.5\%$ . Using normals extracted from the 1,024 input points via orthogonal distance regression, the accuracy of a 4-layer SpiderCNN is $91.8\%$ .

2 Classification on SHREC15

SHREC15 is a dataset for non-rigid 3D shape retrieval. It consists of 1,200 watertight triangle meshes divided in 50 categories. On average 10,000 vertices are stored in one mesh model. Comparing to ModelNet40, SHREC15 contains more complicated local geometry and non-rigid deformation of one object. See Figure 7 for a comparison. 1,192 meshes are used with 895 for training and 297 for testing.

We compute three intrinsic shape descriptors (Heat Kernel Signature, Wave Kernel Signature and Fast Point Feature Histograms) for deformable shape analysis from the mesh models. 1,024 points are sampled uniformly randomly from the vertices of a mesh model, and the $(x,y,z)$ -coordinates are used as the input for SpiderCNN, PointNet and PointNet++. We use SVM with linear kernel when the inputs are classical shape descriptors. Table 2 summarizes the results. We see that SpiderCNN outperforms the other methods.

3 Segmentation on ShapeNet Parts

ShapeNet Parts consists of 16,880 models from 16 shape categories and 50 different parts in total, with a 14,006 training and 2,874 testing split. Each part is annotated with 2 to 6 parts. The mIoU is used as the evaluation metric, computed by taking the average of all part classes.

A 4-layer SpiderCNN whose architecture is shown in Figure 8 is trained with batch of 16. We use points with their normal vectors as the input and assume that the category labels are known. The results are summarized in Table 3. For 4 runs, the mean of mean IoU of SpiderCNN is $85.24$ . We see that SpiderCNN achieves competitive results despite a relatively simple network architecture.

Analysis

In this section, we conduct additional analysis and evaluations on the robustness of SpiderCNN, and provide visualization for some of the typical learned filters from the first layer of SpiderCNN.

Robustness: We study the effect of missing points on SpiderCNN. Following the setting for experiments in Section 4.1, we train a 4-layer SpiderCNN and PointNet++ with 512, 248, 128, 64 and 32 points and their normals as input. The results are summarized in Figure 10. We see that even with only 32 points, SpiderCNN obtains $87.7\%$ accuracy.

Visualization: In Figure 11, we scatter plot the convolutional filters $g_{w}(x,y,z)$ learned in the first layer of SpiderCNN and the color of a point represents the value of $g_{w}$ at the point.

In Figure 12 we choose a plane passing through the origin, and project the points that lie on one side of the plane of the scatter graph onto the plane. We see some similar patterns that appear in 2D image filters. The visualization gives some hints about the geometric features that the convolutional filters in SpiderCNN learn. For example, the first row in Figure 12 corresponds to 2D image filters that can capture boundary information.

Conclusions

A new convolutional neural network SpiderCNN that can directly process 3D point clouds with parameterized convolutional filters is proposed. More complex network architectures and more applications of SpiderCNN can be explored.

Acknowledgement

This work was supported by Shenzhen Basic Research Program (JCYJ201509251 63005055, JCYJ20170818164704758), National Natural Science Foundation of China (U1613211, 61633021, 61502263) and External Cooperation Program of BIC Chinese Academy of Sciences (172644KYSB20150019). We would like to thank Zhikai Dong for his technical assistance and helpful discussion.

Appendix

In this section, we provide some additional details and experimental results.

Recall that the filter used in SpiderCNN decomposes as

We study empirically the effect of replacing $g^{Taylor}$ with MLP in a 4-layer SpiderCNN for classification on ModelNet40. The results are summarized in Table 4. We see that Taylor outperformances MLP with more parameters.

2 Number of parameters in Taylor

Recall that $g^{Taylor}$ is chosen to be order-3 expansion in SpiderCNN, and the trilinear interpolation gives us a simpler expansion:

We study the effect of replacing $g^{Taylor}$ with $f_{w^{T}}$ , order-2 Taylor and linear Taylor in 4-layer SpiderCNN for classification on ModelNet40. The results are summarized in Table 5.

3 SpiderCNN + PointNet

Figure 13 shows the architecture of combing a 3-layer SpiderCNN with PointNet in Section 4.1. Table 6 summarizes the classification results on ModelNet40. We see that the combined model outperforms 3-layer SpiderCNN and PointNet.