Deep Unsupervised Learning of 3D Point Clouds via Graph Topology Inference and Filtering

TL;DR

This paper introduces a novel deep autoencoder for 3D point clouds that infers graph topology and filters it to improve unsupervised representation, avoiding discretization errors of voxel-based methods.

Contribution

It presents a new decoder with graph topology inference and filtering modules, enabling raw point cloud processing without discretization, and demonstrates superior performance in reconstruction and classification tasks.

Findings

Outperforms state-of-the-art methods in reconstruction and classification

Successfully infers graph topology without supervision

Graph filtering refines reconstructions for better accuracy

Abstract

We propose a deep autoencoder with graph topology inference and filtering to achieve compact representations of unorganized 3D point clouds in an unsupervised manner. Many previous works discretize 3D points to voxels and then use lattice-based methods to process and learn 3D spatial information; however, this leads to inevitable discretization errors. In this work, we handle raw 3D points without such compromise. The proposed networks follow the autoencoder framework with a focus on designing the decoder. The encoder adopts similar architectures as in PointNet. The decoder involves three novel modules. The folding module folds a canonical 2D lattice to the underlying surface of a 3D point cloud, achieving coarse reconstruction; the graph-topology-inference module learns a graph topology to represent pairwise relationships between 3D points, pushing the latent code to preserve both coordinates and pairwise relationships of points in 3D point clouds; and the graph-filtering module couples the above two modules, refining the coarse reconstruction through a learnt graph topology to obtain the final reconstruction. The proposed decoder leverages a learnable graph topology to push the codeword to preserve representative features and further improve the unsupervised-learning performance. We further provide theoretical analyses of the proposed architecture. In the experiments, we validate the proposed networks in three tasks, including 3D point cloud reconstruction, visualization, and transfer classification. The experimental results show that (1) the proposed networks outperform the state-of-the-art methods in various tasks; (2) a graph topology can be inferred as auxiliary information without specific supervision on graph topology inference; and (3) graph filtering refines the reconstruction, leading to better performances.

Tables

Table 1. TABLE I: Graph filtering improves the reconstruction of a 3D point cloud. A graph filter learnt through the graph-topology-inference module is used to refine the coarse reconstructions produced by the folding module (left column) and obtain the final reconstructions (right column). We select one 3D point (in red) and trace the evolvement of its neighbors in the learnt graph topology (in cyan) during the training process. Graphs guide the networks to preserves details.

	2D lattice	Airplane
Epoch	Coarse reconstruction	Refined reconstruction
	before graph filtering	after graph filtering
0
10
100
300

Table 2. TABLE II: Only training the folding module cannot reconstruct torus with high-order genus. The first column shows the original point clouds sampled from tori generated in MeshLab [ 2 ] ; the second column shows the reconstructions when we only train the folding module; the third column shows the reconstructions when we train all three modules together. The color associated with each point indicates the correspondence between a node in the 2D lattice and a 3D point. The smoothness of the color transition reflects the difficulty of the folding process. The reconstruction based on the folding mechanism only cannot capture the holes and the folding process is difficult to glue surfaces smoothly.

Input	Folding module only	Overall

Table 3. TABLE III: Graph filtering lowers reconstruction losses. The reconstruction loss is measured by the augmented Chamfer distance. The overall networks achieves better reconstruction performance than the folding module only. All three models are trained by the same setting in an end-to-end fashion and use the same number of training parameters on the dataset of ShapeNetCore.

Category	Airplane	Bag	Cap	Car	Chair	Earphone	Guitar	Knife	# winner
# shape	2299	68	50	817	3362	63	709	357
3DCapsNet (loss: $\times$ 1e-2)	2.48	5.33	5.46	3.79	3.81	4.68	2.04	2.17	0
AtlasNet (loss: $\times$ 1e-2)	2.39	4.33	4.17	3.88	3.58	5.13	1.96	1.75	0
Folding module only (loss: $\times$ 1e-2)	2.55	4.07	4.04	3.80	3.63	4.92	1.62	1.66	0
With graph-adjacency-based filtering (9) (loss: $\times$ 1e-2)	2.34	3.91	3.91	3.83	3.46	4.28	1.58	1.70	5
With graph-Laplacian-based filtering (11) (loss: $\times$ 1e-2)	2.38	4.06	4.53	3.72	3.39	4.77	1.73	1.49	3
Category	Lamp	Laptop	Motorbike	Mug	Pistol	Rocket	Skateboard	Table	# winner
# shape	1404	407	176	168	253	58	137	4683
3DCapsNet (loss: $\times$ 1e-2)	3.51	2.96	3.91	4.86	2.67	2.21	3.09	3.44	0
AtlasNet (loss: $\times$ 1e-2)	3.55	2.98	4.11	5.07	2.82	2.31	2.60	3.58	0
Folding module only (loss: $\times$ 1e-2)	3.47	2.90	4.03	4.94	2.75	2.28	2.48	3.48	0
With graph-adjacency-based filtering (9) (loss: $\times$ 1e-2)	3.45	2.94	3.88	4.60	2.74	2.51	2.63	3.30	1
With graph-Laplacian-based filtering (11) (loss: $\times$ 1e-2)	3.43	2.84	3.69	5.29	2.64	2.18	2.39	3.05	7

Table 4. TABLE IV: Visualizing the evolvement of reconstructions and learnt graph topologies during the training process (based on the graph-adjacency-matrix based filtering ( 9 )). In the Before graph filtering columns, we show the coarse reconstructions produced by the folding module, which is the intermediate output; in the After graph filtering columns, we show the reconstructions after the graph-filtering module, which is the final output. We put supervision only to the final output. We choose one point in the 2D lattice and record its neighboring points in the training process. The chosen point is colored in red and its neighboring points are colored in cyan. The chosen point and its neighboring points evolve to form an engine, which is a fine detail. Comparing to the reconstructed point clouds in the Before graph filtering columns, the reconstructed point clouds in the After graph filtering columns preserve more fine details, such as engines, tails, nodes, and wing tips; see the improvement on fine-detailed classification in Table  VIII .

Epoch	Swept wings no engines		Swept wings two engines		Straight wings two engines
	Before graph filtering	After graph filtering	Before graph filtering	After graph filtering	Before graph filtering	After graph filtering
Input
0
5
300

Table 5. TABLE V: Visualizing the evolvement of reconstructions and learnt graph topologies during the training process (based on the graph-Laplacian-matrix based filtering ( 11 )). In the Before graph filtering columns, we show the coarse reconstructions produced by the folding module, which is the intermediate output; in the After graph filtering columns, we show the reconstructions after the graph-filtering module, which is the final output. We put supervision only to the final output. We choose one point in the 2D lattice and record its neighboring points in the training process. The chosen point is colored in red and its neighboring points are colored in cyan. The chosen point and its neighboring points evolve to form an engine, which is a fine detail. Comparing to the reconstructed point clouds in the Before graph filtering columns, the reconstructed point clouds in the After graph filtering columns preserve more fine details, such as engines, tails, nodes, and wing tips; see the improvement on fine-detailed classification in Table  VIII .

Epoch	Swept wings no engines		Swept wings two engines		Straight wings two engines
	Before graph filtering	After graph filtering	Before graph filtering	After graph filtering	Before graph filtering	After graph filtering
Input
0
5
300

Table 6. TABLE VI: Comparison of classification accuracies on ModelNet10 and ModelNet40 . The proposed networks achieve the best classification accuracy in ModelNet10. VIP-GAN achieves the best performance in ModelNet40, but it uses a longer code and uses images as inputs. All methods use the same transfer-classification routine.

Method	Modality	# code	MN40	MN10
SPH [16]	Voxels	544	68.20	79.80
LFD [17]	Voxels	4700	75.50	79.90
T-L Network [18]	Voxels	-	74.40	-
VConv-DAE [19]	Voxels	6912	75.50	80.50
3D-GAN [11]	Voxels	7168	83.30	91.00
VIP-GAN [21]	Images	4096	91.98	94.05
Latent-GAN [12]	Points	512	85.70	95.40
Our (Folding module only)	Points	512	88.40	94.40
Our (with fixed 2D lattice)	Points	512	84.27	92.11
Our (PointNet++ with adjacency (9))	Points	512	89.63	95.69
Our (PointNet++ with Laplacian (11))	Points	512	89.65	95.91
Our (with graph-adjacency (9))	Points	512	89.67	95.63
Our (with graph-Laplacian (11))	Points	512	89.55	95.93

Table 7. TABLE VII: Dataset with subcategory labels . We categorize airplanes, beds, chairs and monitors into 9 9 9 , 8 8 8 , 16 16 16 , 9 9 9 classes, respectively. This Dataset could be used for fine-grained classification, visualization, clustering, and many other tasks.

Airplane ( Train/Test : 551/142 , Number of classes: 9 )
Swept wings	Swept wings	Swept wings	Straight wings	Straight wings
back engines	two engines	four engines	two engines	four engines
Bed ( Train/Test : 433/112 , Number of classes: 8 )
Boardless	Front board	Front board	Double boards	Double boards
with pillows	no pillows	with pillows	no pillows	with pillows
Chair ( Train/Test : 707/187 , Number of classes: 16 )
Cantilever	Folding chair	Swivel chair	Armless chair	Wing chair
Monitor ( Train/Test : 400/104 , Number of classes: 9)
V-shape base	Half-circle base	Half-ring base	Baseless	Rectangular base

Table 8. TABLE VIII: Comparison of transfer classification accuracies on the subcategory dataset. Proposed networks significantly outperform the other unsupervised model and outperforms the supervised model, PointNet, in three categories. S stands for supervised model; GA stands for the graph-adjacency-matrix-based filtering ( 9 ); GL stands for the graph-Laplacian-matrix-based filtering ( 11 ).

Category	Airplane	Bed	Chair	Monitor	S?
# subcategories	9	8	16	9	-
PointNet (Softmax)	81.69	79.46	62.57	72.12	Y
PointNet (Hinge loss)	78.35	77.40	67.39	71.88	Y
LatentGAN	13.38	51.78	48.13	42.31	N
AtlasNet	83.57	72.23	78.54	71.69	N
3DCapsNet	83.61	72.84	78.59	75.23	N
Our (Folding only)	83.29	73.21	77.05	72.12	N
Our (with GA)	83.80	75.00	81.28	76.92	N
Our (with GL)	83.97	76.65	81.23	75.43	N

Table 9. TABLE IX: Visualization of graph spectral information for reconstructed 3D point cloud. The first column shows the eigenvalues of the graph adjacency/Laplacian matrix obtained in the graph-topology-inference module ( 10 ). The left side of the x 𝑥 x -axis indicates lower frequency. From the second column to the fifth column, the plots show the reconstructed point clouds colored with the first four eigenvectors of the graph adjacency/Laplacian matrix. As eigenvalues increase, the corresponding eigenvectors represent a higher frequency and segment the point clouds in a finer way.

graph-filter	Eigenvalues	1st eigenvector	2nd eigenvector	3rd eigenvector
graph-adjacency
graph-Laplacian

Table 10. TABLE X: Reconstruction loss as a function of the number of reconstructed points across eight categories in the ShapeNetCore dataset. Increasing the number of reconstructed points leads to smaller reconstruction losses.

	Airplane	Car	Chair	Guitar	Knife	Lamp	Laptop	Table
1024 (loss: $\times$ 1e-2)	3.95	5.73	6.01	2.28	2.91	5.93	5.02	5.37
2025 (loss: $\times$ 1e-2)	2.34	3.83	3.46	1.58	1.70	3.45	2.94	3.30
4096 (loss: $\times$ 1e-2)	1.77	2.36	2.49	0.97	1.05	2.71	2.09	2.66

Table 11. TABLE XI: Classification accuracies as a function of the number of reconstructed points in the datasets of ModelNet10 and ModelNet40 . Increasing the number of reconstructed points does not necessarily improve the classification performances.

Value of $M$	Modality	# code	MN40	MN10
1024	Points	512	83.26	90.48
2048	Points	512	89.67	95.63
4096	Points	512	87.85	93.41

Table 12. TABLE XII: Classification comparison between the Chamfer distance (CD) and the augmented Chamfer distance (AugCD) on ModelNet10 and ModelNet40 . The proposed networks trained with the AugCD achieve better classification performances in the ones trained with the CD.

Method	MN40	MN10
Folding module only (CD)	86.32	92.11
Folding module only (AugCD)	88.40	94.40
Folding with graph-adjacency (CD)	88.24	94.10
Folding with graph-adjacency (AugCD)	89.67	95.63
Folding with graph-Laplacian (CD)	88.27	94.44
Folding with graph-Laplacian (AugCD)	89.55	95.93

Table 13. TABLE XIII: Classification comparison between the Chamfer distance (CD) and the augmented Chamfer distance (AugCD) on the subcategory dataset. The proposed networks trained with the AugCD significantly and consistently outperform the networks with the CD. GA stands for the graph-adjacency-matrix-based filtering; GL stands for the graph-Laplacian-matrix-based filtering.

Category	Airplane	Bed	Chair	Monitor
# subcategories	9	8	16	9
Folding module only (CD)	80.15	71.20	71.93	68.82
Folding module only (AugCD)	83.29	73.21	77.05	72.12
Folding with GA (CD)	81.20	73.33	77.86	74.28
Folding with GA (AugCD)	83.80	75.00	81.28	76.92
Folding with GL (CD)	82.13	73.65	77.28	73.75
Folding with GL (AugCD)	83.97	76.65	81.23	75.43

Table 14. TABLE XIV: Tradeoffs between spatial smoothness and graph smoothness (based on the graph-adjacency-matrix-based filtering). We plot the reconstructed point clouds as a function of α 𝛼 \alpha ; that is, X α = ( ( 1 − α ) ​ I + α ​ A ) ​ X ′ subscript X 𝛼 1 𝛼 I 𝛼 A superscript X ′ \operatorname{X}_{\alpha}=\left((1-\alpha)\operatorname{I}+\alpha\operatorname{A}\right)\operatorname{X}^{\prime} , where X ′ superscript X ′ \operatorname{X}^{\prime} is the coarse reconstruction produced by the folding module. When α = 0 𝛼 0 \alpha=0 , the reconstruction only depends on the folding module, which promotes the spatial smoothness and implies the dimension of the underlying surface is close to 2 2 2 ; when α = 1 𝛼 1 \alpha=1 , the reconstruction promotes the graph smoothness and implies the dimension of the underlying surface is close to 3 3 3 . Here we use graph Haar filter, which is equivalent to α = 0.5 𝛼 0.5 \alpha=0.5 ; it combines both spatial and graph smoothness. The intrinsic dimension of underlying surface is around 2.5 2.5 2.5   [ 72 ] .

Original	Spatial smoothness		Output		Graph smoothness
	$\alpha =0$	$\alpha =0.25$	$\alpha =0.5$	$\alpha =0.75$	$\alpha =1$

Table 15. TABLE XV: Tradeoffs between spatial smoothness and graph smoothness (based on the graph-Laplacian-matrix-based filtering). We plot the reconstructed point clouds as a function of α 𝛼 \alpha ; that is, X α = ( μ ​ I + ℒ ) − 2 ​ α ​ X ′ subscript X 𝛼 superscript 𝜇 I ℒ 2 𝛼 superscript X ′ \operatorname{X}_{\alpha}=\left(\mu\operatorname{I}+\mathcal{L}\right)^{-2\alpha}\operatorname{X}^{\prime} , where X ′ superscript X ′ \operatorname{X}^{\prime} is the coarse reconstruction produced by the folding module. When α = 0 𝛼 0 \alpha=0 , the reconstruction only depends on the folding module, which promotes the spatial smoothness, but loses some details; when α = 1 𝛼 1 \alpha=1 , the reconstruction promotes the graph smoothness, but less meaningful in the 3D space. Here the graph-Laplacian-matrix based filter ( 11 ) is equivalent to α = 0.5 𝛼 0.5 \alpha=0.5 ; it combines both spatial and graph smoothness.

Original	Spatial smoothness		Output		Graph smoothness
	$\alpha =0$	$\alpha =0.25$	$\alpha =0.5$	$\alpha =0.75$	$\alpha =1$

Equations

$$X=\left[\begin{array}{cccc}{\mathbf{s}}_1& {\mathbf{s}}_2& \dots & {\mathbf{s}}_K\end{array}\right]={\left[\begin{array}{cccc}{\mathbf{x}}_1& {\mathbf{x}}_2& \dots & {\mathbf{x}}_N\end{array}\right]}^T\in {\mathbb{R}}^{N\times K},$$

$$\mathbf{c}=\Psi \left(\mathcal{S}\right)\in {\mathbb{R}}^C,$$

$$\hat{\mathcal{S}}=\Phi \left(\mathbf{c}\right)\in {\mathbb{R}}^{M\times 3}.$$

$$\underset{\Psi (\cdot ),\Phi (\cdot )}{\min }$$

$$\mathrm{subject}\mathrm{to}$$

$$d(\mathcal{S},\hat{\mathcal{S}})$$

$${\mathbf{c}}_i$$

$${\mathbf{c}}^{\prime }$$

$$\mathbf{c}$$

$${\mathbf{x}}_i^{\prime }=f_{\mathbf{c}}({\mathbf{z}}_i)=\mathrm{MLP}\left(\left[\mathrm{MLP}\left(\left[{\mathbf{z}}_i,\mathbf{c}\right]\right),\mathbf{c}\right]\right)\in {\mathbb{R}}^3,$$

$$A_{ij}^0=\{\begin{array}{ll}\frac{1}{Z_i}\exp (-\frac{\Vert {\mathbf{z}}_i-{\mathbf{z}}_j{\Vert }_2^2}{2{\sigma }^2})& \text{if }{\mathbf{z}}_j\in {\mathcal{N}}_i,\\ 0& \text{otherwise},\end{array}$$

$$A_i$$

$$h(A)=\sum _{\ell =0}^{L-1}{h}_{\ell }{A}^{\ell }\in {\mathbb{R}}^{M\times M},$$

$$\hat{X}=\frac{1}{2}(I+A)X^{\prime }\in {\mathbb{R}}^{M\times 3},$$

$$\mathcal{L}=V\Sigma V^T=V\left[\begin{array}{cccc}{\lambda }_1& 0& \cdots & 0\\ 0& {\lambda }_2& \cdots & 0\\ ⋮& ⋮& \ddots & ⋮\\ 0& 0& \cdots & {\lambda }_M\end{array}\right]V^T,$$

$$h(\mathcal{L})={\left(\mu I+\mathcal{L}\right)}^{-1}\in {\mathbb{R}}^{M\times M},$$

$$h(\mathcal{L})=V\left[\begin{array}{cccc}\frac{1}{\mu }& 0& \cdots & 0\\ 0& \frac{1}{\mu +{\lambda }_2}& \cdots & 0\\ ⋮& ⋮& \ddots & ⋮\\ 0& 0& \cdots & \frac{1}{\mu +{\lambda }_M}\end{array}\right]V^T.$$

$$d\left(\mathcal{S},\Phi \left(\Psi (\mathcal{S})\right)\right)\le \frac{\sqrt{3}}{2\sqrt[3]{C}}\approx \frac{0.866}{\sqrt[3]{C}},\mathrm{for}\mathrm{all}\mathcal{S}\in {\mathcal{X}}_N,$$

$${\mathcal{V}}_{i,j,k}=\{(x,y,z)|(i-1)/K\le$$

$$(j-1)/K\le$$

$$(k-1)/K\le$$

$$\mathbf{c}=\Psi (\mathcal{S})=[{\Psi }_{1,1,1}(\mathcal{S}),\cdots ,{\Psi }_{K,K,K}(\mathcal{S})]\in {\mathbb{R}}^C,$$

$$\hat{\mathcal{S}}=\Phi (\mathbf{c})=\{{\mathbf{q}}_{i,j,k}\in [0,1{]}^3|{\mathbf{c}}_{\ell }={\Psi }_{i,j,k}(\mathcal{S})=1\},$$

$$d(\mathcal{S},\hat{\mathcal{S}})$$

$${\mathbf{F}}_2={\mathbf{I}}_{K^3}\otimes [1,0,0,0{]}^{\top },$$

$${\mathbf{b}}_2=[{\mathbf{b}}_{2,1},{\mathbf{b}}_{2,2},\dots ,{\mathbf{b}}_{2,K^3}{]}^{\top },$$

$${\mathbf{\theta }}_3=[{\mathbf{\theta }}_{3,1},{\mathbf{\theta }}_{3,2},{\mathbf{\theta }}_{3,3},\dots ,{\mathbf{\theta }}_{3,K^3},{\mathbf{x}}_0,{\mathbf{u}}_m],$$

$${\mathbf{\theta }}_5=[f_1({\Psi }_{i,j,k}(\mathcal{S})),{\mathbf{q}}_{i,j,k},{\mathbf{x}}_0],$$

$${\Phi }_Z(\mathbf{c})=\{f({\mathbf{z}}_{\ell })\in [0,1{]}^3|{\mathbf{c}}_{\ell }=1,{\mathbf{z}}_{\ell }\in Z,|\mathbf{c}|=|Z|=C\},$$

$$\underset{{\delta }_i=\{0,1\},{\delta }_j=\{0,1\},{\delta }_k=\{0,1\}}{\min }{\Psi }_{i+{\delta }_i,j+{\delta }_j,k+{\delta }_k}(\mathcal{S})\le$$

$${\Psi }_{i,j,k}(\mathcal{S})\le \underset{{\delta }_i=\{0,1\},{\delta }_j=\{0,1\},{\delta }_k=\{0,1\}}{\max }{\Psi }_{i+{\delta }_i,j+{\delta }_j,k+{\delta }_k}(\mathcal{S}).$$

$$d\left(\mathcal{S},h\left(\Gamma \left(\Psi (\mathcal{S})\right)\right)\right)\le \frac{1}{\sqrt[3]{2C}}\approx \frac{0.7937}{\sqrt[3]{C}},\mathrm{for}\mathrm{all}\mathcal{S}\in {\tilde{\mathcal{X}}}_N,$$

$${\mathrm{DTV}}_{i,j}\left(X\right)$$

Full text

I Introduction

3D point clouds are discrete representations of continuous surfaces in the 3D space, which have be widely used in autonomous driving, industrial robotics, augmented reality and many others [3]. Based on the storage order and spatial connectivity among 3D points, we distinguish between two types of point clouds: organized point clouds, such as those collected by camera-like 3D sensors or 3D laser scanners and arranged on a lattice [4], and unorganized point clouds, such as those that, due to their complex structure, are scanned from multiple viewpoints and are subsequently merged leading to the loss of ordering of indices [5]. Organized point clouds are easier to process as the underlying lattice produce natural spatial connectivity and reflect the sensing order. For generality, we consider unorganized point clouds in this paper. Different from 1D speech data or 2D images, which are associated with regular lattices [6], unorganized 3D point clouds are usually sparsely and irregularly scattered in the 3D space; this makes traditional latticed-based algorithms difficult to handle 3D point clouds. To solve this issue, many previous works discretize 3D point clouds by transforming them to either 3D voxels or multi-view images, causing volume redundancies and quantization artifacts. As a pioneering work, PointNet is a deep-neural-network-based supervised method that uses pointwise multi-layer perceptron followed by maximum pooling to guarantee permutation invariance. It achieves successes on a series of supervised-learning tasks, such as recognition, segmentation, and semantic scene segmentation of 3D point clouds [7]. After that, similar techniques are also applied to many other tasks, such as 3D point cloud detection [8], classification [9], and upsampling [10].

In this work, we consider unsupervised learning of 3D point clouds; that is, learning compact representations of 3D point clouds without any labeling information. In this way, representative features are automatically extracted from 3D point clouds and can be further applied to arbitrary subsequent tasks as auxiliary or prior information. Some works have been proposed recently to pursue this goal [11, 12]. They adopt the encoder-decoder framework. [11] discretizes 3D points to 3D voxels and uses 3D convolutions to design both encoder and decoder; however, it leads to unavoidable discretization errors and 3D convolutions are expensive. [12] directly handles 3D points; it uses PointNet as the encoder and fully-connected layers as the decoder. This approach is effective; however, it does not explore geometric structures of 3D point clouds and requires an unnecessarily huge number of training parameters.

The proposed networks directly handle 3D points and explore geometric structures of 3D point clouds by graph structures. The proposed networks follow the classical autoencoder framework with a focus on designing a powerful decoder. The encoder adopts PointNet and the decoder consists of three novel modules: the folding module, the graph-topology-inference module, and the graph-filtering module. The folding module maps each node in a 2D lattice to a point in the 3D space based on the latent code generated by the encoder, achieving coarse reconstructions. Intuitively, this process folds the underlying 2D flat of a 2D lattice to the underlying 3D surface of a 3D point cloud. The graph-topology-inference module learns a graph topology to explicitly capture the relationships between 3D points. Intuitively, the learnt graph topology is able to deform a 3D point cloud by cutting or gluing local shapes. Finally, the graph-filtering module couples the above two modules. It designs graph filters based on a learnable graph topology and refines the coarse reconstruction to obtain the final reconstruction. Intuitively, the graph filtering module guides the networks to fold, cut, and glue a 2D flat to form a refined and complex 3D surface; see Table I. The overall decoder leverages a learnable graph topology to push the codeword to preserve representative features and further improve the unsupervised-learning performance. We further provide theoretical analyses of the proposed architecture. We provide an upper bound on the reconstruction loss, which is proportional to the cube root of the code length. With a certain smoothness assumption, we are able to show that the filtering process lowers the upper bound by smoothing the coarse reconstruction. We also provide a theoretical framework to show that graph smoothness is a better prior than spatial smoothness and graph filtering refines 3D point clouds by promoting graph smoothness. This reflects the needs of an appropriate graph topology and the subsequent graph filtering.

Experimentally, we validate the effectiveness of the proposed networks in three tasks, including reconstruction, visualization, and transfer classification. To specifically show the fine-grained performance, we manually label the 3D shapes in the dataset of ModelNet40 and provide subcategory labels. For example, airplanes are categorized into $9$ subcategories according to the shape of wings. The experimental results show that (1) the proposed networks outperform state-of-the-art methods in quantitative tasks; (2) graph filtering guides the networks to refine details and outperforms its competitors in fine-grained classification; and (3) graph topology inference can be achieved without direct supervision in an end-to-end architecture.

The main contributions of this paper are:

• •

We propose a novel deep autoencoder with a focus on designing a graph-based decoder. The overall decoder leverages a learnable graph topology to push the codeword to preserve representative features;

• •

We provide theoretical analyses for proposed networks and show the effectiveness of leveraging a graph structure;

• •

We propose a fine-grained 3D shape dataset with subcategory labels based on ModelNet40, which could be used for fine-grained recognition, visualization, and clustering; and

• •

We validate the proposed networks in 3D point cloud reconstruction, visualization, and transfer classification. Both qualitative and quantitative results show that the proposed networks outperform state-of-the-art methods.

II Related Works

In this section, we overview the related works from three aspects: unsupervised learning, graph signal processing and geometric deep neural networks.

II-A Unsupervised Learning

Compared to supervised learning where training data is associated with ground-truth labels, unsupervised learning does not have any label and uses self-organization to model raw data. Some common unsupervised-learning methods include $k$-means clustering, Gaussian mixture models principal component analysis [13], matrix factorization [14], autoencoders, and generative adversarial networks [15]. Recently, a series of unsupervised-learning models are proposed to learn from 3D point clouds [16, 17, 18, 19, 20]. For example, 3D GAN converts 3D points to 3D voxels [11], which introduces a lot of empty voxels and loses precision; LatentGAN handles 3D point clouds directly [12]; however, the decoder uses fully-connected layers, which does not explore specific geometric structures of 3D point clouds and requires a huge number of training parameters; and VIP-GAN uses recurrent-neural-network-based architecture to solve multiple view inter-prediction tasks for each shape [21];  [22] learns a continuous signed distance function representation of a class of shapes that enables high quality shape representation, interpolation and completion from partial and noisy 3D input data. AtlasNet [55] models a 3D shape as a collection of parametric surface elements, which is similar to the folding module in the proposed decoder; 3DCapsNet [71] adopts the dynamic routing scheme and the peculiar 2D latent space. In this work, we use deep autoencoder to directly handle unorganized 3D points and propose graph-based operations to explore geometric structures of 3D point clouds.

II-B Graph Signal Processing

Graph signal processing is a theoretical framework for the analysis of high-dimensional data with irregular structures [23, 24, 25]. This framework extends classical discrete signal processing to signals with an underlying irregular structure. The framework models underlying structure by a graph and signals by graph signals, generalizing concepts and tools from classical discrete signal processing to the graph domain. Some techniques involve representations for graph signals [26, 27], sampling for graph signals [28, 29, 30], recovery for graph signals [31, 32], denoising [33, 34], graph-based filter banks [33, 35], graph-based transforms [36, 26], graph topology inference [37], and graph neural networks [38, 39]. To process 3D point clouds, [40] uses graph filters and graph-based resampling strategies to select most informative 3D nodes; [41] uses graph convolutional neural networks to classify 3D point clouds. In this work, we use graph signal processing techniques to achieve filter design in the proposed graph-filtering module.

II-C Geometric Deep Neural Networks

People have used various ways to represent 3D data in deep learning, including voxels [42], multi-view [43], meshes [44], and point clouds [7]. As a common raw data format in autonomous driving, robotics and augmented reality, 3D point clouds are of particular interests because of their flexibility and expressivity [45, 44, 46, 8, 47, 48, 49, 50]. To process and learn from 3D point clouds, many previous methods convert irregular 3D points to regular data structures by either voxelization or projection to 2D images, such that they can take the advantage of convolutional neural networks (CNN) [51, 52, 53, 54]; however, they have to trade-off between resolution and memory. To handle raw point clouds directly, PointNet [7] uses point-wise multilayer perceptron (MLP) and max-pooling to ensure the permutation invariance. A branch of 3D deep learning methods follows PointNet [7] as their base networks, with applications in classification, segmentation, and up-sampling [1, 55, 56, 57, 10, 58]. Other than that, [44, 47] define an MLP-based continuous graph convolution for processing unorganized point clouds with CNN-like networks; [48] defines a continuous tangent convolution for point clouds; [49] uses a simple polynomial convolution weight function instead of MLP; [8] uses PointNet before voxelization to combine both PointNet and CNN; [50] uses a self-organizing map to learn ordered information for MLP; and [45] designs a bilateral convolution layer that projects features onto a regularly partitioned space before convolution. Most of these previous works focus on supervised learning. In this work, we use deep learning techniques to achieve unsupervised learning of raw 3D points.

III Problem Formulation

We now cover the background material necessary for the rest of the paper. We start by introducing the properties of 3D point clouds. We then formulate the task of unsupervised learning of 3D point clouds.

III-A 3D Point Clouds

Let $\mathcal{S}=\{\mathbf{x}_{i}\in\mathbb{R}^{K}~{}|~{}i=1,\cdots,N\}$ be a 3D point cloud with ($K-3$) attributes. The corresponding matrix representation is

[TABLE]

where $\mathbf{s}_{i}\in\mathbb{R}^{N}$ denotes the $i$th attribute and $\mathbf{x}_{j}\in\mathbb{R}^{K}$ denotes the $j$th point; depending on the sensing device, attributes can be 3D coordinates, RGB colors, intensity, surface normal vector, and many others. Here we mainly consider 3D coordinates; thus from now on, $K=3$.

3D point clouds have their own specific properties:

• •

Permutation invariant. 3D point clouds are collections of 3D points represented by the corresponding 3D coordinates. The order of points stored in collections can be changed by any permutation operation and the points are still in the collections with the same coordinates;

• •

Transformation equivalence. The 3D coordinates of points can be translated, rotated or reflected along any directions without changing the surfaces they represent, indicating those transformations change the 3D coordinates, but do not change the intrinsic topology or relationships between points of a point cloud;

• •

Piecewise-smoothness. Since 3D point clouds are usually sampled from the surfaces of objects, they are intrinsically 2D surfaces folded in the 3D space. Most parts of a surface are smooth and can be locally approximated by 2D tangent planes, indicating neighboring points share similar geometric structures. Some parts of a surface have significant curvatures and are non-smooth. Overall, the underlying surface of a 3D point cloud is mostly piecewise-smooth in the 3D spatial domain.

III-B Unsupervised learning of 3D Point Clouds

The goal is to model the distribution of 3D point clouds by self-organization. Specifically, we aim to use a deep autoencoder to explore compact representations of 3D point clouds that preserve the ability to reconstruct the original point clouds. The proposed autoencoder is based on a deep neural-network framework. It learns to compress a 3D point cloud to a low-dimensional code, and then decompress the code back to a reconstruction that closely matches the original 3D point cloud. The compress module is called an encoder and the decompressed module is called a decoder.

III-B1 Encoder

The functionality of an encoder $\Psi(\cdot)$ is to produce a low-dimensional code to represent the original point cloud; that is,

[TABLE]

where $C\ll 3N$, reflecting that $\mathbf{c}$ is a compact representation of the original point cloud.

III-B2 Decoder

The functionality of a decoder $\Phi(\cdot)$ is to reconstruct a 3D point cloud that closely matches the original one; that is, the reconstructed 3D point cloud is

[TABLE]

Note that we do not restrict the number of points in the reconstructed 3D point cloud $M$ to be the same with the number of points in the original 3D point cloud $N$.

We use deep neural networks to design both the encoder and the decoder.

III-B3 Loss function

To push the reconstructed 3D point cloud to match the original 3D point cloud, we aim to minimize their difference. Given a set of $n$ 3D point clouds and a fixed code length $C$, the overall optimization problem is

[TABLE]

where $\mathcal{S}_{i}$ is the $i$th 3D point cloud in the dataset and $d(\cdot,\cdot)$ is the distance metric that measures the difference between two point clouds. Here we consider the augmented Chamfer distance,

[TABLE]

where the first term $\min_{j=1,2,\cdots,M}\left\|\mathbf{x}_{i}-\widehat{\mathbf{x}}_{j}\right\|_{2}$ measures the $\ell_{2}$ distance between each 3D point in the original point cloud and its correspondence in the reconstructed point cloud; the second term $\min_{j=1,2,\cdots,N}\left\|\widehat{\mathbf{x}}_{i}-\mathbf{x}_{j}\right\|_{2}$ measures the $\ell_{2}$ distance between each 3D point in the reconstructed point cloud and its correspondence in the original point cloud. The maximum operation outside the bracket enforces the distance from the original point cloud to the reconstructed point cloud and the distance vice versa be small simultaneously. The augmented Chamfer distance is essentially the Hausdorff distance between two 3D point clouds. Compared to the original Chamfer distance, it is more robust to prevent some ill cases. For example, the original Chamfer distance is less informative when one 3D point cloud have only a few 3D points. This augmented Chamfer distance enforces the underlying manifold of the reconstruction to stay close to that of the original point cloud. Since we use the minimum and average operations to remove the influence from the number of points, the reconstructed 3D point cloud does not necessarily have the same number of points as in the original 3D point cloud.

We use stochastic gradient descent to solve (3). Since we train the entire networks end-to-end, the performance of unsupervised learning depends on both the encoder and the decoder: the encoder extracts sufficient information such that the decoder is able to reconstruct; on the other hand, a decoder uses specific structures to push the encoder to extract specific information. Since we can reconstruct the original 3D point cloud, the code $\mathbf{c}$ preserves key features that describe 3D shapes of the original 3D point cloud. The code thus can be used in classification, matching and other related tasks. In this paper, we mainly consider the design of a decoder.

IV Network Architecture

In this section, we introduce the proposed networks; see an overview in Figure 1. The proposed networks follow the encoder-decoder framework. The encoder follows PointNet [7]. The decoder includes three novel modules: the folding module, the graph-topology-inference module, and the graph-filtering module.

IV-A Encoder

Here we mainly adopt the architecture of PointNet [7]. The encoder mainly includes a cascade of pointwise multi-layer perceptrons (MLP). For example, the first MLP maps a point from 3D space to a high-dimensional feature space. Since all 3D points share the same weights in the convolution, similar points will map to similar positions in the feature space. We next use the max-pooling to remove the point dimension, preserving global features. We finally use MLPs to map global features to codes. Mathematically, the encoder (1) is implemented as

[TABLE]

where $\mathbf{x}_{i}\in\mathbb{R}^{3}$ is the $i$th 3D point, ${\rm MLP}^{(\ell)}\left(\cdot\right)$ denotes $\ell$ layers of MLPs and $\mathbf{c}_{i}$ is the feature representation of the $i$th 3D point. Step (5a) uses a cascade of MLPs to extract point-wise features $\mathbf{c}_{i}$; Step (5b) uses max-pooling to aggregate point-wise features and obtain global features $\mathbf{c}^{\prime}$; and Step (5c) uses a cascade of MLPs to obtain the final code $\mathbf{c}$.

IV-B Decoder: Folding module

The folding module decodes the code to form a coarse reconstructed 3D point cloud. A straightforward way to decode is to use fully-connect layers that directly map a code to a 3D point cloud [12]; however, it does not explore any geometric property of 3D point clouds and requires a huge number of training parameters111The decoding is to construct a mapping from the code space to the space of $3N$-dimensional point sets. The fully-connected decoding uses fully-connected layers to learn such a mapping, while our idea is to parameterize such a mapping by introducing a canonical 2D lattice.. As mentioned in Section III-A, 3D point clouds are intrinsically sampled from 2D surfaces lying in the 3D space. We then consider the reconstruction as folding from a 2D surface to a 3D surface and the folding mechanism is determined by the code produced by the encoder.

Let $\operatorname{Z}\in\mathbb{Z}^{M\times 2}$ be a matrix representation of nodes sampled uniformly from a fixed regular 2D lattice and the $i$th row vector $\mathbf{z}_{i}\in\mathbb{R}^{2}$ be the 2D coordinate of the $i$th node in the 2D lattice. Note that $\operatorname{Z}$ is fixed and given for any 3D point cloud. It is used as a canonical base for the reconstruction and does not depend on the original point cloud. The functionality of the folding module is to fold a 2D lattice to a surface in the 3D space. Since the code is trained in a data-driven manner, it preserves the folding mechanism. We thus can concatenate the code with each 2D coordinate and then uses MLPs to implement the folding process. Mathematically, the $i$th point after folding is

[TABLE]

where the code $\mathbf{c}$ is the output of the encoder and $\left[\cdot,\cdot\right]$ denotes the concatenation of two vectors. The folding function $f_{\mathbf{c}}(\cdot)$ consists of two-layer MLPs and the code is introduced in each layer to guide the folding process. We collect all the 3D points $\mathbf{x}^{\prime}_{i}$ to form the reconstruction $\mathcal{S}^{\prime}=\{\mathbf{x}^{\prime}_{i}\in\mathbb{R}^{3}~{}|~{}i=1,\cdots,M\}$ with the corresponding matrix representation $\operatorname{X}^{\prime}\in\mathbb{R}^{M\times 3}$.

Intuitively, $f_{\mathbf{c}}(\cdot)$ is supposed to be a smooth function; that is, when two nodes are close in the 2D lattice, their correspondence after folding are also close in the 3D space. The smoothness makes the networks easy to train; however, when the 3D surfaces have a lot of curvatures and complex shapes, the smoothness of the 2D to 3D mapping limits the representation power. Table II shows that only training the folding module cannot reconstruct tori with high-order genus. The color associated with each point indicates the correspondence between a node in the 2D lattice and a 3D point. The smoothness of the color transition reflects the difficulty of the folding process. We see that only training the folding module cannot capture the holes in tori and the networks cannot find an appropriate way to fold. The reason behind is that the folding process implies the spatial smoothness, which can hardly construct an arbitrarily complex shape. Therefore, we consider $\operatorname{X}^{\prime}\in\mathbb{R}^{M\times 3}$ a coarse reconstruction and we next propose two other modules to refine the reconstruction.

IV-C Decoder: Graph-topology-inference module

The graph-topology-inference module decodes the code to reflect the pairwise relationships between 3D points. As the initialization of 3D points used in the folding module, the 2D lattice sets a default and uniform connection pattern to each pair of 3D points; however, it cannot capture irregular connection patterns, especially a topology that is genus-wise different from a 2D plane. To solve this, we learn a graph to capture irregular pairwise relationships, empowering the networks to refine a coarse reconstruction.

The learnt graph is initialized by the same 2D lattice used in the folding module. The nodes are fixed and the edges are updated during the training process. The initial graph adjacent matrix $\operatorname{A}^{0}\in\mathbb{R}^{M\times M}$ is

[TABLE]

where $\mathbf{z}_{i}$ is the $i$th node in the canonical 2D lattice, the hyper-parameters $\sigma$ reflects the decay rate, $\mathcal{N}_{i}$ represents the $k$-nearest neighboring nodes of node $\mathbf{z}_{i}$ and a normalization term $Z_{i}=\sum_{j}\exp(-\lVert\mathbf{z}_{i}-\mathbf{z}_{j}\rVert_{2}^{2}/(2\sigma^{2}))$ ensures that $\sum_{j}\operatorname{A}^{0}_{ij}=1$. Note that we use the same node set in the 2D lattice, but introduce more connections by considering $k$-nearest neighbors for each node, instead of restricting to 4. This can increase the reception field and make the model easier to train.

Since the code produced by the encoder preserves information of the original point cloud, we concatenate the code with each row of $\operatorname{A}^{0}$, and then uses MLPs to implement the graph topology inference. Mathematically, the $i$th row of the learnt graph adjacency matrix is obtained as

[TABLE]

where $\operatorname{A}_{i}\in\mathbb{R}^{M}$ is the $i$th row of $\operatorname{A}$ and $\mathbf{c}$ is the code produced by the encoder. The softmax operation promotes sparse connections, which can help reduce overfitting. Note that (i) the last layer of MLP uses ReLU as the nonlinear activation function, ensuring that all the edge weights are nonnegative; (ii) the softmax ensures that the sum of each row in $\operatorname{A}$ is one; that is, $\operatorname{A}{\bf 1}={\bf 1}\in\mathbb{R}^{M}$. We also recognize this as a random-walk matrix [59], whose element reflects the transition probability jumping from one node to another. We then introduce one more step to make the graph adjacency matrix symmetric; that is, $\operatorname{A}=(\operatorname{A}^{\prime}+\operatorname{A}^{\prime T})/2$. This step ensures the pairwise relationships between 3D points are undirected. During the experiments, we see that this step can stabilize the training process.

The intuition behind this is that the initial graph adjacent matrix provides initial pairwise relationships in the 2D lattice and the latent code provides the mechanism to adjust the edge weights in the graph adjacent matrix and properly reflect the pairwise relationships. At the same time, during training, the graph-topology-inference module pushes the latent code to preserve the spatial relationships in the original 3D point cloud, guiding the evolvement of the graph adjacency matrix.

Note that the memory cost of learning a graph topology is $O(M^{2})$. One potential solution of dealing with a large-scale 3D point cloud is to use the divide-and-conquer strategy [60]; however, the further improvement is subject to the future work.

IV-D Decoder: Graph-filtering module

The graph-filtering module couples the previous two modules, refining a coarse reconstruction through a learnable graph topology. In Section III-A, we mention that the underlying surface of 3D points is piecewise-smooth in the 3D spatial domain. The curvatures along the surface cause discontinuities; however, 3D coordinates are always smooth along the surface. In other words, when a graph perfectly reflects the underlying surface, 3D coordinates should be smooth in the graph domain. We thus design low-pass graph filters based on the learnt graph adjacency matrix to filter the coarse reconstruction and obtain the refined reconstruction. A graph filter allows each point to aggregate information from its neighbors to refine its 3D position. At the same time, the graph filtering pushes the networks to learn a graph topology that preserves smoothness on the graph for 3D points. Note that previous works design graph filters to process 3D point clouds, where both the graph topologies and the input 3D point clouds are fixed and known [61, 62, 63, 40], while the proposed system uses a fixed graph filter to couple the graph topology inference and the folding process in an end-to-end learning system, where both the graph topologies and the input 3D point clouds are trainable.

Here we consider two types of graph filters.

Graph-adjacency-matrix based filter design. Similarly to [34], we can design smooth graph filters based on the learnt graph adjacency matrix (IV-C); that is,

[TABLE]

where $h_{\ell}$’s are filter coefficients and $L$ is the order of the graph filter. A larger $L$ indicates a bigger receptive field; however, a large $L$ slows down the training process. For simplicity, we thus set $L=1$ and $h_{0}=h_{1}=0.5$. The final reconstruction is then

[TABLE]

where $\operatorname{X}^{\prime}$ is the coarse reconstruction obtained by the folding module. Correspondingly, the $i$th row of $\widehat{\operatorname{X}}$ is $\widehat{\mathbf{x}}_{i}=(\mathbf{x}^{\prime}_{i}+\sum_{j\in\mathcal{N}_{i}}\operatorname{A}_{ij}\mathbf{x}^{\prime}_{j})/2$, where $\mathbf{x}^{\prime}_{i}$ is obtained in (6). The corresponding set representation is $\widehat{\mathcal{S}}=\{\widehat{\mathbf{x}}_{i}\in\mathbb{R}^{3}~{}|~{}i=1,\cdots,M\}$. We recognize (9) as the low-pass graph Haar filter [64]. In traditional signal processing, the Haar filter is used to locally smooth time-series or images and remove noises. Here we use the graph Haar filter to locally smooth the coarse 3D point cloud to obtain a refined one. Theorem 4 shows the smoothness effect of the proposed low-pass graph Haar filter.

Graph-Laplacian-matrix based filter design. We can also convert the learnt graph adjacency matrix to the graph Laplacian matrix and then design smooth graph filters. Let $\mathcal{L}=\widetilde{\operatorname{D}}-\widetilde{\operatorname{A}}$ be the graph Laplacian matrix, $\widetilde{\operatorname{A}}=\left(\operatorname{A}+\operatorname{A}^{T}\right)/2$ is the symmetric graph adjacency matrix and $\widetilde{\operatorname{D}}={\rm diag}\left(\widetilde{\operatorname{A}}{\bf 1}\right)$ is the degree matrix. The eigendecomposition of $\mathcal{L}$ is

[TABLE]

where the eigenvector matrix $\operatorname{V}\in\mathbb{R}^{M\times M}$ is the graph Fourier basis and the eigenvalues ($\lambda_{1}\leq\lambda_{2}\leq\cdots\leq\lambda_{M}$) capture the graph frequencies. Since $\mathcal{L}{\bf 1}=0\cdot{\bf 1}$, the first eigenvalue is zero ($\lambda_{1}=0$) and the corresponding eigenvector is all ones, representing the smoothest graph signal. A larger eigenvalue is associated with a less smooth graph signal. The graph Laplacian $\mathcal{L}$ captures the second-order differences and its inverse promotes the global smoothness [65].

We thus consider the graph filters as follows

[TABLE]

where $\mu>0$ is a hyperparameter to avoid computational issues. The graph-spectral representations of the graph filters are

[TABLE]

The final reconstruction is then $\widehat{\operatorname{X}}\ =\ h(\mathcal{L})\operatorname{X}^{\prime}\in\mathbb{R}^{M\times 3}.$

Note that since (11) involves a matrix inversion, the computational cost of the graph-Laplacian-matrix based filter is much more expensive than the graph-adjacency-matrix based filter (9).

V Theoretical Analysis

In this section, we show the theoretical analyses about the proposed method.

V-A Reconstruction error

The aim here is to show when the proposed encoder and decoder can lead to bounded reconstruction errors. Without loss of generality, we assume that all the 3D points lie in a unit cubic space. The following theorem shows the existence of a pair of encoder and decoder to reconstruct an arbitrary 3D point cloud.

Theorem 1**.**

Let $\mathcal{X}_{n}=\{\mathcal{S}\subset[0,1]^{3},|\mathcal{S}|=n\}$ be the space of 3D point clouds with $n$ points. Then, there exits a pair of encoder $\Psi:\mathcal{X}_{N}\rightarrow\mathbb{R}^{C}$ and decoder $\Phi:\mathbb{R}^{C}\rightarrow\mathcal{X}_{C}$ that satisfies

[TABLE]

where $d(\cdot,\cdot)$ is the augmented Chamfer distance (III-B3).

Proof.

We proof by construction. We partition the 3D space into equally-spaced nonoverlapping voxels along each of three dimensions. We evenly split the unit 3D space $[0,1]^{3}$ into $K^{3}$ 3D voxels. The $(i,j,k)$th voxel represents a 3D space,

[TABLE]

Let $g_{i,j,k}(\mathbf{x})=\max_{\mathbf{z}\in\mathcal{V}_{i,j,k}}\exp\left(-\left\|\mathbf{x}-\mathbf{z}\right\|_{2}^{2})\right)\in\mathbb{R}$ be a soft indicator function, reflecting the presence of the point $\mathbf{x}$ in the $(i,j,k)$th voxel. Let $g(\mathbf{x})=[g_{1,1,1}(\mathbf{x}),\cdots,g_{K,K,K}(\mathbf{x})]\in\mathbb{R}^{K^{3}}$, reflecting the influence of the point $\mathbf{x}$ to the unit space. Let the encoder work as

[TABLE]

whose element $\Psi_{i,j,k}(\mathcal{S})=\max_{\mathbf{x}\in\mathcal{S}}g_{i,j,k}(\mathbf{x})\in\mathbb{R}$ indicates the occupancy of the $(i,j,k)$th voxel by 3D points in $S$ with $C=K^{3}$. By construction, the encoder discretizes a 3D point cloud to voxels and the code reflects the voxel occupancy.

Let the decoder work as

[TABLE]

where $\mathbf{q}_{i,j,k}=[i/K,j/K,k/K]\in[0,1]^{3}$ is the 3D point, which acts as the proxy of the $(i,j,k)$ voxel. In (13), we use two ways to index the code, indicating the one-to-one correspondence between $\ell$ and a triple of $i,j,k$. The code works as a lookup table: When an element in the code is one, the corresponding voxel is activated. In other words, the index reflects the corresponding voxel and the value is a mask to select the activated voxel.

Now, we bound $d(\mathcal{S},\widehat{\mathcal{S}})$. Because of the discretization, for any point $\mathbf{x}$ in $\mathcal{S}$, we can find a triple of $i,j,k$ to satisfy $\left\|\mathbf{x}-\mathbf{q}_{i,j,k}\right\|_{2}\leq\sqrt{3}/(2K)$; at the same time, for any point $\mathbf{q}_{i,j,k}\in\widehat{\mathcal{S}}$, we can find at least one point $\mathbf{x}\in\mathcal{S}$ to satisfy $\left\|\mathbf{q}_{i,j,k}-\mathbf{x}\right\|_{2}\leq\sqrt{3}/(2K)$; see Figure 2 (a). Then, we have

[TABLE]

∎

Theorem 1 constructs a naive pair of encoder and decoder to show the upper bound of the reconstruction error. To achieve this upper bound, the encoder only needs to discretize the 3D space, such that each point can be mapped to the corresponding voxel; and the decoder only needs to learn the index-to-voxel correspondence, such that each element in the code can represent the corresponding voxel. Note that the proposed structures of the encoder (5) and the decoder (6) are consistent with the hypothetical constructions, which is shown in details in the following corollary.

Corollary 1**.**

The proposed encoder (5) implements the constructed encoder (12). The proposed folding module (6) implements the decoder (13). The proposed encoder followed by the proposed decoder leads to the same upper bound as shown in Theorem 1.

Proof.

Here we mainly prove the decoder part. Specifically, we aim to show the following: Let $M$ be the number of output points and $\mathbf{c}_{0}=[\mathbf{c},\mathbf{x}_{0}]^{\top}$ be the code, where the code $\mathbf{c}$ follows (12) and $\mathbf{x}_{0}\in\mathbb{R}^{3}$ is an arbitrary 3D point in the original point cloud $\mathcal{S}$. Then, we use the folding module (6) to decode $\mathbf{c}_{0}$ and reconstruct a 3D point cloud $\widehat{\mathcal{S}}$ to satisfy that $d(\mathcal{S},\widehat{\mathcal{S}})\leq\sqrt{3}/{(2K)}$.

Now we explicitly provide the coefficients of each layer in the MLP. We denote by $\bm{\theta}_{l}$ the input and output to each layer. Note that by Definition 1 of [1], the code is concatenated with $M$ pairs of two dimensional grid coordinates $\mathbf{z}_{m}=(x_{m},y_{m})$, $m=1,2,\ldots,M$, and all of the $M$ concatenated vectors are fed into the same MLP in parallel. In our proof, we assume that the number of output points $M$ is the same as the number of 3D grid points $K^{3}$, i.e., $M=K^{3}$. The input to the first layer of the MLP is a vector of length $K^{3}+5$, i.e., $\bm{\theta}_{1}=[\mathbf{c},\mathbf{x}_{0},\mathbf{z}_{m}]^{\top}$, where recall that $\mathbf{x}_{0}$ is a point in the original point cloud $S$. Note that the index $m$ represents the $m$th 3D voxel, and that also corresponds to the ($i$,$j$,$k$)-th grid point in Theorem 1. In the proof below, we will sometimes refer to the index $m$ and the ($i$,$j$,$k$)-th grid point exchangeably.

The first layer is a simple nonlinear layer that only operates on the first $K^{3}$ elements on the input $\bm{\theta}_{1}$ to change the value to a binary 1 or 0, i.e., $f_{1}(x)=x$ if $x\geq 1$. Therefore, after the first layer, the output $\bm{\theta}_{2}$ represents the occupancy of the 3D voxel grid of size $K^{3}$, concatenated by one point $\mathbf{x}_{0}$ in the original point cloud $S$ and the 2D-grid point $\mathbf{z}_{m}$.

The second layer is a linear layer that maps the first $K^{3}$ elements in the input $\bm{\theta}_{2}$ to $4K^{3}$ elements, and does not change the concatenated values of the last 5 entries. The feature map is the $4K^{3}$-by-$K^{3}$ matrix

[TABLE]

where $\mathbf{I}$ is the identity matrix, and $\otimes$ represents the Kronecker product. The bias vector is

[TABLE]

where each $\mathbf{b}_{2,m}$ is a length-4 vector $[0,\mathbf{q}_{m}]$ and the length-3 vector $\mathbf{q}_{m}=\mathbf{q}_{i,j,k}$, i.e., the ($i$,$j$,$k$)-th 3D grid point. We apply this feature map and the bias vector to the first $K^{3}$ entries in the input $\bm{\theta}_{2}$ (the total length of which is $K^{3}+5$), and the output is a vector of length $4K^{3}+5$. The output vector can be written as

[TABLE]

where $\bm{\theta}_{3,m}=[f_{1}(\Psi_{i,j,k}(\mathcal{S})),\mathbf{q}_{i,j,k}]$, where recall that $f_{1}(\Psi_{i,j,k}(\mathcal{S}))$ means the binary value that indicates whether the ($i$,$j$,$k$)-th 3D voxel has been occupied or not.

The third and the fourth layers are exactly the same as Theorem 3.1 in [1]. The readers are referred to [1] and the proof therein for details. The Theorem 3.1 in [1] shows that one can use the grid point $\mathbf{u}_{m}$ to select the $m$th segment in a vector of length $3M$, and get a segment of size 3. Therefore, we can use exactly the same construction to get the $m$th segment of the first $4K^{3}$ elements in $\bm{\theta}_{3}$. Therefore, after the third and the fourth layer, the input to the fifth layer can be written as

[TABLE]

where $f_{1}(\Psi_{i,j,k}(\mathcal{S}))$ indicates whether the ($i$,$j$,$k$)-th 3D voxel has been occupied or not, $\mathbf{q}_{i,j,k}$ means the position of the ($i$,$j$,$k$)-th 3D voxel, and $\mathbf{x}_{0}$ means one point in the original point cloud.

The fifth-layer can choose $\mathbf{q}_{i,j,k}$ or $\mathbf{x}_{0}$ based on whether $f_{1}(\Psi_{i,j,k}(\mathcal{S}))=1$ or not. One may wonder how we can use an MLP to make this selection. One way is to simply let the output be $\mathbf{y}_{m}=f_{1}(\Psi_{i,j,k}(\mathcal{S}))\cdot\mathbf{q}_{i,j,k}+(1-f_{1}(\Psi_{i,j,k}(\mathcal{S})))\cdot\mathbf{x}_{0}$. However, this is not an MLP because it contains multiplication. In fact, Theorem 3.1 in [1] again provides the construction: one can use an MLP to select one input in the vector to be the output. Thus, the second way is to construct a selecter-MLP as in Theorem 3.1 in [1] to get the output.

The output of the MLP is thus either the grid point $\mathbf{q}_{i,j,k}$, or the point $\mathbf{x}_{0}$ that is already in the original point cloud. Therefore, the final output is the same as in Theorem 1 plus one extra point $\mathbf{x}_{0}$ that is already in the original point cloud, which does not change the Chamfer distance. This concludes the proof. ∎

The intuition behind the proof is that the folding module  IV-B can be represented as

[TABLE]

where $\mathbf{z}_{\ell}\in\mathbb{Z}^{2}$ is a node sampled from a 2D lattice $\operatorname{Z}$ and $f:\mathbb{Z}^{2}\rightarrow[0,1]^{3}$. It uses $\mathbf{z}_{\ell}$ to initialize $\mathbf{q}_{i,j,k}$in (13) and only needs to learn the mapping function $f(\cdot)$ that lifts 2D points to 3D points. While LatentGAN [12] uses fully connected layers as the decoder, which has to learn $\mathbf{q}_{i,j,k}$ from scratch.

The following theorem further shows that under the smoothness assumption, a filtering step refines the coarse 3D point clouds and achieves the better reconstructions.

Theorem 2**.**

Let $\mathcal{X}_{n}=\{\mathcal{S}\subset[0,1]^{3},|\mathcal{S}|=n\}$ be the space of 3D point clouds with $n$ points. Let $\Psi:\mathcal{X}_{N}\rightarrow\mathbb{R}^{C}$ be the encoder defined in (12). Let $\widetilde{\mathcal{X}}_{n}\subset\mathcal{X}_{n}$ satisfy that for all $\mathcal{S}\in\widetilde{\mathcal{X}}_{n}$,

[TABLE]

Then, there exits a coarse decoder $\Gamma:\mathbb{R}^{C}\rightarrow\mathcal{X}_{C}$ and a filter $h:\mathcal{X}_{C}\rightarrow\widetilde{\mathcal{X}}_{C}$ that satisfies

[TABLE]

where $d(\cdot,\cdot)$ is the augmented Chamfer distance (III-B3).

Proof.

To take the advantage of the smoothness condition (18), instead of encoding each voxel, we can partition the space into a finer resolution and encode every other voxel. The decoder $\Gamma(\cdot)$ can then recover every other voxel. After that, $h(\cdot)$ is introduced to interpolate via neighboring voxels; that is, we add $\mathbf{q}_{i,j,k}$ to the final reconstruction $\widehat{\mathcal{S}}$ when $\mathbf{q}_{i+\delta_{i},j+\delta_{j},k+\delta_{k}}\in\widehat{\mathcal{S}}$ with $\delta_{i}=\{0,1\},\delta_{j}=\{0,1\},\delta_{k}=\{0,1\}$. The maximum error we could make is no more than $1/K$; see Figure 2 (b). Since we use the half of the length of code, the code length is $C=K^{3}/2$, the error is ${1}/{\sqrt[3]{2C}}$. ∎

The smoothness condition (18) only requires the voxel is similar to its neighbor voxels, which is soft and easy to satisfy. This result suggests that exploring smoothness can reduce the reconstruction error. The proposed graph-filtering module in Section IV-D uses a graph filter to promote smoothness and potentially leads to a smaller reconstruction error. Theorem 2 assumes smoothness in the 3D spatial domain; however, 3D points may not be smooth in the 3D spatial domain. We next show that graphs and graph smoothness can be used to capture the distribution of 3D points.

V-B Graph smoothness

The aim here is to show graph smoothness is a key prior to model 3D point clouds. When the graph-topology-inference module in Section IV-C can infer appropriate graphs, we can model 3D point clouds as smooth graph signals, instead of nonsmooth spatial signals. Since the graph-filtering module in Section IV-D promotes graph smoothness, it is expected to improve the reconstruction quality of point clouds.

For simplicity, instead of considering points in the 3D space, we consider nodes in a 2D lattice, which is a simplified and discretized version of points in the 3D space. We use a binary value to indicate if each node in the 2D lattice is occupied. Those binary values on the 2D lattice form a 2D lattice signal. Since a 3D point cloud intrinsically represents a 2D surface, 2D lattice signal intrinsically represents a 1D curve.

Definition 1**.**

Let $\operatorname{X}\in\{0,1\}^{N\times N}$ be a 2D lattice signal, where $\operatorname{X}_{i,j}$ denotes the signal value supported on the $(i,j)$th node. The directional variation of the spatial signal $\operatorname{X}$ at $(i,j)$th node is

[TABLE]

The directional total variation of the spatial signal $\operatorname{X}$ is

[TABLE]

The first term in the parenthesis captures the isolated nodes and the second term in the parenthesis captures the local discontinuity. The directional total variation measures the curvatures represented by a 2D spatial signal. Here we cannot use the standard total variation [66] because we consider 1D curves in 2D lattice. The standard total variation is defined to measure the smoothness level of natural images; however, here we consider 1D curves in the 2D lattice, which can be considered as an extremely sparse image with signals only on the curve. In this case, the standard total variation can hardly measure the complexity of the curvature.

A low directional total variation indicates that the underlying 1D curve is smooth in the 2D space. For example, Figure 3 shows that red dots form a 1D curve in the 2D lattice and the directional total variation can properly measure the curvatures.

Definition 2**.**

Let $\mathbf{x}\in\mathbb{R}^{n}$ be a graph signal associated with a graph adjacency matrix $\operatorname{A}\in\mathbb{R}^{n\times n}$, where $\mathbf{x}_{i}\in\mathbb{R}$ denotes the signal value on the $i$th node. The graph total variation of the graph signal $\mathbf{x}$ is

[TABLE]

The graph total variation measures the graph smoothness. A low graph total variation of a graph signal indicates that the underlying 1D curve is smooth in the graph domain. To represent the same occupancy of nodes in a 2D lattice, we can use either a spatial signal or a pair of graph signals. A spatial signal uses a binary value to indicate the occupancy of a node; that is, when the value is one, the corresponding node is occupied. A pair of graph signals use the 2D coordinates to record the occupied nodes. When a spatial signal represents the same information with a pair of graph signals, we consider they are equivalent.

Definition 3**.**

Let $\operatorname{X}\in\{0,1\}^{N\times N}$ be a 2D lattice signal. Let $\mathbf{x}^{(1)},\mathbf{x}^{(2)}\in\mathbb{R}^{M}$ be a pair of graph signals. $\operatorname{X}$ and $\mathbf{x}^{(1)},\mathbf{x}^{(2)}$ are equivalent when

• •

$\operatorname{X}_{\lceil\mathbf{x}^{(1)}_{\ell}\rceil,\lceil\mathbf{x}^{(2)}_{\ell}\rceil}=1$, for $\ell=1,\cdots,M$;

• •

$\sum_{i,j=1}^{N}\operatorname{X}_{i,j}=M$.

The first condition indicates that each element in a graph signal reflects the coordinate in the 2D lattice. $\lceil\cdot\rceil$ denotes the ceiling function that rounds a real value to an integer. Note that the underlying graph associated with a graph signal can have arbitrary connections and the optimal one is supposed to provide graph smoothness for the 2D coordinates. For example, the spatial signal

[TABLE]

is equivalent to a pair of graph signals

[TABLE]

which can be associated with an arbitrary graph $\widetilde{\operatorname{A}}\in\mathbb{R}^{8\times 8}$. No matter what graph topology is, both the spatial signal $\widetilde{\operatorname{X}}$ and a pair of graph signals $[\widetilde{\mathbf{x}}^{(1)},\widetilde{\mathbf{x}}^{(2)}]$ represents the same ‘Z’ shape in the 2D space; see illustration in Figure 4.

Among many possible graph topologies, we can find at least one to promote graph smoothness for $[\widetilde{\mathbf{x}}^{(1)},\widetilde{\mathbf{x}}^{(2)}]$. Given

[TABLE]

we can show ${\rm TV}_{\widetilde{\operatorname{A}}}(\widetilde{\mathbf{x}}^{(1)})={\rm TV}_{\widetilde{\operatorname{A}}}(\widetilde{\mathbf{x}}^{(2)})=0$. At the same time, due to the local discontinuity, ${\rm DTV}(\widetilde{\operatorname{X}})>0$.

In the following theorem, we show that there always exists a nontrivial graph to promote graph smoothness for arbitrary graph signals.

Theorem 3**.**

Let $\mathbf{x}^{(1)},\mathbf{x}^{(2)}\in\mathbb{R}^{M}$ ($M>2$) be two vectors. Then, there exists a graph adjacency matrix $\operatorname{A}\in\mathbb{R}^{M\times M}$ to satisfy that

• •

$\operatorname{A}\neq\operatorname{I}$;

• •

${\rm TV}_{\operatorname{A}}(\mathbf{x}^{(1)})={\rm TV}_{\operatorname{A}}(\mathbf{x}^{(2)})=0$.

Proof.

We want to show the existence of $\operatorname{A}$ given two conditions. Based on the second condition, we use the lifting trick to obtain

[TABLE]

Since $\begin{bmatrix}{\mathbf{x}^{(1)}}^{T}\\ {\mathbf{x}^{(2)}}^{T}\end{bmatrix}\otimes\operatorname{I}\in\mathbb{R}^{2M\times M^{2}}$, rank$\left(\begin{bmatrix}{\mathbf{x}^{(1)}}^{T}\\ {\mathbf{x}^{(2)}}^{T}\end{bmatrix}\otimes\operatorname{I}\right)<M^{2}$. Thus, there exists $\operatorname{A}\neq\operatorname{I}$ to ensure $(\operatorname{I}-\operatorname{A})\mathbf{x}^{(1)}=(\operatorname{I}-\operatorname{A})\mathbf{x}^{(2)}=0$. ∎

We further show that a nonsmooth spatial can be represented as a smooth graph signal.

Corollary 2**.**

There exists a class of 2D lattice signals $\operatorname{X}\in\{0,1\}^{N\times N}$ and corresponding pairs of graph signals $\mathbf{x}^{(1)},\mathbf{x}^{(2)}\in\mathbb{R}^{M}$ associated with specifically designed graph adjacency matrices $\operatorname{A}\in\mathbb{R}^{M\times M}$ to satisfy that

• •

$\operatorname{X}$ is equivalent to $\mathbf{x}^{(1)},\mathbf{x}^{(2)}$;

• •

$\frac{{\rm DTV}(\operatorname{X})}{1_{N}^{T}\operatorname{X}1_{N}}=O(1)$;

• •

$\operatorname{A}\neq\operatorname{I}$;

• •

${\rm TV}_{\operatorname{A}}(\mathbf{x}^{(1)})={\rm TV}_{\operatorname{A}}(\mathbf{x}^{(2)})=0$.

The first condition indicates the equivalence; the second condition indicates the number of discontinuities increases as the length of the curve increases, reflecting spatial nonsmoothness; the third condition indicates the graph topology is nontrivial; and the fourth condition indicates the existence of a graph topology to ensure the graph smoothness.

Proof.

A class of periodic ‘Z’ or ‘L’ shapes, which generalize the previous example of $\widetilde{\operatorname{X}}$, is a simple construction proof to this Theorem. Due to the periodicity, the number of local discontinuities increases as the length of the curve increases. On the other hand, as shown in Theorem 3, there exists a graph topology to ensure graph total variations are zeros. ∎

Corollary 2 shows that with an appropriate graph topology, we can represent a nonsmooth spatial signal as a pair of smooth graph signals. Hypothetically, the graph-topology-inference module is designed to provide such a graph topology. In practice, many 3D points sampled from complicated shapes and curvatures show nonsmoothness in the 3D space. On the other hand, when an appropriate graph topology is obtained, graph smoothness is a strong prior to capture the distribution of 3D points. We thus can use the graph-topology-inference module to learn an appropriate graph and then promote graph smoothness for 3D points. This also indicates that convolutional neural networks may not be appropriate to learn 3D point clouds [11]. A 3D convolution is usually used for 3D volume data and does not explore an appropriate manifold prior for 3D point clouds, which are sampled from the surfaces of objects.

We now show graph filtering guides the networks to promote graph smoothness and refine the positions of 3D points.

Theorem 4**.**

Let $\operatorname{A}\in\mathbb{R}^{M\times M}$ be an adjacency matrix whose eigenvalues are $\lambda_{i}$, with $\max_{i}|\lambda_{i}|=1.$ Let $h(\operatorname{A})=\frac{1}{2}\left(\operatorname{I}+\operatorname{A}\right)\in\mathbb{R}^{M\times M}$ be a graph filter. For any graph signal $\mathbf{x}\in\mathbb{R}^{M}$, we have

[TABLE]

Proof.

Let $\operatorname{M}=(\operatorname{I}-\operatorname{A})^{T}(\operatorname{I}-\operatorname{A})-h(\operatorname{A})(\operatorname{I}-\operatorname{A})^{T}(\operatorname{I}-\operatorname{A})h(\operatorname{A})\in\mathbb{R}^{M\times M}$. We want to show

[TABLE]

is nonnegative for any arbitrary $\mathbf{x}$. This is equivalent to show $\operatorname{M}$ is positive semidefinite. We now want to show that all the eigenvalues of $\operatorname{M}$ are nonnegative. Since we can show

[TABLE]

and

[TABLE]

the eigenvalues of $\operatorname{M}$ are $(1-\lambda_{i})^{2}-\frac{(1-\lambda_{i})^{2}(1+\lambda_{i})^{2}}{4}$ for $i=1,\cdots,N$. Since $-1\leq\lambda_{i}\leq 1$,

[TABLE]

Thus, $\operatorname{M}$ is positive semidefinite. ∎

This shows that the low-pass graph Haar filter promotes graph smoothness. In the context of 3D point clouds, the graph-filtering module refines the reconstructed 3D points by pushing them as smooth graph signals. For graph-Laplacian-based filters (11), we can use the quadratic term $\mathbf{x}^{T}\mathcal{L}\mathbf{x}$ to measure the graph variations [23] and further show that

[TABLE]

which also pushes the reconstructed 3D points as smooth graph signals.

VI Experimental Results

In this section, we conduct experiments to validate the proposed unsupervised model mainly from three aspects: 3D point cloud reconstruction, visualization and transfer classification.

VI-A Dataset

We consider four datasets in the experiments, including ShapeNet [67], ShapeNetCore [68], ModelNet40 [69] and ModelNet10 [69]. ShapeNet contains more than $50000$ unique 3D models from 55 manually verified categories of common objects and ShapeNetCore is a subset of ShapeNet. ModelNet40 (MN40) contains 9843/2468 3D CAD models from 40 categories in train/test datasets; ModelNet10 (MN10) contains 3991/909 3D CAD models from 10 categories in train/test datasets; the datasets are labeled by human workers in Amazon Mechanical Turk and manually selected by researchers. In our experiments, we sample $57447$ point clouds from ShapeNet, $12311$ point clouds from ModelNet40, $4900$ point clouds from ModelNet10, and $15011$ point clouds from ShapeNetCore. Each point cloud is composed of $2048$ 3D points.

VI-B Experimental Setup

All the experiments are conducted on GTX TITAN Xp GPU with pytorch 0.4.0. We used ADAM with an initial learning rate of 0.0001. The training batch size is $32$. The features dimensions are shown in Figure 1. In our experiments, we choose $k=96$ and $\sigma=0.08$ in the graph-topology-learning module and $\mu=0.5$ in the graph-filtering module. The experimental results show the overall performances are not sensitive to those hyperparameters. By default, the number of reconstructed 3D points are set to M = 2025. Note that a squared number is preferred for M because of the structure of the 2D lattice.

VI-C Reconstruction of 3D Point Clouds

As an unsupervised method, we first validate the reconstruction performance of the proposed networks. Specifically, we compare the reconstructions without graph filtering and with graph filtering. For the reconstructions without graph filtering, we remove the graph-topology-inference module and the graph-filtering module and only train the folding module end-to-end222In this paper, when we show the performance of the folding module, there are two possible settings. In the first setting, we train three modules together and the supervision is put on the final output of the graph-filtering module. The output of the folding module is the intermediate output from the entire networks; we call this before graph filtering. In the second setting, we only train the folding module and the supervision is directly put on the output of the folding module; we call this folding module only.. We then use its output $\mathcal{S}^{\prime}$ in (6) as the final reconstruction; for the reconstructions with graph filtering, we train all three modules and outputs the refined reconstruction $\widehat{S}$ in (9). To make a fair comparison, we adjust the configurations of both models to ensure they have similar numbers of trainable parameters. For the graph-filtering module, we consider both graph-adjacency and graph-Laplacian-matrix based filters. We train all the networks on ShapeNetCore. Table III shows the comparisons of the reconstruction losses, which are measured by the augmented Chamfer distance. We see that the entire networks with graph filtering achieve better reconstruction performance than the folding module only. This indicates that it is beneficial to using a graph topology to refine the reconstruction. We also see that the graph-Laplacian-based filter (11) achieves slightly better reconstruction performances than the graph-adjacency-based filter (9). We also compare the proposed method with AtlasNet [55] and 3DCapsNet [71]. AtlasNet generates a 3D surface by leveraging multiple configurations from the same 2D flat; and 3DCapsNet generates multiple 3D local patches by leveraging distinct 2D lattices with the corresponding latent representations. Here we adopt one single 2D lattice and use a trainable graph topology to increase the expressive power of this 2D lattice. Table III shows that the proposed method outperforms AtlasNet and 3DCapsNet.

VI-D Visualization of Reconstruction and Graph Topology

Tables IV and  V show the evolvement of reconstructions and learnt graph topologies during the training process based on graph-adjacency-matrix and graph-Laplacian-matrix based filtering, respectively. The Before graph filtering columns show the coarse reconstructions produced by the folding module. Different from the reconstruction without graph filtering shown in Section VI-C, here we train the entire networks with three modules end-to-end and extract the output of the folding module as the intermediate output. In other words, the supervision is not put on the output of the folding module directly. The After graph filtering columns show the reconstructions after the graph-filtering module. We see that (i) for three airplanes, the reconstructed point clouds in the Before graph filtering columns are similar, reflecting a shared and common shape of various airplanes. This indicates that the folding module provides coarse reconstructions. (ii) The reconstructed point clouds in the After graph filtering columns preserves more fine details, such as engines, tails, nodes, and wing tips. Note that the wing tips were missing without applying graph filtering; see Table 2 [1]. One can look at Figure 1 for a more clear demonstration of the reconstructed wing tips from another visualization angle. This indicates that the graph-filtering module refines the details and provides better reconstructions. Comparing two types of graph filtering, the graph-adjacency-matrix-based filtering (9) and the graph-Laplacian-matrix-based filtering (11) provide different, yet similar reconstruction performances.

To visualize the evolvement of the learnt graph topology, we select one point in the 2D lattice and record its neighbors in the learnt graph topology during the training process. The chosen point is colored in red and its neighboring points are colored in cyan. We see that (i) during the training procedure, the learnt graph builds new connections and cuts the old connections adaptively for a better reconstruction performance; (ii) for three airplanes, the neighbors are similar, reflecting shared and common pairwise relationships in various airplanes; (iii) with the graph-topology-inference module and the graph-filtering module, both 3D coordinates and pairwise relationships are updating simultaneously to refine local shapes.

VI-E 3D Point Cloud Transfer Classification

Features extracted from unsupervised-learning methods can be used for supervised tasks. For example, principal component analysis is a common unsupervised-learning method that represents data via a learnt orthogonal transformation. The coordinates in the transformed coordinate system are often used as features in classification, regression [13]. Similarly, we can take the latent code produced by the encoder of the proposed networks as features of a 3D point cloud. Based on those features, we can train a classifier to recognize the corresponding category of a 3D point cloud. Since the proposed networks and the classifier are trained by separate datasets, we call the task transfer classification. In other words, the networks learn shape patterns from 3D point clouds in one dataset and are used to extract features of 3D point clouds in a different dataset. The performance of the transfer classification shows the effectiveness of the latent code and the generalization ability of the networks.

VI-E1 Category classification

We first consider the category classification. There are $10$ and $40$ categories in ModelNet10 (MN10) and ModelNet40 (MN40), respectively. Some categories include airplane, chair, and bed. We follow the same experimental setting in [12, 1, 55] to train the proposed networks with 3D point clouds sampled from the dataset of ShapeNet. After the proposed networks are trained, we fix the parameters and run the networks to obtain the codes for 3D point clouds sampled from ModelNet10 and ModelNet40. We then split the codes into train/test datasets as the work in [7, 1, 11, 55]. ModelNet40 (MN40) contains 9843/2468 3D mesh models in train/test datasets; ModelNet10 (MN10) contains 3991/909 3D mesh models in train/test datasets. Each point cloud contains 2048 3D points with their $[x,y,z]$ coordinates. We use a linear SVM as the classifier to recognize the corresponding category of a 3D point cloud. We compare the proposed networks with the other state-of-the-art unsupervised-learning models, including SPH, LFD, T-L Network, VConv-DAE, 3D GAN, VIP-GAN, LatentGAN [16, 17, 18, 19, 11, 12].

Table VI shows the comparison of classification accuracies. We see that (i) the proposed networks achieve the best classification accuracy in ModelNet10 and achieves the second best performance in ModelNet40; however, VIP-GAN uses a longer code (4096 vs. 512 in ours) and has a different input modality; it uses images, instead of 3D point clouds as inputs; (ii) in both datasets, two types of learnable graph filters (9) and  (11) provide similar performances; (iii) in both datasets, when we replace the learnable graph topology by the fixed 2D lattice, the performance degenerates, indicating a naive graph topology would provide misleading prior and make the training process harder; (iv) in both datasets, the proposed networks outperform the LatentGAN, which adopts 3D point clouds as inputs; (v) in both datasets, the proposed networks perform better when the graph-filtering module is used to refine the reconstruction. The reason is that graph-topology-inference-module pushes the code to preserve both 3D coordinate information and pairwise relationship information, such that the decoder can reconstruct the 3D point clouds and the corresponding graph topology; and (vi) when we replace the encoder from PointNet to PointNet++, the classification performance does not significantly improved. The intuition could be that a powerful decoder is able to push the codewords to preserve informative features and release the pressure of using a sophisticated encoder.

VI-E2 Subcategory Classification

Recognizing objects across various categories mainly requires global features, instead of local features. For example, even a model cannot capture engines of airplanes shown in Table VII, the classifier can still correctly label it as an airplane. Here we consider validating the ability of the proposed networks to extract detailed features. For objects in the same category, we further group them into several subcategories based on some local shapes. We then train the models to classify subcategories; called the subcategory classification. To achieve a high classification accuracy in this task, a model has to capture local features.

We choose four categories in ModelNet40, including airplanes, beds, chairs, and monitors, and manually label subcategories for them. Table VII illustrates the subcategory dataset. Here we label point clouds only based on 3D shapes, without considering their function or other information. Airplanes are grouped into $9$ subcategories based on the shape of the wings and the number of engines. $551$ and $142$ airplanes are used for training and testing, respectively. Beds are grouped into $8$ subcategories based on the shape of the board and the presence of pillows. $433$ and $112$ beds are used for training and testing, respectively. Chairs are grouped into $16$ subcategories. $707$ and $187$ chairs are used for training and testing, respectively. Monitors are grouped into $9$ subcategories based on the shape of bases. $400$ and $104$ monitors are used for training and testing, respectively.

We compare the proposed networks with LatentGAN, AtlasNet [55], 3DCapsNet [71], and a supervised model, PointNet. Table VIII shows the comparison of classification accuracies in the subcategory dataset. We see that (i) the proposed networks achieve significantly higher classification accuracies than LatentGAN in all four categories. LatentGAN fails to classify subcategories since fully-connected layers do not commit a dedicated design to exploit local geometric structures or point relationships; (ii) as an unsupervised model, the proposed networks even work better than PointNet in three categories, indicating a strong generalization ability of the proposed networks. Note that PointNet is trained with both cross-entropy loss and the hinge loss. The one with the hinge loss is slightly worse; (iii) the proposed networks perform better when the graph-filtering module is used to refine the reconstruction. The results indicate that graph filtering has a significant advantage in preserving local geometric structures; and (iv) two types of graph filters (9) and  (11) provide similar classification performances.

VI-F Visualization of Clustering

We use the latent code produced by the proposed networks to represent a 3D point cloud and use t-SNE to reduce the dimensionality to $2$ for visualization [70]. Here we use the graph-adjacency-matrix-based filtering (9) to implement the graph-filtering module. Figure 5 shows the clustering performance on both training and testing sets of ModelNet10 where each point represents a 3D point cloud and the associated color represents its ground-truth category. We see that 3D point clouds with the same categories are clustered together, indicating the proposed networks encode similar 3D point clouds to similar codes.

VI-G Graph Spectral Analysis

Table IX shows the spectral properties of the learned graph topologies based on either the graph adjacency matrix (9) or the graph Laplacian matrix (11). The first column shows the distribution of eigenvalues of the learned graph adjacency/Laplacian matrix, which indicates the graph frequencies. In each plot, the left side of the $x$-axis represents lower frequency and vice versa. We see that for the graph adjacency matrix, the eigenvalues associated with the torus point cloud and the airplane point cloud are similar; however for the graph Laplacian matrix, the eigenvalues of torus point cloud decrease much faster compared with the eigenvalues of airplane point cloud, which implies that it is easier to learn a torus than an airplane. We also calculate the first four eigenvectors of the graph adjacency/Laplacian matrix and color the corresponding reconstructed point clouds using the values of these eigenvectors, which are shown in Table IX. The colored point clouds listed in the second, third, fourth and fifth columns are segmented by the colors in a finer way.

VI-H Effect of the number of reconstructed points $M$

Table X shows the reconstruction losses as a function of the number of reconstructed points $M$. We see that a larger value of $M$ leads to smaller reconstruction losses. The reason is that increasing the number of reconstructed points in a point cloud is equivalent to increasing the sampling density of reconstructed point clouds; thus, the points in input 3D point clouds are able to find closer points in reconstructed point clouds. Note that (1) increasing the value of $M$ does not necessarily improve the transfer classification performance; see Table XI; and (2) increasing the value of $M$ would significantly increases the number of training parameters because the learned graph-adjacency/Laplacian matrix is an $M\times M$ matrix. Therefore, we usually set $M\approx N$.

VI-I Validation of augmented Chamfer distance

As discussed in Section IV, the augmented Chamfer distance is the Hausdorff distance between two 3D point clouds. Tables XII and XIII compare the classification accuracies between using the standard Chamfer distance (CD) and using the augmented Chamfer distance (AugCD) in the tasks of classification and fine-grained classification, respectively. We see that using the augmented Chamfer distance achieves a better performance than using the standard Chamfer distance.

VI-J Tradeoff between spatial and graph smoothness

Tables XIV and XV show the tradeoffs between spatial and graph smoothness based on graph adjacency matrix and graph Laplacian matrix, respectively. For the graph-adjacency-matrix based filter, we plot the reconstructed point clouds as a function of $\alpha$; that is, $\operatorname{X}_{\alpha}=\left((1-\alpha)\operatorname{I}+\alpha\operatorname{A}\right)\operatorname{X}^{\prime}$, where $\operatorname{X}^{\prime}$ is the coarse reconstruction produced by the folding module. For the graph-Laplacian-matrix based filter, we plot the reconstructed point clouds as a function of $\alpha$; that is, $\operatorname{X}_{\alpha}=\left(\mu\operatorname{I}+\mathcal{L}\right)^{-2\alpha}\operatorname{X}^{\prime}$. In both cases, when $\alpha=0$, the reconstruction only depends on the folding module, which promotes the spatial smoothness and implies the intrinsic dimension of the underlying surface is close to $2$; when $\alpha=1$, the reconstruction promotes the graph smoothness and implies the intrinsic dimension of the underlying surface is close to $3$. Here we use graph Haar filter, which is equivalent to $\alpha=0.5$; it combines both spatial and graph smoothness. The intrinsic dimension of underlying surface is around $2.5$ [72].

VII Conclusions

We propose an end-to-end deep autoencoder that achieves cutting-edge performance in unsupervised learning of 3D point clouds. The main novelties are that (i) we propose the folding module to fold a canonical 2D flat to the underlying surface of a 3D point cloud; (ii) we propose the graph-topology-inference module to model pairwise relationships between 3D points, pushing the latent code to preserve both coordinates and pairwise relationships of 3D points; (iii) we propose the graph-filtering module, which refines the coarse reconstruction to obtain the final reconstruction. We further provide an upper bound for the reconstruction loss and show that graph filtering lowers the upper bound. In the experiments, we validate the proposed networks in 3D point clouds reconstruction, visualization, and transfer classification. The experimental results show that (i) the proposed networks outperform state-of-the-art methods in the quantitative tasks; (ii) a graph topology can be inferred without specific supervision; and (iii) graph filtering improves the performances by reconstructing details.