PaperlayerView exact revision on arXiv

Source-linked AI summary

Spherical Kernel for Efficient Graph Convolution on 3D Point Clouds

Huan Lei, Naveed Akhtar, Ajmal Mian

arXiv:1909.09287v2cs.CV

TL;DR

Irregular 3D point clouds lack efficient CNN-like operations that preserve useful geometric relationships without expensive edge-wise filter generation. The paper introduces a discrete spherical kernel within graph networks, using volumetric quantization, graph pyramids, and separable convolution. Across classification and semantic-segmentation benchmarks, the resulting networks achieve highly competitive performance while efficiently processing high-resolution point clouds.

  • Problem

    Irregular point clouds make regular-grid CNNs inefficient, while spatial graph networks lack discrete 3D kernels that avoid dynamic edge-wise filter overhead.

  • Method

    The method partitions local spherical neighborhoods into volumetric bins with learnable weights and applies separable spherical convolution in graph pyramids built using range search, farthest point sampling, and pooling/unpooling.

  • Results

    The networks achieve highly competitive classification and semantic-segmentation performance across ModelNet, ShapeNet, RueMonge2014, ScanNet, and S3DIS while efficiently processing high-resolution point clouds.

  • Takeaways & Limitations

    The spherical kernel provides a computationally efficient graph-convolution framework for learning geometric features from large and high-resolution point clouds.

  • Takeaways & Limitations

    On ScanNet, performance is low for picture categories because the method lacks rich 3D structures and often confuses pictures with walls.

Abstract

from arXiv · show

We propose a spherical kernel for efficient graph convolution of 3D point clouds. Our metric-based kernels systematically quantize the local 3D space to identify distinctive geometric relationships in the data. Similar to the regular grid CNN kernels, the spherical kernel maintains translation-invariance and asymmetry properties, where the former guarantees weight sharing among similar local structures in the data and the latter facilitates fine geometric learning. The proposed kernel is applied to graph neural networks without edge-dependent filter generation, making it computationally attractive for large point clouds. In our graph networks, each vertex is associated with a single point location and edges connect the neighborhood points within a defined range. The graph gets coarsened in the network with farthest point sampling. Analogous to the standard CNNs, we define pooling and unpooling operations for our network. We demonstrate the effectiveness of the proposed spherical kernel with graph neural networks for point cloud classification and semantic segmentation using ModelNet, ShapeNet, RueMonge2014, ScanNet and S3DIS datasets. The source code and the trained models can be downloaded from https://github.com/hlei-ziyan/SPH3D-GCN.

1 INTRODUCTION

The paper addresses efficient convolution on irregular 3D point clouds by introducing a discrete spherical kernel and graph-based networks. It extends preliminary work with separable convolution, flexible graph architectures, broader real-world evaluation, and TensorFlow/CUDA support.

  • Irregular point clouds make regular-grid CNNs inefficient, while graph networks face challenges in designing effective convolution, pooling, and unpooling modules.
  • Discrete graph kernels must support translation-invariance and asymmetry while avoiding the computational overhead of dynamically generated edge-wise filters.
  • The proposed spherical kernel partitions local 3D space into volumetric bins, assigns learnable parameters to bins, and preserves translation-, asymmetry-, and permutation-invariance.
  • Graph networks use range search for edges, farthest point sampling for coarsening, and pooling/unpooling modules for vertex-feature resizing.
  • Separable convolution reduces network parameters and computational cost compared with the preliminary design.
  • The extended work reports a 4.2% performance gain over on RueMonge2014 and evaluates ScanNet and S3DIS alongside broader benchmarks.
  • The authors release CUDA implementations of spherical convolution and pooling/unpooling operations compatible with TensorFlow.

2 RELATED WORK

Prior point-cloud methods use pooling, volumetric, tree, or dynamically generated graph operations, but often sacrifice convolutional modeling, scalability, or efficiency. The paper positions discrete metric kernels and flexible graph construction as alternatives.

  • PointNet and PointNet++ process point clouds directly, but rely on pooling rather than convolution to aggregate geometric context.
  • SO-Net, KCNet, Kd-network, and ShapeContextNet use varied representations but do not develop convolutional networks for point clouds.
  • Volumetric 3D-CNN methods historically process low-resolution voxel grids, limiting input resolution even on modern GPUs.
  • PCNN transforms sparse points into a translating tensor whose size is quadratic in point-cloud size, creating substantial computation and memory overhead.
  • Spectral graph networks require fixed or carefully aligned graph structures, making varying point-cloud graphs challenging to process.
  • Spatial graph methods such as ECC and Monte Carlo convolution dynamically generate edge-wise filters with MLPs, incurring computational overhead.
  • The proposed approach uses range search for graph connections and supports both regular and irregular graphs because vertex degrees need not be fixed.

3 DISCRETE CONVOLUTION KERNELS

The SPH3D kernel discretizes spherical neighborhoods into non-uniform volumetric bins, providing a discrete, computationally attractive alternative to continuous filters for graph convolution on point clouds. Its multi-scale granularity and asymmetry preserve geometric detail while using a compact representation.

  • Spherical convolution kernel: Discrete kernels avoid the intermediate coordinate-based computations required by continuous filters, making them computationally attractive for graph convolution.Continuous filters parameterize weights as functions such as h(xj−xi), whereas discrete kernels directly associate neighboring points with predefined weights.
  • Spherical convolution kernel: SPH3D partitions a spherical neighborhood into n × p × q volumetric bins, using uniform azimuth and elevation partitions but non-uniform radial partitions.The neighborhood contains points within radius ρ under the ℓ2 metric; each bin receives a learnable weight, with w0 reserved for self-convolution.
  • Spherical convolution kernel: The spherical kernel maps each neighboring point into spherical coordinates and assigns its corresponding bin weight to compute the target activation.The resulting distribution of points across bins gives different points distinctive influence based on local geometry.
  • Spherical convolution kernel: SPH3D preserves translation-invariance, permutation-invariance, and kernel asymmetry, with asymmetry preventing weight sharing between distinct point pairs.The paper links asymmetry to learning fine geometric details and describes guidelines for partitioning bins so asymmetry is preserved.
  • Comparison to CNN3D kernel: SPH3D uses multi-scale radial granularity to place finer bins near the origin while keeping a compact representation, unlike uniformly sized CNN3D voxels.Uniform CNN3D cells require increased resolution to capture fine detail, causing cubic parameter growth; SPH3D instead keeps the same number of angular bins across radial shells.

4 GRAPH NEURAL NETWORK

The graph neural network builds point-cloud hierarchies through range-based neighborhood construction, farthest point sampling, pooling, and unpooling. Spherical convolutions operate within graph architectures whose coarsening and expansion support classification and semantic segmentation.

  • Graph construction: Graphs connect each point to spatial neighbors found by range search with a specified radius ρ.Neighborhood computations are independent across points, supporting parallel processing on GPUs.
  • Graph coarsening: Farthest Point Sampling coarsens the point graph layer by layer by selecting vertices that are farthest from previously selected samples.Alternating edge construction and coarsening produces the graph hierarchy.
  • Pooling: Pooling transfers features from the original graph to sampled vertices using max or average aggregation over inter-layer neighborhoods.The implementation provides both operations, while experiments use max pooling.
  • Unpooling: Unpooling reverses the graph pyramid and reconstructs higher-resolution features using uniform or distance-weighted interpolation.Experiments use uniform interpolation for computational efficiency.
  • Network architecture: The encoder-decoder applies consecutive spherical convolutions between graph-resolution changes, with skip connections for semantic segmentation and a decoder-free global representation for classification.A toy hierarchy coarsens 12 vertices to 8 and then 4 before expanding back to 12.
  • Implementation: The released TensorFlow package includes CUDA implementations of spherical convolution and pooling/unpooling operations for general graph architectures.The implementation extends the earlier Matconvnet and octree-specialized code.

5 EXPERIMENTS

Experiments evaluate SPH3D-GCN across synthetic object and part datasets and real-world scene segmentation benchmarks, using point-cloud inputs and graph-network configurations tailored to each task. The results report competitive classification and segmentation performance, large-input processing, and efficiency gains over the preliminary method.

  • Datasets and settings: Experiments cover classification and semantic or part segmentation on ModelNet, ShapeNet, RueMonge2014, ScanNet, and S3DIS point clouds.The evaluation includes clean CAD point clouds and large-scale noisy real-world scenes, using coordinates and available color features.
  • Datasets and settings: SPH3D-GCN uses a spherical kernel size of 8 × 2 × 2 + 1, with up to K = 64 neighborhood connections per vertex.Training uses Adam with initial learning rate 0.001 and momentum 0.9; batch sizes are 32 for ModelNet and ShapeNet and 16 otherwise.
  • Datasets and settings: The realistic-dataset network processes 8,192 input points, four times the 2,048 points accepted by PointCNN.RueMonge2014, ScanNet, and S3DIS share one configuration, while ShapeNet part segmentation uses a different configuration.
  • Classification: For ModelNet40, SPH3D-GCN processes 10K input points and uses a 40-category dataset with 9,843/2,468 training/testing samples.The network uses six SPH3D layers and aggregates intermediate max-pooled features into the classifier representation.
  • Classification: For 10K input points, SPH3D-GCN uses 0.78M parameters and runs at 18.1/8.4 ms versus Ψ-CNN's 3.0M parameters and 84.3/34.1 ms.The reported pairs are training/inference times, respectively.
  • Segmentation: On ShapeNet part segmentation, SPH3D-GCN achieves the highest class mIoU of 84.9% and outperforms other approaches on 9 of 16 categories.A single network for all categories obtains instance and class mIoUs of 85.4% and 82.7%, respectively.
  • Segmentation: ScanNet scenes are downsampled with a 3 cm voxel grid and split into 1.5 m × 1.5 m blocks with 0.3 m context padding.The dataset contains 1,513 training scenes and 100 test scenes, with 20 of 40 labels used for evaluation.

6 ABLATION STUDY

The ablation study examines separable versus regular convolution, implementation efficiency, and pooling, interpolation, and augmentation choices. Results favor separable convolution and show that max pooling and augmentation help, while interpolation preferences depend on point-cloud density.

  • Separable convolution: Separable convolution reduces parameters relative to regular convolution through depth-wise and point-wise operations controlled by multiplier λ.For λ ≫ 1, the parameter count of the separable kernel is significantly smaller than that of the regular kernel.
  • Separable convolution: Separable convolution also reduces computation, making it suitable for densely connected graphs representing large-scale point clouds.The study reports fewer multiplications than regular convolution and reductions in both memory and computation.
  • Runtime and memory: Regular-V1 cannot process 16,384-point samples at batch size 16 because of memory requirements.Regular-V2 is memory-friendly but cannot perform classification and segmentation on standard datasets in reasonable time.
  • Pooling, interpolation, and augmentation: Max pooling outperforms average pooling, and data augmentation provides a reasonable performance boost in the Area 5 S3DIS ablation.The baseline uses max pooling, uniform interpolation, and data augmentation.
  • Pooling, interpolation, and augmentation: Weighted interpolation performs better for denser point clouds but worse than uniform interpolation for sparser clouds.The comparison uses point-cloud sizes of 8,192 and 4,096.

7 DISCUSSION

The proposed network is designed for scalable point-cloud processing, using fewer parameters and comparable per-sample runtime while supporting substantially larger inputs than PointCNN.

  • Table 10 compares the proposed technique with PointCNN on computational, memory, and performance requirements for S3DIS.The comparison varies input point size and includes performance for reference.
  • With a batch size of 16 on a 12GB GPU, the network processes up to 65,536 points.This input size is comparable to the number of pixels in a 256 × 256 image.
  • The segmentation network uses 0.4M parameters, compared with 4.4M for PointCNN.The comparison is made alongside memory and runtime measurements.
  • For 2,048, 4,096, and 8,192 points, its per-sample runtime is less than or comparable to PointCNN at 2,048 points.The passage reports both per-batch and per-sample training/testing times for fairness.
  • Although the network supports larger inputs, the authors use 8,192 points for S3DIS in Table 7 to limit processing time.

8 CONCLUSION

The paper concludes that separable spherical convolution within graph-pyramid architectures supports effective feature learning across resolutions and efficient processing of large point clouds.

  • The method combines separable spherical convolution with graph-pyramid architectures built using range search and farthest point sampling.
  • Applying spherical convolution at each graph resolution enables feature learning in larger contexts, analogous to standard CNNs.
  • The spherical kernel partitions occupied space into bins and assigns each bin a learnable parameter during network training.
  • Pooling and unpooling operations downsample and upsample vertex features across graphs at different resolutions.
  • The resulting networks efficiently process high-resolution point clouds and achieve highly competitive classification and semantic-segmentation performance on synthetic and real-world datasets.
Loading 1909.09287v2…