Local Spectral Graph Convolution for Point Set Feature Learning

Local Spectral Graph Convolution for Point Set Feature Learning

Chu Wang School of Computer Science and Center for Intelligent Machines,
McGill University
1
   Babak Samari School of Computer Science and Center for Intelligent Machines,
McGill University
1
   Kaleem Siddiqi School of Computer Science and Center for Intelligent Machines,
McGill University
1
1email: {chuwang,babak,siddiqi}@cim.mcgill.ca
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 real-world 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 multi-layer perceptrons [11] and the resulting point features are abstracted by a pooling operation. Through hierarchical multi-layer 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 sub-sampling 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.

Figure 1: Top: Starting from a point cloud, farthest point sampling leads to centroids, from which -NN’s are sampled. Then, for each neighborhood, spectral convolution is carried out followed by recursive cluster pooling. After several layers of sampling, spectral convolution and cluster pooling, we perform segmentation or classification. Bottom: The green dashed box details the process of recursive spectral cluster pooling on the Fiedler vector of a sample neighborhood. See text in Section 4 for a discussion.

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 winner-take-all 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 end-to-end 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 state-of-the-art 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 point-wise 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.

Figure 2: Top: A comparison between point-wise MLP in pointnet++ (left) and our spectral graph convolution (right) in a local neighborhood. For each point, the spectral graph convolution output depends on all points in its neighborhood, whereas in point-wise MLP the output only depends on the point itself. Bottom: We illustrate the network operations in a spectral graph convolutional layer, with the corresponding input/output dimensions.

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 element-wise 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 pair-wise 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 element-wise 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:

  1. 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.

  2. 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)
  3. 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 within-cluster 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 nose-like, chin-like and ear-like 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 point-to-point 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


Figure 3: A visualization of spectral coordinates for models of a bird and a human, both from the McGill Shape Benchmark. is the -th eigenvalue of the graph Laplacian.

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 end-to-end trainable.

Inputs: pts point features , csize cluster size, and Pool the Pool method.
     Output: Pooled point features .
     Methods: Arg_Sort(x) returns the sorted indices of x, ReArrenge(x,y) permutes x along its 1st dimension according to the given indices y, Pool(x) pools x along its 1st dimension.

procedure Cluster(pts, csize, Pool)
      Adj_Matrix(pts)
      Laplacian()
      EVD()
     fiedler_vector
     inds Arg_Sort(fiedler_vector)
     ReArrenge(pts, inds)
     ReShape(pts, [:, csize])
     return Pool(pts)
procedure Main(pts, csize)
     Pool Max_Pool
     while Count(pts)csize do
          ptsCluster(pts, csize, Pool)
          if Pool Max_Pool then
               Pool Avg_Pool
          else
               Pool Max_Pool                
     return Pool(pts)
Algorithm 1 Recursive Cluster Pooling

5 Experiments

5.1 Datasets

We evaluate our approach against present state-of-the-art methods on the following 5 datasets:

  • MNIST: This contains images of handwritten digits with 60k training and 10k testing samples. It has been used to benchmark related graph CNN approaches [4, 10] as well as pointnet++ [13].

  • 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 two-thirds of the examples in each category for training and the remaining one-third for testing. The dataset is also divided into articulated (254 models) versus non-articulated (202 models) sub-categories.

  • 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.

  • ScanNet Indoor Scene dataset [3]: This dataset contains 1513 scanned and reconstructed indoor scenes, with rich annotations including semantic voxel labels. We follow the experimental settings for segmentation in [13, 3] and use 1201 scenes for training, and 312 scenes for testing.

Structure L1 L2 L3 L4 Kernel Pooling
3l-pointnet++ 512 128 1 - max
64 64 128 - pointMLP
128 256 1024 -
4l-pointnet++ 512 128 32 1 max
32 32 8 32 pointMLP
128 256 512 1024
4l-spec-max 512 128 32 1 max
32 32 8 32 spec-conv
128 256 512 1024
4l-spec-cp 512 128 32 1 cp
32 32 8 32 spec-conv
128 256 512 1024
Structure L1 L2 L3 L4 Kernel Pooling
3l-pointnet++ 1024 256 1 - max
64 64 256 - pointMLP
128 256 1024 -
4l-pointnet++ 1024 256 64 1 max
32 32 8 64 pointMLP
128 256 512 1024
4l-spec-max 1024 256 64 1 max
32 32 8 64 spec-conv
128 256 512 1024
4l-spec-cp 1024 256 64 1 cp
32 32 8 64 spec-conv
128 256 512 1024
Table 1: Network architectures for the 1k experiments (left) and the 2k experiments (right). Here, for each layer, stands for the number of centroids, stands for the size of the -NN, and stands for the output feature dimension.

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 3l-pointnet++ is that defined in the “pointnet2_cls_ssg.py” model file on the pointnet++ GitHub page 111https://github.com/charlesq34/pointnet2/blob/master/models/pointnet2_cls_ssg.py. We replace the kernels from 4l-pointnet++ with spectral graph convolution kernels to acquire the 4l-spec-max model. Replacing max pooling with recursive cluster pooling in the 4l-spec-max model results in the 4l-spec-cp 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 up-right 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
3l-pointnet++ 90.7 91.3 11h 91.5 20h
4l-pointnet++ 90.6 91.1 7.5h 91.2 11h
4l-spec-max 91.2 91.6 8h 91.9 12h
4l-spec-cp 91.5 91.8 12h 92.1 20h
ShapeNet Seg mIOU 1k mIOU 1k +N Time 100ep mIOU 2k +N Time 100ep
3l-pointnet++ 84.2 84.7 7.5h 84.9 14h
4l-spec-cp 84.6 85.0 8h 85.4 14h
Table 2: Model Ablation Study on ModelNet40 (classification) and ShapeNet (segmentation). Acc stands for classification accuracy, 1k/2k refers to the number of points used and “+N” indicates the addition of surface normal features to xyz. For the segmentation experiments, mIOU stands for mean intersection over union. Here we only compare the best models from pointnet++ with ours. Training time is with respect to the number of epochs used in each experiment. Adding normals only increases the training time by a negligible amount, therefore only one runtime column is provided for the 1k experiments. Network structures for all the reported experiments are in Table 1.

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 non-trivial improvement over pointnet++ on both the classification and segmentation tasks. We make the following observations: 1) 3l-pointnet++ 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 point-wise MLP. The 4l-spec-max model outperforms 4l-pointnet++. 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, 4l-spec-cp, has roughly the same training time as that of 3l-pointnet++, which is the best model from pointnet++. Spectral graph convolution kernels are as fast as the point-wise MLP kernels, which can be seen by comparing the runtime of the 4l-spec-max and 4l-pointnet++ models.

We now provide comparisons against the present state-of-the-art 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 3l-pointnet++ 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 Non-Arti Combined Articulated Non-Arti Combined
3l-pointnet++ point-MLP max 91.25 95.31 93.06 91.33 95.44 93.27
4l-pointnet++ point-MLP max 92.50 92.19 92.36 92.83 92.74 92.79
4l-spec-cp spec-conv max 92.50 98.44 95.14 92.75 98.41 95.43
spec-conv cp 93.75 98.44 95.83 93.30 98.41 95.74
Table 3: McGill Shape Benchmark classification results. We report the instance and category level accuracy on both the entire database and on subsets (see Table 1 for network structures).

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, 4l-spec-cp, from the previous model ablation study. We compare our results with the state-of-the-art methods in graph CNNs [4, 10], in point sets [13] 222We 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 point-wise 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(%)
Multi-layer 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
3l-pointnet++ [13] local points spatial point-MLP 0.55
4l-spec-cp local -NN graph spectral graph conv 0.42
Table 4: Results on the MNIST dataset. For the pointnet++ results, we reproduced their experiments, as discussed in [13].
Method Domain Kernel Pooling Acc (%) Acc + N (%)
Subvolume [12] Voxel Grid 3D conv 3D-max 89.2 -
MVCNN [18] 2D views 2D conv view-max 90.1 -
PointNet [11] Full Points point-MLP point-max 89.2 -
3l-pointnet++ [13] Local Points point-MLP point-max 90.7 91.5
4l-spec-max Local -NN graph graph conv graph-max 91.2 91.9
4l-spec-cp Local -NN graph graph conv graph-cp 91.5 92.1
Table 5: ModelNet40 results. “Acc” stands for 1k experiments with only points as input features. “Acc + N” stands for 2k experiments with points along with their surface normals as input features.“graph-cp” stands for recursive cluster pooling, introduced in section 4.

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 state-of-the-art 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 ShapeNet-mIOU (%) ScanNet-Acc (%)
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 point-MLP 83.7 73.9
Pointnet++ [13] Local Points point-MLP 84.9 84.0
4l-spec-cp Local -NN Graphs graph conv 85.4 84.8
Table 6: A comparison between our method and the present state-of-the-art approaches in segmentation tasks. For ShapeNet, mIOU stands for mean intersection over union on points, and for ScanNet, Acc stands for voxel label prediction accuracy.

5.5.1 Shapenet Part Segmentation Dataset

We compare our method with state-of-the-art 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, 3l-pointnet++ model is applied for pointnet++ and 4l-spec-cp is applied for our method.

5.5.2 ScanNet Dataset

ScanNet is a large-scale semantic segmentation dataset constructed from real-world 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 4l-pointnet++ model is applied for pointnet++ and the 4l-spec-cp is applied for our method. 333The 3l-pointnet++ model leads to inferior performance on this large-scale 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 skate-board     table lamp airplane knife
PN++

Ours

GT

Figure 4: A visualization of segmentation results on ShapeNet using pointnet++ (top row, 84.9% in Table 6), our 41-spec-cp model (middle row, 85.4% in Table 6), and the ground truth labels (bottom row). Our method appears to better capture fine local structures (see text for a discussion).

The use of spectral graph convolution combined with cluster pooling in our approach once again provides a non-trivial improvement over pointnet++, achieving state-of-the-art 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 Non-rigid 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: Richly-annotated 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.: Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907 (2016)
  • [7] LeCun, Y., Bottou, L., Bengio, Y., Haffner, P.: Gradient-based 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 Multi-View 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 high-dimensional 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., Learned-Miller, E.: Multi-view 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)
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
124248
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description