Large-scale 3D point cloud representations via graph inception networks with applications to autonomous driving
Siheng Chen Sufeng. Niu Tian Lan Baoan Liu



Parameter Estimation and Uncertainty Quantification for Systems Biology Models
    William S. Hlavacekcor1
    December 30, 2023
==============================================================================



We present a novel graph-neural-network-based system to effectively represent large-scale 3D point clouds with the applications to autonomous driving. Many previous works studied the representations of 3D point clouds based on two approaches, voxelization, which causes discretization errors and learning, which is hard to capture huge variations in large-scale scenarios.  In this work, we combine voxelization and learning:  we discretize the 3D space into voxels and propose novel graph inception networks to represent 3D points in each voxel. This combination makes the system avoid discretization errors and work for large-scale scenarios. The entire system for large-scale 3D point clouds acts like the blocked discrete cosine transform for 2D images; we thus call it the point cloud neural transform (PCT). We further apply the proposed PCT to represent real-time LiDAR sweeps produced by self-driving cars and the PCT with graph inception networks significantly outperforms its competitors.



3D point cloud representations,  graph deep neural networks, autonomous driving





§ INTRODUCTION


With the growth of 3D sensing technologies, one can now use a large number of 3D points to precisely represent objects' surfaces and surrounding environments. We call those 3D points a 3D point cloud; it has a growing impact on various applications, including autonomous driving, virtual reality and scanning of historical artifacts <cit.>.  In this paper, we consider the setting of autonomous driving. A self-driving car could use multiple sensors to observe the world, such as LiDARs, cameras and RADARs <cit.>. Among those, LiDARs produce two types of 3D point clouds, real-time LiDAR sweeps and high-precision maps. Both include accurate range information, which are critical to perception and localization systems. We consider both types of point clouds large-scale point clouds because they contain a large number of 3D points and record outdoor environments. 



To fully exploit real-time LiDAR sweeps and high-precision maps, we need advanced techniques to handle a series of challenges, including 3D point cloud compression, 3D localization and 3D object detection. A common task shared in those challenges is 3D point cloud representations; that is, representing a 3D point cloud in a compact format, such that it is easy to conduct subsequent processing procedures. For 1D time-series, the basic representation is the Fourier transform; for 2D images, it is the discrete cosine transform and 2D wavelet transform <cit.>; for 3D point clouds, Octree partitions the 3D space adaptively and has been an effective representation tool <cit.>; however, Octree represents a 3D point cloud only in the 3D spatial domain and does not fully exploit shapes formed by 3D points.

To represent large-scale 3D point clouds, we propose a novel graph-neural-network-based system, called the point cloud neural transform (PCT). The PCT includes two phases: voxelization, which adopts the standard Octree-like partition  and splits a large-scale space into a series of small-scale spaces (voxels), and voxel-level encoding, which adopts graph neural networks to capture the complicated underlying distributions of 3D points within each voxel. In the phase of voxel-level encoding, we propose novel graph inception networks, which transform 3D points in a voxel to a low-dimensional feature vector and extend to the translation-invariant graph convolution <cit.> to the 3D space. Because of the two-phase design, PCT can be considered as the 3D counterpart of the windowed Fourier transform for 1D time series and the blocked discrete cosine transform for 2D images. We further apply the PCT to represent real-time LiDAR sweeps collected by self-driving cars and compare it with the standard Octree-based representations. As a general tool, the PCT can be potentially used to 3D compression, 3D object detection and many others in autonomous driving.  The main contributions of the paper include: (i) we propose the PCT to represent large-scale 3D point clouds; (ii) we propose novel graph inception networks to implement the voxel-level encoding;  (iii) the proposed PCT is applied to represent real-time LiDAR sweeps produced by self-driving cars and outperforms its competitors.

Related works
3D point cloud processing has become important in various 3D imaging and autonomous systems. The topic broadly includes
  compression <cit.>, denoising <cit.>,  surface  reconstruction <cit.>, feature  extraction <cit.>, localization <cit.>, 3D object detection <cit.> and many others. Here we consider 3D point cloud representations, which mainly based on three approaches, including resampling, voxelization and learning. Resampling represents a 3D point cloud by selecting a subset of 3D points <cit.>. In many applications, resampling can enhance key geometry information and make subsequent processing both cheaper and more accurate <cit.>. Voxelization represents a 3D point cloud by partitioning the 3D space into a series of voxels and use the corresponding voxel center as the proxy for each 3D point, such as regular voxels <cit.>  and Octree <cit.>; however, they all suffer from discretization errors.  Learning-based models can also be trained to capture the underlying distribution of 3D points. For example, <cit.>
proposed a probabilistic generative model to model the distribution of 3D point clouds; however, such model is inefficient in inferring parameters;  <cit.> proposed a deep  autoencoder  that directly handles 3D point clouds;  <cit.> introduced a 2D lattice to help decoding.


§ METHODOLOGY


Similarly to many standard representation problems, the overall goal is to use a low-dimensional feature vector to represent a large-scale 3D point cloud; however, a large-scale 3D point cloud has its own challenges:
(i) variations. 3D points captured in a outdoor environment have huge variations, while the available training data are limited. The representations need to learn rich variations from limited amount of 3D point clouds; (ii) irregularity. 3D points are irregularly and sparsely scattered in the 3D space. The representations need to go beyond  the regular lattices and capture irregular and nonuniform distributions of 3D points; (iii) invariances and equivalences. The representations need to promote basic geometric properties, including permutation-invariance, translation-invariance, scale-equivalent and rotation-equivalence. We propose the point cloud neural transform (PCT) to handle these challenges.



Point cloud neural transform
To handle large variations, we propose a two-stage framework. In the first stage, we partition the 3D space into a series of voxels; in the second stage,  we encode 3D points in each voxel to a few codes; see the entire system in Figure <ref>. The intuitions are (i) since the representations in each individual voxel is much more constraint, we are able to specifically and effectively  learn local shapes and patterns; and (ii) since each 3D point cloud produces multiple voxels, we are able to increase the number of training data and potentially train strong voxel-level representations. This two-stage representation is similar to the windowed Fourier transform for 1D time series and the blocked discrete cosine transform for 2D images. To handle irregularity, we propose graph inception networks, which use a graph to capture the underlying distribution of 3D points. We treat 3D points as nodes and connects each point to its neighboring points to formulate a spatial graph. The edge weights reflect irregular and nonuniform distribution of 3D points.  The graph inception networks also ensure permutation and translation-invariances. To handle equivalences, we propose normalization networks to ensure scale and rotation-equivalences.


Mathematically, let ∈^N × 3 be the matrix representation of this 3D point cloud, whose ith row _i = [x_i, y_i, z_i] ∈^3 represents the 3D coordinate of the ith point. The overall procedures of the PCT are



    {^(i)}_i=1^M     =    partition( ),
    
    ^̧(i)    =    Ψ_w ( ^(i)) ∈^ℓ,
    
    ^(i)    =    Φ_w ( ^̧(i))
    
        =     synthesis(  {^(i)}_i=1^M ).


In (<ref>), we partition a 3D space into a series of nonoverlapping voxels based on the spatial structure; correspondingly, a large-scale 3D point cloud is partitioned into a series of small-scale 3D point clouds, where ^(i) represents the 3D point cloud in the ith voxel. In (<ref>), we encode the 3D points in each voxel to a low-dimensional feature vector. In (<ref>), we decode a low-dimensional feature vector back to the 3D coordinates. In (<ref>), we concatenate the 3D coordinates in all the voxels and reconstruct a 3D point cloud.  

Partition
We simply partition the 3D space into equally-spaced nonoverlapping voxels from each of three dimensions. Let each voxel is of size H, W, D along the X, Y, Z axes respectively.  The (h, w, d)th voxel represents a 3D space,

    _h,w, d =  { (x, y, z)  |      (h-1) H   ≤ x < h H,    
        (w-1) W ≤ y < w W,    
        (d - 1 )D  ≤ z < d D }.

The points inside _h,w, d form a point cloud  _h,w, d. The partition (<ref>) contributes to the implement of (<ref>) and (<ref>). The PCT is also compatible to multiscale voxels, such as Octree.

Graph inception networks as voxel-level encoder  We use the graph inception networks (GIN) to implement the voxel-level encoding (<ref>). The operations and weights of GIN are shared across all the voxels. To handle the irregularity, we introduce a spatial graph to capture the distribution of 3D points. For the simplicity, here we consider a K-nearest-neighbor graph, where each 3D points connects to its K closest 3D points. We denote the neighboring set for of i-th point as ^(K)_i. We then use an adjacency matrix ^(K)∈^n × n to reflect the pairwise connectivity, where n is the number of 3D points in the corresponding voxel. The edge weight between two points _i and _j is

    ^(K)_i,j = 
      {[ e^- _i - _j _2^2 ,         j ∈^(K)_i;;                 0,                  . ].


A key issue raised by a graph-based approach is how to choose the number of neighbors K. Especially, the point density could vary a lot in various voxels. A fixed K could either capture  limited information or irrelevant information. To solve this issue, we adopt an inceptive-like structure, where we construct a series of K-nearest-neighbor graphs with multiple K values. This K value is equivalent to the kernel size of the classical 2D convolution: a larger K indicates a larger reception field.  We thus consider a graph inception convolution to extract features from 3D points. Let _i ∈^ℓ be the features of the i-th point (the initial feature is _i ∈^3). The response is

    '_i     =      g_w( [ ^(k)_i ]_k ∈𝒦)
     
        =      g_w( [ ∑_j ∈^(k)_i h_w( ^(k)_i,j,  _j - _i )   ]_k ∈𝒦) ∈^ℓ',

where h_w (·) is a standard multilayer perceptron with parameters w, 𝒦 is a set of K values, [·]_k ∈𝒦 denotes the concatenation and g_w(·) is the inception network that combine responses from multiple graph convolutions. The edge weight ^(K)_i,j and the difference _j - _i  reflects the relative difference of two points in the original 3D space and the feature space, respectively.  The corresponding matrix representation is

    ' =  conv_gin  ([ ^(k)]_k ∈𝒦 , ) ∈^n ×ℓ',

where ∈^n ×ℓ is the input feature matrix with the ith row vector _i in (<ref>) and ' is the output feature matrix with the ith row vector '_i.  Since we only consider relative differences, the graph convolution is translation-invariant; that is,

    conv_gin  ( +  1_n ^T)  =   conv_gin  (),

holds for arbitrary ∈^ℓ, where 1_n ∈^n is a all-one vector. We call (<ref>) graph inception convolution; see Figure <ref>. 


After a series of graph inception convolution, we obtain deep point-wise features. To produce voxel-level features, we average the features across all the points.  Let ∈^n ×ℓ be the final point-wise feature matrix, =   agg_mean () =   ^T  1_n/n∈^ℓ. Since we aggregate along the point dimension, the final voxel-level features are permutation invariant. Comparing to the max-aggregation <cit.>, the mean-aggregation allows all points contributes to the code, which preserves richer information for reconstruction. 

The voxel-level encoder Ψ_w(·) is thus a combination of graph inception convolutions and a mean aggregation. For example, the encoder of the ith voxel with a single layer graph inception convolution is

    ^̧(i) =  Ψ_w(^(i)) =   agg_mean( ρ(  conv_gin  ([ ^(k)]_k ∈𝒦 , ^(i)) ) ),

where ρ(·) is the nonlinear activation, such as ReLU. In our experiments, we use 3-layer graph inception convolutions.

Graph inception convolution is a 3D convolution
Here we consider graph inception convolution from a different perspective. We can represent each 3D point as a delta function in the 3D space. A 3D point cloud is then a train of delta functions; that is,

    () = ∑_jδ ( - _j),

where , _j ∈^3. Let a 3D convolution be h(·): ^3 →. The response is then

    y()     =    ∫_τ h( - τ) (τ) d τ
        =    ∫_τ h( - τ) ∑_jδ (τ - _j) d τ
        =    ∑_j h( - _j).

This is equivalent to the graph inception convolution in (<ref>). In other words, we aim to learn a kernel function h(·) through neural networks. The number of neighbors in the graph reflects the size of the reception field of a kernel function. This kernel function is learnt in the 3D continuous space and operates in the graph domain. The nature of a 3D convolution indicates the properties of translation invariance and weight sharing in the 3D space; it also ensures that the same kernel function works for various graph topologies. Once the neighboring points form a same shape pattern, we will construct the same local graph topology and obtain the same response.

Fully connected layers as voxel-level decoder
To design a voxel-level decoder Φ_w(·) in (<ref>), we cannot use graph-based approaches, because the only information that decoder can access is the code given by the encoder and the graph information no longer exists. We consider two approaches to design a voxel-level decoder. The first approach is based on fully-connected layers, which use more trainable parameters and work better in practice <cit.>; the second approach is based on FoldingNet <cit.>, which considers that points are warped from a 2D map. 




Normalization networks
To handle equivalences, the voxel-level representation also needs to capture the scale and rotation variances. Here we use normalization networks to explicitly learn the scale and rotation. Before we feed the points to the voxel-level encoder, we use multilayer perceptions to lean the 3 × 1 scale vector and the 3 × 3 rotation matrix.  We keep those geometric information to the code and apply to the reconstructed points after the decoder. In this way,
we promote scale and rotation equivalences:  the 3D point cloud in each voxel is distributed in the unit space and has a similar orientation. The voxel-level encoder and decoder can thus focus on learning local shapes.

Training implementations
The encoder Φ_w (·) and decoder Ψ_w (·) is implemented by using deep-neural-networks with trainable weights. To train the networks, we consider the following
optimization problem:

    O(ℓ) =     minimize_Ψ_w ( ·), Φ_w ( ·)   ∑_i=1^M  CD(^(i), ^(i)),
    
        subject to    =̧Ψ_w ( ) ,   =  Φ_w ( ),
    
           dim()̧≤ℓ,

where  CD (, )  = ∑_j=1^Nmin_i ∈{1,  2, ⋯ N }_j - _i _2^2 /N  + ∑_i=1^Nmin_j ∈{1,  2, ⋯ N }_i  - _j  _2^2/N is the Chamfer distance <cit.>. An effective representation should be ℓ M ≪ 3N, O(ℓ) → 0. 




§ EXPERIMENTAL RESULTS


Dataset We validate the proposed PCT in a standard autonomous-driving dataset,  KITTI <cit.>, which has been recorded from a moving platform while driving in and around Karlsruhe. Real-time LiDAR sweeps  are collected by a Velodyne HDL-64E rotating 3D laser scanner, with 10 Hz, 64 beams, 0.09 degree angular resolution, around 1.3 million points/second, 360 horizontal, 26.8 vertical field of view.

Experimental Setup  For each real-time sweep in KITTI, we partition the space into voxels with the size of 1 × 1 × 10 meter^3. We train 400 LiDAR sweeps and test 100 LiDAR sweeps. We select training sweeps and testing sweeps from separate logsets to avoid data snooping. For GIN, 𝒦 = {1, 4, 8, 16}. To evaluate the performance, we compare the reconstruction based on the codes  to the original LiDAR sweep.


Results We validate the proposed PCT from two aspects. In the ablation study, we add each component at a time to validate the effectiveness of each component; in the ratio-distortion analysis, we compare the PCT with other competitors. Due to the limited space, we only show the quantitative results for KITTI. Table <ref>
shows the ablation study in the dataset of KITTI. For the encoder, we consider three components: graph inception convolution (inception), mean-aggregation  (mean-agg), normalization (norm).  When the graph inception convolution is not checked, we consider a single K=1; when the mean-aggregation is not checked, we consider the maximum-aggregation; when the normalization is not checked, we do not use normalization networks. For the decoder, we consider two components: fully-connected layers and FoldingNet. We use five metrics to evaluate the performance: earth-mover distance (EMD), Chamfer distance (CD), mean square error (MSE), mean and variance <cit.>. For MSE, we consider the difference between each original 3D point and its closest correspondence in the reconstruction. For all the metrics, lower values indicate better results. We see that  each component of graph inception convolution improves the reconstruction performance; fully-connected layers consistently outperform FoldingNet.

Figure <ref> shows the mean square error as a function of compression ratios. We vary the code length in each voxel as 9, 18, 36, 72, leading to various compression ratios. The x-axis is the compression ratio; the y-axis is the logarithm-scale mean square error.  We consider give comparison methods. Uniform resampling randomly selects a few 3D points and use this subset to represent the overall 3D point clouds. We consider resampling based on either  the entire 3D spatial space (G-Random) or the voxels (V-Random). For voxel-based resampling, we select the same number of 3D points in each voxel to promote spatial uniformity; kmeans-based representation (V-Kmeans) adaptively selects cluster centers in each voxel and we select the same number of 3D points in each voxel. Kmeans is computationally expensive and cannot afford global optimization.  These three approaches preserve information based on the spatial domain. We also consider two learning-based approaches to implement the voxel-level encoding in the framework of PCT. PointNet encodes the 3D points in each voxel into a few features by using deep neural networks <cit.>; dynamic graph convolutional neural networks (DGCNN) are the extension of PointNet by introducing a graph structure <cit.>. Compared to DGCNN, GIN ensures translation invariance and adopts inception structures, mean-aggregation and the normalization networks. We ensure all methods preserves the same number of data from the original sweeps. We see that PCT with GIN outperforms its competitors.  The advantage of the PCT is to transform the 3D points from the spatial domain to a feature domain, which is similar to the mechanism of the classical Fourier transform.



§ CONCLUSIONS

We propose the PCT to provide compact representations for large-scale 3D point clouds. The PCT includes two phases: 3D partition and voxel-level representations, which makes it acts like the blocked discrete cosine transform for 2D images. We propose GIN to improve voxel-level representations. The proposed PCT is applied to represent real-time LiDAR sweeps and significantly outperforms its competitors.




IEEEbib


