Local Spectral Graph Convolution for Point Set Feature Learning
Abstract
Feature learning on point clouds has shown great promise, with the introduction of effective and generalizable deep learning frameworks such as pointnet++. Thus far, however, point features have been abstracted in an independent and isolated manner, ignoring the relative layout of neighboring points as well as their features. In the present article, we propose to overcome this limitation by using spectral graph convolution on a local graph, combined with a novel graph pooling strategy. In our approach, graph convolution is carried out on a nearest neighbor graph constructed from a point’s neighborhood, such that features are jointly learned. We replace the standard max pooling step with a recursive clustering and pooling strategy, devised to aggregate information from within clusters of nodes that are close to one another in their spectral coordinates, leading to richer overall feature descriptors. Through extensive experiments on diverse datasets, we show a consistent demonstrable advantage for the tasks of both point set classification and segmentation.
Keywords:
Point Set Features, Graph Convolution, Spectral Filtering, Spectral Coordinates, Clustering, Deep Learning.1 Introduction
With the present availability of registered depth and appearance images of complex realworld scenes, there is tremendous interest in feature processing algorithms for classic computer vision problems including object detection, classification and segmentation. In their latest incarnation, for example, depth sensors are now found in the apple iPhone X camera, making a whole new range of computer vision technology available to the common user. For such data it is particularly attractive to work directly with the unorganized 3D point clouds and to not require an intermediate representation such as a surface mesh. The processing of 3D point clouds from such sensors remains challenging, since the sensed depth points can vary in spatial density, can be incomplete due to occlusion or perspective effects and can suffer from sensor noise.
Motivated by the need to handle unstructured 3D point clouds while leveraging the power of deep neural networks, the pointnet++ framework has shown promise for 3D point cloud feature processing for the tasks of recognition and segmentation [13]. In this approach a network structure is designed to work directly with point cloud data, while aggregating information in a hierarchical fashion, in the spirit of traditional CNNs on regular grids. To do so, a centroid sampling is first applied on the input point cloud, followed by a radius search to form point neighborhoods. Then the point neighborhoods are processed by multilayer perceptrons [11] and the resulting point features are abstracted by a pooling operation. Through hierarchical multilayer learning on the point cloud data, the pointnet++ framework exhibits impressive performance in both segmentation and classification on challenging benchmarks, while treating the input data as an unorganized point cloud.
In a parallel development, Defferrard et al. have sought to extend CNNs, traditionally applied on regular domains, such as sampled image pixels in 2D or voxels in 3D, to irregular domains represented as graphs [4]. Their approach uses Chebyshev polynomials to approximate spectral graph filters; an initial graph is processed by convolutional operations to yield features which are then coarsened using subsampling and pooling methods. Kipf and Welling [6] simplify the higher order polynomial approximations in Defferrard et al. and propose a first order linear approximation of spectral graph filters. The aforementioned spectral approaches operate on the full graph and have the limitation that the graph Laplacian and the graph coarsening hierarchy have to be precomputed, in an offline manner, before the network training or testing. This adds significant overhead when the full graph is large.
In this article we propose to leverage the power of spectral graph CNNs in the pointnet++ framework, while adopting a different pooling strategy. This allows us to address two limitations of present deep learning methods from point clouds: 1) the fact that for each point sample the learning of features is carried out in an isolated manner in a local neighborhood and 2) that the aggregation of information in later layers uses a greedy winnertakeall max pooling strategy. Instead, we adopt a different pooling module, as illustrated by the detailed example in Fig. 1. Further, our method requires no precomputation, in contrast to existing spectral graph CNN approaches [4, 6]. Our combination of local spectral feature learning with recursive clustering and pooling provides a novel architecture for point set feature abstraction from unorganized point clouds. Our main methodological contributions are the following:

The use of local spectral graph convolution in point set feature learning to incorporate structural information in the neighborhood of each point.

An implementation of the local spectral graph convolution layer that requires no offline computation and is trainable in an endtoend manner. We build the graph dynamically during runtime and compute the Laplacian and pooling hierarchy on the fly.

The use of a novel and effective graph pooling strategy, which aggregates features at graph nodes by recursively clustering the spectral coordinates.
The proposed architecture leads to new stateoftheart object recognition and segmentation results on diverse datasets, as demonstrated by extensive experiments.
2 Challenges in point set feature learning
A limitation of feature learning in the pointnet++ framework [13], is that features from the nearest neighbors (NN) of a point are learned in an isolated fashion. Let represent the output of an arbitrary hidden layer in a deep network, typically a multilayer perceptron. In pointnet++ the individual features for each point in the NN are achieved with Unfortunately, this hidden layer function does not model the joint relationship between points in the NN. A convolution kernel that jointly learns features from all points in the NN would capture topological information related to the geometric layout of the points, as well as features related to the input point samples themselves, e.g., color, texture, or other attributes. In the following section we shall extend approaches such as the pointnet++ framework to achieve this goal by using local graph convolution, but in the spectral domain.
Another limitation in pointnet++ is that the set activation function for the NN is achieved by max pooling across the hidden layer’s output for each point, such that
(1) 
Max pooling does not allow for the preservation of information from disjoint sets of points within the neighborhood, as in the case of the legs of the ant in Fig. 1. To address this limitation we introduce a recursive spectral clustering and pooling module that yields an improved set activation function for the NN, as discussed in Section (4). The combined point set feature abstraction operation in this paper can be summarized by
(2) 
where is the convolution output evaluated at the th point and stands for our proposed set activation function.
Fig. 2 provides a comparison between the pointwise MLP in pointnet++ [13] and our spectral graph convolution, to better illustrate our motivation. Whereas pointnet++ abstracts point features in an isolated manner, spectral graph convolution considers all points in a local neighborhood in a joint manner, incorporating both features at neighboring points as well as structural information encoded in the graph topology in the abstraction. More formally, this is accomplished via the graph Fourier transform and spectral modulation steps, which blend neighborhood features using the eigenspace of the graph Laplacian (see Fig. 3). In the following section, we provide theoretical background and implementation details of our spectral graph convolution kernel.
3 Graph Convolution
The convolution operation in the spatial domain (directly on vertices in the graph) is described by
(3) 
where stands for the input point set features and for a spatial convolution kernel. This is equivalent to an elementwise Hadamard product in the graph spectral domain, as is shown in Defferrard et al. [4] and Shuman et al. [15]
(4) 
Here stands for the graph Fourier transform of the point set features, stands for the filter in the graph Fourier domain and for the filtered output. In order to acquire the filtered output in the original spatial (vertex) domain, an inverse Fourier transform is required. We elaborate on the graph Fourier transform and the spectrum filtering below.
3.1 Graph Formulation of a Local Neighborhood
Given a set of points in a local neighborhood, we build a representation graph whose vertices are the points and whose edges carry weights based on a measurement of pairwise distance, such as Euclidean distance between spatial coordinates or distance in a feature space provided by the deep network. This provides a graph adjacency matrix , which is nonnegative, symmetric, with entries . We then compute the graph spectrum based on this adjacency matrix and perform a graph Fourier transform, spectral filtering and finally an inverse Fourier transform.
3.2 Graph Fourier Transform
To compute a graph Fourier Transform of the point features , which are graph signals on vertices of , we first need to compute the normalized graph Laplacian defined as
(5) 
where is the identity matrix and is the diagonal degree matrix with entries . It follows that is a real symmetric positive semidefinite matrix, and has a complete set of orthonormal eigenvectors which comprise the graph Fourier basis
(6) 
The eigenvalues can be used to construct a diagonal matrix
(7) 
which contains the frequencies of the graph. Then it follows that . The graph Fourier transform of is then defined as and its inverse as .
3.3 Spectral Filtering
The convolution operation is defined in the Fourier domain as
(8) 
following Shuman et al. [15], where is the elementwise Hadamard product, is an arbitrary graph signal and is a spatial filter. If we define as the output of the graph convolution, it follows that a graph signal filtered by can be written as
(9) 
where stands for an arbitrary parametrization. In the following section, we describe our implementation of spectral filtering, which is introduced as a module on top of the existing pointnet++ [13] framework, using TensorFlow.
3.4 Implementation of Spectral Filtering
We carry out spectral graph convolution using standard unparametrized Fourier kernels, where the entries of are all learnable. With the input feature dimension and the output dimension, convolution of a graph signal with spectral filters can be achieved by the following three steps:

Spectral modulation which outputs , with the diagonal matrix being the unparametrized kernel . The diagonal entries of are all free parameters in the unparametrized Fourier kernel formulation.

Feature filtering which expands the input dimension from to . The output of this step is a feature matrix . The entry is the th output feature of the th point and is given by Here is the entry of corresponding to the th input feature of the th point defined in the previous step and is the filter coefficient between the th input feature with th output feature. This step can be represented by , where is the matrix of learnable filter parameters. The filtering operation in steps 1 and 2 can be summarized as
(10) 
Reverse Fourier transform which provides convolution outputs in the spatial graph signal domain via .
The above formulation resembles that of [4] and [6], with the difference that we build the NN graph during runtime, computing its Laplacian and pooling hierarchy on the fly, thereby requiring no offline precomputation. We further note that the weights of the feature filter , as well as the spectral modulation matrix , are shared by all the different local neighborhoods in a given graph convolution layer. Thus, unlike [4, 6], the learned parameters in our work do not depend on the underlying graph structure. Fig. 2 (bottom) illustrates the above spectral filtering process.
While the more sophisticated efficient kernels of [4] could be used, our goal was to demonstrate the improvement obtained by graph CNNs in general. The overhead of eigenvalue decomposition (EVD) in our unparametrized spectral kernel does not significantly affect runtime since the EVD is computed on local NN graphs, with being very small. This computation is easily handled by parallel computing on GPUs as demonstrated by the experiments showing training time cost in our model ablation study in Section 5.3.
4 Pooling on Local NN Graph
The set activation function discussed in Section 2, whose aim is to summarize information from a NN graph, is essentially a form of graph pooling, where a graph of vertices is abstracted via feature pooling to a single vertex. We propose a novel NN graph pooling algorithm using hierarchical clustering and withincluster pooling.
The general strategy is to pool information during learning in a manner that does so only within a cluster of similar abstract point features, in contrast to the greedy strategy of max pooling, which is commonly applied in regular CNNs as well as in pointnet++. The intuition here is that multiple sets of distinct features may together contribute towards a salient property for the task at hand, and that the detection of these clusters combined with within cluster pooling will improve performance. For example, for the task of classifying a point set sampled from a human head one would want to simultaneously learn and capture noselike, chinlike and earlike features and not assume that only one of these would be discriminative for this object category. We discuss each of our steps in turn.
4.1 Spectral Clustering
We propose to group features into clusters according to a local NN’s geometric information that is embedded using spectral coordinates. The spectral coordinates we use are based on the low frequency eigenvectors of the Graph Laplacian , which capture coarse shape properties since the Laplacian itself encodes pairwise distances in the NN graph. As exploited in [9] [1] for computing pointtopoint correspondences on meshes or for feature description, the low frequency spectral coordinates provide a discriminative spectral embedding of an object’s local geometry (see Fig. 1 bottom and Fig. 3). The eigenvector corresponding to the second smallest eigenvalue, the Fiedler vector [2], is widely used for spectral clustering [14].
bird  human  



4.2 Clustering, Pooling and Recurrences
Following the normalized cuts clustering algorithm [14], we partition the Fiedler vector to perform spectral clustering in a local NN. We first sort the entries of the Fiedler vector in ascending order of their numerical value, and then evenly cut it into sections in the first iteration. The points in the neighborhood whose Fiedler vector entries fall in the same section will be clustered together. This results in clusters with a cluster size of . After obtaining a partition into clusters, we perform pooling operations only within each cluster. This allows the network to take advantage of separated features from possibly disjoint components in the NN graph.
The above steps result in a coarsened NN graph with aggregated point features. The same process is then repeated on the coarsened graph in a recursive manner, to obtain clusters for each iteration . Note that we alternate between max pooling and average pooling between different recurrences to further increase the discriminative power of the graph pooling algorithm. The proposed algorithm terminates when the number of vertices remaining is smaller or equal to a prescribed cluster size. A regular full stride pooling is then applied on the resultant graph signals. We formalize the above steps in Algorithm 1.
In practice, we found that using as a relationship between cluster size and neighborhood size gave good results, with two recurrences of cluster pooling and a final pooling of size 2. We used max pooling as the first stage in the alternating pooling scheme, and fixed these configurations for all our experiments in Section 5. We implemented the recursive cluster pooling module in TensorFlow, integrating it fully with the spectral graph convolution layer to make the resultant network endtoend trainable.
5 Experiments
5.1 Datasets
We evaluate our approach against present stateoftheart methods on the following 5 datasets:

ModelNet40 [19]: This contains CAD models of 40 categories, sampled into point clouds. We use the official split, with 9,843 training and 2,468 testing examples.

McGill Shape Benchmark [16]: This dataset contains 456 CAD models of 19 object level categories. We sample the meshes into point clouds and use the first twothirds of the examples in each category for training and the remaining onethird for testing. The dataset is also divided into articulated (254 models) versus nonarticulated (202 models) subcategories.

ShapeNet part segmentation dataset [20]: This dataset contains 16,881 shapes from 16 classes, with the points of each model labeled into one of 50 part types. We use the official training/testing split, following [11, 20, 21], where the challenge is to assign a part label to each point in the test set.
Structure  L1  L2  L3  L4  Kernel  Pooling  
3lpointnet++  512  128  1    max  
64  64  128    pointMLP  
128  256  1024    
4lpointnet++  512  128  32  1  max  
32  32  8  32  pointMLP  
128  256  512  1024  
4lspecmax  512  128  32  1  max  
32  32  8  32  specconv  
128  256  512  1024  
4lspeccp  512  128  32  1  cp  
32  32  8  32  specconv  
128  256  512  1024 
Structure  L1  L2  L3  L4  Kernel  Pooling  
3lpointnet++  1024  256  1    max  
64  64  256    pointMLP  
128  256  1024    
4lpointnet++  1024  256  64  1  max  
32  32  8  64  pointMLP  
128  256  512  1024  
4lspecmax  1024  256  64  1  max  
32  32  8  64  specconv  
128  256  512  1024  
4lspeccp  1024  256  64  1  cp  
32  32  8  64  specconv  
128  256  512  1024 
5.2 Network Architecture and Training
We provide details of our network structures for the case of 1024 input points (1k) and 2048 input points (2k). The network structure for the 2k experiments is designed to be “wider” to better accommodate the increased input point density. Table 1 lists all the variations of the pointnet++ and our spectral point convolution network structures, which we will later to refer to when presenting experimental results. The 3lpointnet++ is that defined in the “pointnet2_cls_ssg.py” model file on the pointnet++ GitHub page ^{1}^{1}1https://github.com/charlesq34/pointnet2/blob/master/models/pointnet2_cls_ssg.py. We replace the kernels from 4lpointnet++ with spectral graph convolution kernels to acquire the 4lspecmax model. Replacing max pooling with recursive cluster pooling in the 4lspecmax model results in the 4lspeccp model.
Configurations for the layers after L3/L4 in Table 1 differ for the classification and segmentation tasks. For classification on the McGill Shape Benchmark, ModelNet40 and MNIST, we used 3 fully connected layers with drop out, i.e., FC(512, 0.5) FC(256, 0.5) FC(#classes). For segmentation on the ShapeNet Part Segmentation and ScanNet datasets, feature propagation (FP) layers (as in [13]) are applied after L3/L4. The number of FP layers and their input/output dimensions are the same as those of the corresponding previous set activation layers. After the FP layers, two fully connected layers are applied to map learned features to point labels.
In all our experiments, we applied the following strategy for network training. We used the Adam optimizer [5] with an initial learning rate of 0.001 and an exponential decay on the learning rate with a ratio of 0.5 applied every 20 epochs. We chose to use the Relu activation function and applied batch normalization (BN) with a size of 32 and a decay rate set to increase from 0.5 to 0.99. Throughout we followed the strategy in pointnet++ [13] for data augmentation: random rotation around the upright direction, small rotation perturbation around the axes, point location perturbation, and random scaling and translation.
5.3 Ablation Study for Network Models
We now evaluate the effect of the novel components in our framework: 1) local spectral filtering on a NN and 2) recursive cluster pooling for local outputs. We apply a 4 layer pointnet++ structure as the baseline method, then add spectral filters to each layer, and then replace max pooling with recursive cluster pooling. We also include results obtained using the 3 layer structure used in [13]. In addition, we consider the scalability of both approaches, by varying the number of input points, the effect of including additional features such as surface normals, and training time. These results are presented in Table (2).
ModelNet40  Acc 1k  Acc 1k +N  Time 250ep  Acc 2k +N  Time 250ep 
3lpointnet++  90.7  91.3  11h  91.5  20h 
4lpointnet++  90.6  91.1  7.5h  91.2  11h 
4lspecmax  91.2  91.6  8h  91.9  12h 
4lspeccp  91.5  91.8  12h  92.1  20h 
ShapeNet Seg  mIOU 1k  mIOU 1k +N  Time 100ep  mIOU 2k +N  Time 100ep 
3lpointnet++  84.2  84.7  7.5h  84.9  14h 
4lspeccp  84.6  85.0  8h  85.4  14h 
From the model ablation study in Table 2, it is evident that our proposed model, which incorporates spectral graph convolution together with recursive cluster pooling, provides a nontrivial improvement over pointnet++ on both the classification and segmentation tasks. We make the following observations: 1) 3lpointnet++ performs better than the 4 layer version. This is likely because in the 4 layer version the neighborhood size is half of that in the 3 layer version. Since features are learned at each point in an isolated fashion in pointnet++, the use of larger neighborhoods gives an advantage. 2) Spectral graph convolution on local NNs performs better than pointwise MLP. The 4lspecmax model outperforms 4lpointnet++. This implies that the topological information encoded by spectral graph convolution benefits feature learning. 3) Recursive cluster pooling further boosts the performance of the spectral graph convolution layer. This suggests that information aggregation following spectral coordinates increases the discriminative power of the learned point features, benefiting both classification and segmentation. 4) The runtime of our model is comparable to those of pointnet++. The eigenvalue decomposition used in spectral convolution and recursive cluster pooling could in theory be costly, but since we use local neighborhoods the impact is not severe. Our best model, 4lspeccp, has roughly the same training time as that of 3lpointnet++, which is the best model from pointnet++. Spectral graph convolution kernels are as fast as the pointwise MLP kernels, which can be seen by comparing the runtime of the 4lspecmax and 4lpointnet++ models.
We now provide comparisons against the present stateoftheart methods, in both classification and segmentation tasks, on various datasets described in Section 5.1. When comparing against pointnet++, unless stated otherwise, we apply the 3lpointnet++ model since it gives better results than the 4 layer version in our model ablation study in Table 2.
5.4 Classification Experiments
5.4.1 McGill Shape Benchmark
The classification results for the McGill Shape Benchmark are presented in Table 3, using 1024 points as the inputs in all cases. Spectral graph convolution on point sets provides a consistent boost in both average instance level accuracy and category level accuracy. Further, the use of recursive cluster pooling grants our model another boost in overall instance level accuracy over max pooling. Since the NNs may contain disjoint sets of points, a recursive aggregation of NN features by clustering the spectral coordinates appears to increase discriminative power for articulated objects.
Avg Instance Level Accuracy (%)  Avg Category Level Accuracy (%)  
Model  Kernel  Pooling  Articulated  NonArti  Combined  Articulated  NonArti  Combined 
3lpointnet++  pointMLP  max  91.25  95.31  93.06  91.33  95.44  93.27 
4lpointnet++  pointMLP  max  92.50  92.19  92.36  92.83  92.74  92.79 
4lspeccp  specconv  max  92.50  98.44  95.14  92.75  98.41  95.43 
specconv  cp  93.75  98.44  95.83  93.30  98.41  95.74 
5.4.2 MNIST dataset
2D images can be treated as a grid graph [4, 10] or a 2D point cloud [13]. We provide results on the MNIST dataset using our proposed best model, 4lspeccp, from the previous model ablation study. We compare our results with the stateoftheart methods in graph CNNs [4, 10], in point sets [13] ^{2}^{2}2We tried to reproduce the pointnet++ results on MNIST. Our error rate is very close to the error rate reported by the authors. and with regular neural network/CNN approaches applied on the 2D image domain [17, 7, 8].
For both pointnet++ and our method, 784 points are provided as inputs to the network and we use the 1k experimental network, where the first layer samples 512 centroids (see Table 1). The results in Table 4 show that approaches which favor local operations on the input domain usually yield better performance, for instance, MLP vs. LeNet, and our method vs. ChebNet. Our approach gives a 20% error rate reduction over pointnet++, demonstrating the advantage of spectral convolution on a local NN graph over the isolated learning process in pointwise MLP. In addition, our performance surpasses that of the Network in Network model [8], which is a strong regular image CNN model.
Method  Domain  Kernel  Error Rate(%) 
Multilayer perceptron [17]  full image  spatial MLP  1.60 
LeNet5 [7]  local img patch  spatial conv  0.80 
Network in Network [8]  local img patch  spatial conv  0.47 
ChebNet [4]  full graph  spectral graph conv  0.86 
MoNet [10]  local graph  spatial graph conv  0.81 
3lpointnet++ [13]  local points  spatial pointMLP  0.55 
4lspeccp  local NN graph  spectral graph conv  0.42 
Method  Domain  Kernel  Pooling  Acc (%)  Acc + N (%) 
Subvolume [12]  Voxel Grid  3D conv  3Dmax  89.2   
MVCNN [18]  2D views  2D conv  viewmax  90.1   
PointNet [11]  Full Points  pointMLP  pointmax  89.2   
3lpointnet++ [13]  Local Points  pointMLP  pointmax  90.7  91.5 
4lspecmax  Local NN graph  graph conv  graphmax  91.2  91.9 
4lspeccp  Local NN graph  graph conv  graphcp  91.5  92.1 
5.4.3 ModelNet 40 Dataset
We present ModelNet40 3D shape recognition results in Table 5, where we compare our method with representative competitive approaches. We were able to reproduce the results from pointnet++, to get very similar performance to that reported by the authors in [13]. We report two sets of accuracy results. In the first 1024 point coordinates are used as inputs, with the network structure following the 1k configurations in Table 1. In the second 2048 points along with their surface normals are used as inputs, with the network structure following the 2k configurations in Table 1. Our use of spectral graph convolution and recursive cluster pooling provides a consistent improvement over pointnet++, and leads to stateoftheart level classification performance on the ModelNet40 Benchmark.
5.5 Segmentation Experiments
Point segmentation is a labeling task for each point in a 3D point set, and is more challenging than point set classification. We present experimental results on ShapeNet [20] and ScanNet [3] in Table 6. We then provide details on experimental settings for each case.
Method  Domain  Kernel  ShapeNetmIOU (%)  ScanNetAcc (%) 
Yi et al. [20]      81.4   
Dai et al. [3]  Voxel Grid  3D conv    73.0 
SynSpecCNN [22]  Full NN Graph  graph conv  84.7   
PointNet [11]  Full Points  pointMLP  83.7  73.9 
Pointnet++ [13]  Local Points  pointMLP  84.9  84.0 
4lspeccp  Local NN Graphs  graph conv  85.4  84.8 
5.5.1 Shapenet Part Segmentation Dataset
We compare our method with stateoftheart approaches, as well as the reproduced results from pointnet++. Following the setting in [20], we evaluate our approach assuming that a category label for each shape is already known and we use the same mIoU (mean intersection over union) metric on points. 2048 points and their surface normals are used as input features and the network structure follows that of the 2k configurations in Table 1. More specifically, 3lpointnet++ model is applied for pointnet++ and 4lspeccp is applied for our method.
5.5.2 ScanNet Dataset
ScanNet is a largescale semantic segmentation dataset constructed from realworld 3D scans of indoor scenes, and as such is more challenging than the synthesized 3D models in ShapeNet. Following [13][3], we remove RGB information in our experiments in Table 6 and we use the semantic voxel label prediction accuracy for evaluation. The training and testing procedures follow those in pointnet++ [13]. 8192 points are used as input features and the network structure is that of the 2k configurations in Table 1. More specifically, the 4lpointnet++ model is applied for pointnet++ and the 4lspeccp is applied for our method. ^{3}^{3}3The 3lpointnet++ model leads to inferior performance on this largescale indoor dataset. For both networks, for all experiments reported in this paper, single scale grouping (SSG in [13]) is applied for a fair comparison.
5.5.3 Results and Discussion
handbag  skateboard  table  lamp  airplane  knife  
PN++  
Ours 

GT 


The use of spectral graph convolution combined with cluster pooling in our approach once again provides a nontrivial improvement over pointnet++, achieving stateoftheart level performance on both part segmentation (ShapeNet) and indoor scene semantic segmentation (ScanNet). We provide an illustrative visualization of the part segmentation results on selected models in Fig. 4. In these examples, when compared to pointnet++, our approach gives results that are closer to the ground truth overall and better captures fine local structures, such as the axles of the skateboard, and the feet of the table. In addition, spectral graph convolution with cluster pooling provides a more faithful representation of changes in local geometry. This allows us to successfully segment connected parts of a 3D object, such as the strap from the body of the hand bag, the wings from the tail fins of the airplane and the handle from the blade of the knife.
6 Conclusion
The use of spectral graph convolution on local point neighborhoods, followed by recursive cluster pooling on the resultant representations, holds great promise for feature learning from unorganized 3D point sets. Our method’s ability to capture local structural information and geometric cues presents an advance in deep learning approaches to feature abstraction from unorganized point sets in 3D computer vision. Considering its strong experimental performance, acceptable runtime, and versatility in handling a variety of datasets and tasks, our approach could have considerable practical value as 3D depth sensors begin to become more and more common place.
References
 [1] Bronstein, A.M., Bronstein, M.M., Kimmel, R.: Numerical Geometry of Nonrigid Shapes. Monographs in Computer Science, Springer (2008)
 [2] Chung, F.R.: Spectral graph theory. No. 92 in Regional Conference Series in Mathematics, American Mathematical Soc. (1997)
 [3] Dai, A., Chang, A.X., Savva, M., Halber, M., Funkhouser, T., Nießner, M.: Scannet: Richlyannotated 3d reconstructions of indoor scenes. In: Proc. IEEE Conf. on Computer Vision and Pattern Recognition (CVPR). vol. 1 (2017)
 [4] Defferrard, M., Bresson, X., Vandergheynst, P.: Convolutional neural networks on graphs with fast localized spectral filtering. In: Advances in Neural Information Processing Systems. pp. 3844–3852 (2016)
 [5] Kingma, D.P., Ba, J.: Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980 (2014)
 [6] Kipf, T.N., Welling, M.: Semisupervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907 (2016)
 [7] LeCun, Y., Bottou, L., Bengio, Y., Haffner, P.: Gradientbased learning applied to document recognition. Proceedings of the IEEE 86(11), 2278–2324 (1998)
 [8] Lin, M., Chen, Q., Yan, S.: Network in network. arXiv preprint arXiv:1312.4400 (2013)
 [9] Lombaert, H., Grady, L., Cheriet, F.: Focusr: feature oriented correspondence using spectral regularization–a method for precise surface matching. IEEE Transactions on Pattern Analysis and Machine Intelligence 35(9), 2143–60 (2013)
 [10] Monti, F., Boscaini, D., Masci, J., Rodolà, E., Svoboda, J., Bronstein, M.M.: Geometric deep learning on graphs and manifolds using mixture model cnns. CVPR 2017 (2016)
 [11] Qi, C.R., Su, H., Mo, K., Guibas, L.J.: Pointnet: Deep learning on point sets for 3d classification and segmentation. arXiv preprint arXiv:1612.00593 (2016)
 [12] Qi, C.R., Su, H., Niessner, M., Dai, A., Yan, M., Guibas, L.J.: Volumetric and MultiView CNNs for Object Classification on 3D Data. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) (2016)
 [13] Qi, C.R., Yi, L., Su, H., Guibas, L.J.: Pointnet++: Deep hierarchical feature learning on point sets in a metric space. NIPS (2017)
 [14] Shi, J., Malik, J.: Normalized cuts and image segmentation. IEEE Transactions on pattern analysis and machine intelligence 22(8), 888–905 (2000)
 [15] Shuman, D.I., Narang, S.K., Frossard, P., Ortega, A., Vandergheynst, P.: The emerging field of signal processing on graphs: Extending highdimensional data analysis to networks and other irregular domains. IEEE Signal Processing Magazine 30(3), 83–98 (2013)
 [16] Siddiqi, K., Zhang, J., Macrini, D., Shokoufandeh, A., Bouix, S., Dickinson, S.: Retrieving articulated 3d models using medial surfaces. Machine Vision and Applications 19(4), 261–274 (2008)
 [17] Simard, P.Y., Steinkraus, D., Platt, J.C., et al.: Best practices for convolutional neural networks applied to visual document analysis. In: ICDAR. vol. 3, pp. 958–962 (2003)
 [18] Su, H., Maji, S., Kalogerakis, E., LearnedMiller, E.: Multiview convolutional neural networks for 3D shape recognition. In: Proceedings of the IEEE International Conference on Computer Vision (2015)
 [19] Wu, Z., Song, S., Khosla, A., Yu, F., Zhang, L., Tang, X., Xiao, J.: 3D shapenets: A deep representation for volumetric shapes. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (2015)
 [20] Yi, L., Kim, V.G., Ceylan, D., Shen, I., Yan, M., Su, H., Lu, A., Huang, Q., Sheffer, A., Guibas, L., et al.: A scalable active framework for region annotation in 3d shape collections. ACM Transactions on Graphics (TOG) 35(6), 210 (2016)
 [21] Yi, L., Su, H., Guo, X., Guibas, L.: Syncspeccnn: Synchronized spectral cnn for 3d shape segmentation. CVPR (2017)
 [22] Yi, L., Su, H., Guo, X., Guibas, L.: Syncspeccnn: Synchronized spectral cnn for 3d shape segmentation. In: Computer Vision and Pattern Recognition (CVPR) (2017)