L EARNING TO G ENERATE 3D S HAPES WITH G ENERATIVE C ELLULAR A UTOMATA
Anonymous authors
Paper under double-blind review
A BSTRACT
In this work, we present a probabilistic 3D generative model, named Generative
Cellular Automata, which is able to produce diverse and high quality shapes.
We formulate the shape generation process as sampling from the transition kernel of a Markov chain, where the sampling chain eventually evolves to the full shape of the learned distribution.
The transition kernel employs the local update rules of cellular automata, effectively reducing the search space in a high-resolution 3D grid space by exploiting the connectivity and sparsity of 3D shapes.
Our progressive generation only focuses on the sparse set of occupied voxels and their neighborhood, thus enables the utilization of an expressive sparse convolutional network.
We propose an effective training scheme to obtain the local homogeneous rule of generative cellular automata with sequences that are slightly different from the sampling chain but converge to the full shapes in the training data.
Extensive experiments on probabilistic shape completion and shape generation demonstrate that our method achieves competitive performance against recent methods.
I NTRODUCTION
Probabilistic 3D shape generation aims to learn and sample from the distribution of diverse 3D shapes and has applications including 3D contents generation or robot interaction.
Speciﬁcally, learning the distribution of shapes or scenes can automate the process of generating diverse and realistic virtual environments or new object designs.
Likewise, modeling the conditional distribution of the whole scene given partial raw 3D scans can help the decision process of a robot, by informing various possible outputs of occluded space.
The distribution of plausible shapes in 3D space is diverse and complex, and we seek a scalable formulation of the shape generation process.
Pioneering works on 3D shape generation try to regress the entire shape (Dai et al.
(2017)) which often fail to recover ﬁne details.
We propose a more modular approach that progressively generates shape by a sequence of local updates.
Our work takes inspiration from prior works on autoregressive models in the image domains, such as the variants of pixelCNN (van den Oord & Kalchbrenner (2016); van den Oord et al.
(2016; 2017)), which have been successful in image generation.
The key idea of pixelCNN (van den Oord et al.
(2016)) is to order the pixels, and then learn the conditional distribution of the next pixel given all of the previous pixels.
Thus generating an image becomes the task of sampling pixel-by-pixel in the predeﬁned order.
Recently, PointGrow (Sun et al.
(2020)) proposes a similar approach in the ﬁeld of 3D generation, replacing the RGB values of pixels with the coordinates of points and sampling point-by-point in a sequential manner.
While the work proposes a promising interpretable generation process by sequentially growing a shape, the required number of sampling procedures expands linearly with the number of points, making the model hard to scale to high-resolution data.
We believe that a more scalable solution in 3D is to employ the local update rules of cellular automata (CA).
CA, a mathematical model operating on a grid, deﬁnes a state to be a collection of cells that carries values in the grid (Wolfram (1982)).
The CA repeatedly mutates its states based on the predeﬁned homogeneous update rules only determined by the spatial neighborhood of the current cell.
In contrast to the conventional CA where the rules are predeﬁned, we employ a neural network to infer the stochastic sequential transition rule of individual cells based on Markov chain.
The obtained homogeneous local rule for the individual cells constitutes the 3D generative model, named
Generative Cellular Automata (GCA).
When the rule is distributed into the group of occupied cells of an arbitrary starting shape, the sequence of local transitions eventually evolves into an instance among the diverse shapes from the multi-modal distribution.
The local update rules of CA greatly reduce the search space of voxel occupancy, exploiting the sparsity and connectivity of 3D shapes.
We suggest a simple, progressive training procedure to learn the distribution of local transitions of which repeated application generates the shape of the data distribution.
We represent the shape in terms of surface points and store it within a 3D grid, and the transition rule is trained only on the occupied cells by employing a sparse CNN (Graham et al.
The sparse representation can capture the high-resolution context information, and yet learn the effective rule enjoying the expressive power of deep CNN as demonstrated in various computer vision tasks (Krizhevsky et al.
; He et al.
Inspired by Bordes et al.
, our model learns sequences that are slightly different from the sampling chain but converge to the full shapes in the training data.
The network successfully learns the update rules of CA, such that a single inference samples from the distribution of diverse modes along the surface.
The contributions of the paper are highlighted as follows: (1) We propose Generative Cellular
Automata (GCA), a Markov chain based 3D generative model that iteratively mends the shape to a learned distribution, generating diverse and high-ﬁdelity shapes.
(2) Our work is the ﬁrst to learn the local update rules of cellular automata for 3D shape generation in voxel representation.
This enables the use of an expressive sparse CNN and reduces the search space of voxel occupancy by fully exploiting sparsity and connectivity of 3D shapes.
(3) Extensive experiments show that our method has competitive performance against the state-of-the-art models in probabilistic shape completion and shape generation.
3D S HAPE G ENERATION WITH G ENERATIVE C ELLULAR A UTOMATA
Let Z n be an n -dimensional uniform grid space, where n = 3 for a 3D voxel space.
A 3D shape is represented as a state s ⊂ Z 3 , which is an ordered set of occupied cells
c ∈ Z 3 in a binary occupancy grid based on the location of the surface.
Note that our voxel representation is different from the conventional occupancy grid, where 1 represents that the cell is inside the surface.
Instead, we only store the cells lying on the surface.
This representation can better exploit the sparsity of 3D shape than the full occupancy grid.
The shape generation process is presented as a sequence of state variables s 0: T that is drawn from the following Markov Chain:
[Equation]
where p 0 is the initial distribution and p θ is the homogeneous transition kernel parameterized by θ .
We denote the sampled sequence s
→ s 1 → · · · → s T as a sampling chain .
Given the data set D containing 3D shapes x ∈ D , our objective is to learn the parameters θ of transition kernel p θ , such that the marginal distribution of ﬁnal generated sample p ( s T ) =
(cid:80) s 0:
[Equation]
1 p 0 ( s 0 ) (cid:81) 0 ≤ t<T p θ ( s t +1 |
[Equation]
t ) is close to the data distribution.
The initial state s 0 can be deﬁned differently depending on the task to solve.
For the task of probabilistic shape completion, s 0 is given to be the partial input shape.
For shape generation, we set the initial state s 0 to be the most simple state we can think of, a single cell { c } .
Figure 1 presents examples of sampling chains of shape generation, where the starting shape sis merely a single cell.
The GCA further splits the transition kernel p θ ( s t +1 | s t ) to be the combination of local update rules on individual occupied cells c i ∈ s t , as depicted in Figure 2.
The cellular transition is implemented with the sparse convolution, which is translation invariant if implemented with a fully convolutional network, and outputs the distribution of local occupied cells.
Then individual predictions are aggregated by cell-wise averaging, resulting in the binary probability distribution for occupancy of each cell that follows the Bernoulli distribution:
[Equation]
The next state s t +1 is sampled independently for individual cells from the obtained distribution and the sampling chain continues to the next time step.
For each transition p θ ( s t +1 | s t ) , we limit the search space of the occupied cells by conﬁning our predictions within the neighborhood of the occupied cells.
The underlying assumption is that the occupied cells of a valid shape are connected, a successful generation is possible by progressive growing into the immediate neighborhood of the given state.
Speciﬁcally, the output of the sparse convolution is the occupancy probability of neighborhood cells p i
=
p θ ( N ( c i ) | s t ) , where the neighborhood cells are those fall within a radius r ball centered at the cell, N ( c i )
= { c (cid:
) ∈
Z n | d ( c i , c (cid:48) ) ≤ r } given a distance metric d .
Other cells are ignored assuming they have probability 0 of occupancy.
If the input state has M occupied cells s t = { c 1 , · · · , c M } , the sparse convolution predicts the occupancy probability of individual cells with N -dimension vectors P
= { p 1 , · · · , p M } , where N is the number of neighborhood cells ﬁxed by the distance threshold r within the uniform grid Z n .
After the cell-wise averaging step, the aggregated probability is nonzero for coordinates in N ( s t ) =
(cid:83) c ∈ s t N ( c ) .
Then the cell-wise sampling in Eq.
(2) is performed only within N ( s t ) , instead of the full grid Z n , leading to an efﬁcient sampling procedure.
The stochastic local transition rule p θ ( N ( c i ) | s t ) changes the state of a cell’s immediate neighborhood N ( c i ) , but the inference is determined from a larger perception neighborhood. In contrast, classical cellular automata updates a state of a cell determined by a ﬁxed rule given the observation of the cell’s immediate neighborhood. The large perception neighborhood of GCA is effectively handled by deep sparse convolutional network, and results in convergence to a single consistent global shape out of diverse possible output shapes as further discussed in the appendix F.
T RAINING G ENERATIVE C ELLULAR A UTOMATA
We aim to learn the parameters for the local transition probability p θ ( N ( c i ) | s t ) , whose repetitive application generates shape that follows the complex distribution of the data set.
If we have sequences of sampling chains, then all current and next states can serve as the training data.
Because we only have the set of complete shapes D , we emulate the sequence of sampling chain and obtain the intermediate states.
The emulated sequence of a sampling chain may start from an arbitrary state, and needs to converge to the full shape x ∈ D after local transitions to the neighbor of the previous state.
A naive method would be to sample the next state s t from the sampling chain and maximize p θ ( x ∩ N ( s t ) | s t ) , the probability of the shape that is closest to x among reachable forms from the current state 1 , similar to scheduled sampling (Bengio et al.
While this approach clearly emulates the inference procedure, it leads to learning a biased estimator as pointed out in Huszár (2015).
More importantly, the emulated sequence cannot consistently learn the full shape x as it is not guaranteed to visit the state s such that x ⊂ N ( s ) .
We instead employ the use of infusion training procedure suggested by Bordes et al.
Speciﬁcally, the infusion chain , denoted as ˜ s
→ ˜ s 1 → ... → ˜ s T , is obtained as following:
[Equation]
where q 0 indicates the initial distribution of infusion chain, and q t is the infusion transition kernel at time step t .
For probabilistic shape completion ˜ s 0 is sampled as a subset of x , while for shape generation ˜ s 0 is a single cell c ∈ x .
The transition kernel q t is deﬁned for cells in the neighborhood ˜ c t +1 ∈ N (˜ s t ) as the mixture of p θ (˜ c t +1 i | ˜ s t ) and δ x (˜ c t +1 i ) , which are the transition kernel of the sampling chain and the infusion of the ground shape x , respectively.
δ x (˜ c t +1 i ) is crucial to guarantee the sequence to ultimately reach the ground truth shape, and is formulated as the Bernoulli distribution with probability 1, if ˜ c t +1 i ∈ x , else 0.
We set the infusion rate to increase linearly with respect to time step, i.e., α t = max( wt, 1) , where w > 0 is the speed of infusion rate as in Bordes et al. (2017).
We can prove that the training procedure converges to the shape x in the training data if it is composed of weakly connected cells.
We ﬁrst deﬁne the connectivity of two states.
Deﬁnition 1.
We call a state ˜ s (cid:48) to be partially connected to state x , if for any cell b ∈ x , there is a cell c 0 ∈ ˜ s (cid:48)
∩ x , and a ﬁnite sequence of coordinates c 0: T b in x that starts with c 0 and ends with c T b = b , where each subsequent elements are closer than given threshold distance r , i.e., for any b ∈ x, ∃ c 0: T b , such that c i ∈ x, d ( c i , c i +1 ) ≤ r , 0 ≤ i ≤ T b and c 0 ∈ ˜ s (cid:48) , c T b = b .
The shape x is partially connected to any ˜ s (cid:48)
(cid:54) = ∅ if we can create a sequence of coordinates between any pair of cells in x that is composed of local transitions bounded by the distance r .
This is a very weak connectivity condition, and any set that overlaps with x is partially connected to x for shapes with continuous surfaces, which include shapes in the conventional dataset.
Now assuming that the state ˜ s t (cid:48) is partially connected to the state x , we recursively create a sequence by deﬁning ˜ s t
+1 =
N (˜ s t ) ∩ x , which is the next sequence of infusion chain with infusion rate 1.
Since we use a linear scheduler for infusion rate, we can assume that there exists a state ˜ s t (cid:48) such that infusion rate α t (cid:48)
= 1 .
The following proposition proves that the sequence (˜ s t ) t ≥ t (cid:48) converges to x with local transitions.
Proposition 1.
Let state ˜ s t (cid:48) be partially connected to state x , where x has a ﬁnite number of occupied cells.
We denote a sequence of states ˜ s t (cid:48) : ∞ , recursively deﬁned as ˜ s t +1 =
N (˜ s t ) ∩ x .
Then, there exists an integer T (cid:48) such that ˜ s t
= x, t ≥ T (cid:48) .
Proof.
The proof is found in the appendix A.
The proposition states that the samples of infusion chain eventually converges to the shape x , thus we can compute the nonzero likelihood p ( x | ˜ s T ) during training if T is large enough.
One can also interpret the training procedure as learning the sequence of states that converges to x and is close to the sampling chain.
We empirically observe that most of the training samples converge to the shape x before the infusion rate becomes 1.
The training procedure can be summarized as the following:
Sample infusion chain ˜ s 0: T from ˜ s 0 ∼ q 0 (˜ s 0 | x ) , ˜ s t +1 ∼ q t (˜ s t +1 | ˜ s t , x ) .
For each state ˜ s t , maximize the log-likelihood that has the closest form to x via gradient descent, i.e., θ ← θ + η ∂ log p θ ( x ∩N (˜ s t ) | ˜ s t ) ∂θ .
The full training algorithm utilizes a data buffer to de-correlate the gradients of subsequent time steps, and accelerates the process by controlling the time steps based on the current state.
More details regarding the full training algorithm can be found in the appendix B.
E XPERIMENTS
We demonstrate the ability of GCA to generate high-ﬁdelity shapes in two tasks: probabilistic shape completion (Sec. 4.1) and shape generation (Sec. 4.2).
State-of-the-art works on both tasks generate shapes using point cloud whereas ours uses grid structure.
For comparison, we extract high-resolution points from the CAD model and map them into 64 3 voxel grid.
Individual shapes in the dataset are centered and uniformly scaled to ﬁt within the cube [ − 1 , 1] 3 .
We also present additional analysis on how the sparse representation and local transition of GCA can successfully learn to generate ﬁne resolution shapes with continuous geometry (Sec. 4.3).
Details regarding the training settings and baselines are reported in the appendix G.
P ROBABILISTIC S HAPE C OMPLETION
Dataset and implementation details.
The probabilistic shape completion is tested with PartNet (Mo et al.
and PartNet-Scan (Wu et al.
(2020)) dataset, where objects in ShapeNet(Chang et al.
(2015)) are annotated with instance-level parts.
For each instance, we identify the input partial object by randomly choosing parts from the complete shape, and generating a diverse set of complete shapes.
PartNet-Scan dataset simulates the real-world situation where partial scans suffer from part-level incompleteness by randomly selecting parts from the PartNet and virtually scanning the remaining parts.
We validate our approach on chair, lamp, and table categories following Wu et al.
We use neighborhood radius r = 3 , T = 70 with infusion speed w = 0 .
005 for all datasets.
Following the work of Wu et al.
(2020), for each partial shape in the test set, we generate ten completion results and sample 2,048 points from occupied cells.
We compare the performance of probabilistic shape completion of GCA against cGAN (Wu et al.
(2020)), cGAN and its variations (cGAN-im-l2z and cGAN-im-pc2z) 2 , with 3D-IWGAN (Smith [Table] & Meger (2017))
The qualitative results in Figure 3 and the appendix H clearly show that our highresolution completion exhibits sophisticated geometric details compared to the state-of-the-art.
Our superior performance is further veriﬁed in the quantitative results reported in Table 1 with three metrics: minimal matching distance (MMD), total mutual difference (TMD), and unidirectional
Hausdorff distance (UHD).
MMD and TMD are reported after generated samples are centered due to translation invariant nature of our model.
The detailed description regarding the evaluation metrics are found in the appendix G.3.
We outperform all other methods in MMD and TMD on average, and achieve comparable or the best results in UHD.
The results indicate that we can generate high ﬁdelity (MMD) yet diverse (TMD) shapes while being loyal to the given partial geometry (UHD).
We observe an extremely large variation of completion modes in the lamp dataset, which is the dataset with the most diverse structure while having a high level of incompleteness in the input partial data.
This is because the lamp dataset contains fragmented small parts that could be selected as an highly incomplete input.
We include further discussion about the diversity in the lamp dataset in the appendix E. Multiple category completion .
While previous works on shape completion are trained and tested individual categories separately, we also provide the results on training with the entire category, denoted as GCA (joint) in Table 1.
The performance of jointly trained transition kernel does not signiﬁcantly differ to those of independently trained, demonstrating the expressiveness and high capacity of GCA.
In addition, interesting behavior arises with the jointly trained GCA.
As shown in the left image of Figure 5, given ambiguous input shape, the completed shape can sometimes exhibit features from categories other than that of the given shape.
Furthermore, GCA is capable of completing a scene composed of multiple objects although it is trained to complete a single object (Figure 5, right). We believe that this is due to the translation invariance and the local transition of GCA. As discussed in Section 2, the deep network observes relatively large neighborhood, but GCA updates the local neighborhood based on multiple layers of sparse convolution which is less affected by distant voxels. The information propagation between layers of sparse convolutional network (Graham et al.
(2018)) is mediated by occupied voxels, which effectively constrains the perception neighborhood to the connected voxels.
As a result, the effect of separated objects are successfully controlled.
We also include additional examples in the appendix D on how the GCA trained in one category completes the unseen category.
4. S HAPE G ENERATION
Dataset and implementation details.
We test the performance of shape generation using the
ShapeNet (Chang et al.
(2015)) dataset, focusing on the categories with the most number of shapes: airplane, car, and chair, as presented in Yang et al.
We use the same experimental setup as Cai et al.
(2020), and sample 2,048 points from the occupied cells of the generate shape and center the [Figure] [Table] [Figure]
[Table]
[Figure] [Table] results shape, due to translation invariant aspect of our model, for a fair comparison. We use neighborhood size r = 2 with L 1 distance metric, T = 100 inferences, and infusion speed w = 0 .
005 for airplane and car dataset, and r = 3 for chair category, which tend to converge better.
The quantitative results of shape generation are reported in Table 2.
We compare the performance of our approach against recent point cloud based method: r-GAN (Achlioptas et al.
(2018)), GCN-GAN (Valsesia et al.
, Tree-GAN (Shu et al.
, Pointﬂow (Yang et al.
, ShapeGF
(Cai et al.
(2020)), a voxel-based method: 3D-IWGAN (Smith & Meger (2017)), and training set.
The scores assigned to training set can be regarded as an optimal value for each metric.
We evaluate our model on three metrics, 1-nearest-neighbor-accuracy (1-NNA) coverage (COV), and minimal matching distance (MMD) as deﬁned in the appendix G.3.
Our approach achieves the state-of-the-art results on 1-NNA of car category.
As remarked by Yang et al.
(2019), 1-NNA is superior on measuring the distributional similarity between generated set and test set from the perspective of both diversity and quality.
Our method also achieves state-of-the-art results on COV of car, implying that our method is able to generate diverse results.
Note we are using a homogeneous transition kernel conﬁned within the local neighborhood of occupied cells, but can still achieve noticeable performance on generating a rich distribution of shape.
MMD is a conventional metric to represent the shape ﬁdelity, but some results achieve scores better than the training set which might be questionable (Yang et al.
We visualize our shape generation results in Figure 4 and in the appendix I.
4. A NALYSIS ON N EIGHBORHOOD AND C ONNECTIVITY
GCA makes high-resolution predictions by only handling the occupied voxels and their neighborhood, and overcome the limitation of memory requirement of voxel-based representation of 3D shape.
In
Figure 6, we empirically analyze the required search space during the shape generation process that starts from a single cell and evolves to the full shape.
The occupied voxels take approximately 2% of the total volume (solid lines), and their neighborhood adds up to 2-8% (dashed lines). After a certain [Figure]
Top, front, and side views of generation process are shown with r = 3 , L 1 metric neighborhood, where the diameter of the lampshade is over 30.
Given the partial shape of the shade, GCA is able to generate the body of the lamp that is disconnected from the input.
amount of time steps, the growing speed of the search space gradually decreases, implying that our method tends to converge and maintain the generated shape.
The large structural variation observed in the lamp dataset leads to interesting observation on the neighborhood size of GCA and the connectivity of the shape.
When r = 1 , nearly 10% of the infusion chain data fails to meet the stopping condition (cover more than 95% of x , see the training detail in the appendix B) with time step T = 100 .
This is because GCA trained on a small neighborhood size, while enabling the transition kernel to be trained quickly, lacks the ﬂexibility to model disconnected shapes even after large time steps.
On the other hand, increased neighborhood size can capture disjoint parts at the expense of larger search space and instability.
When r = 10 , the trained transition kernel generates output that is noisy or unrelated to the input partial shape.
We believe that the transition kernel can not be trained to cover the entire search space as the neighborhood size increases cubic to r .
A few bad sampling steps can lead to a state that is far from the previous state or unobserved during training.
The effects of hyperparameters are further discussed in the appendix C.
We also clarify the notion of connectivity in relation to the neighborhood size.
While we mostly demonstrate the performance of GCA generating 3D shapes with continuous surface, GCA can surely generate disjoint parts as long as the distance between parts is within the radius r .
Besides, GCA is ﬂexible enough to learn to generate parts that are farther than r .
r is merely the distance of cells between adjacent steps, and it is possible to learn the sequence of states that generates a temporary bridge to reach disconnected parts after a few steps.
Figure 7 shows an observed sequence of a sampling chain that generates a temporary bridge from the shade to the body of the lamp further than the neighborhood size.
After the sampling chain reaches the main body, GCA removes the bridge and successfully generates the full shape.
R ELATED W ORKS 5. G ENERATIVE M ODELS
Autoregressive models.
PixelCNN and its variants (van den Oord & Kalchbrenner (2016); van den
Oord et al.
(2016)) sequentially sample a single pixel value at a time, conditioned on the previously generated pixels.
PointGrow (Sun et al.
(2020)) extends the idea to 3D by sampling the coordinates of points in a sequential manner.
While these approaches lead to tractable probabilistic density estimation, inferring one pixel/point with a single inference is not scalable to high resolution 3D voxel space.
GCA, on the other hand, can grow to the shape occupying any number of voxels in the neighborhood at each inference.
Markov chain models.
Previous works learn the transition kernel of Markov chain operating on the input space which eventually produces samples matching the data distribution (Sohl-Dickstein et al.
; Anirudh et al.
; Bordes et al.
The diffusion-based models (Sohl-Dickstein et al.
; Anirudh et al.
(2017)) start from a random noise distribution and incrementally denoise the input to generate the data.
They learn the reverse of a diffusion process, which begins from the data and gradually adds noise to become a factorial noise distribution.
On the other hand, the work of infusion training (Bordes et al.
slightly infuses data to input dimension during training, and learns the chain biased towards the data.
This removes the process of inverting the diffusion chain and allows the chain to start from any distribution.
The training of GCA utilizes the technique of infusion, enabling to train on both shape generation and completion.
3D generative models .
Recent works on 3D generative models (Yang et al.
; Cai et al.
Wu et al.
(2020)) achieve noticeable success with point cloud based representation.
They are based on
PointNet (Qi et al.
(2016)), one of the most widely-used neural network architecture consuming point cloud.
PointNet condenses the 3D shape into a single global feature vector to achieve permutation invariance, but in turn lacks the representation power of local context observed in deep neural architecture.
On the other hand, voxel-based generation methods (Wu et al.
; Smith & Meger (2017)) can capture local features by directly adapting a CNN-based architecture, but suffer from immense memory consumption in high-resolution.
Recent works of sparse CNN (Graham et al.
; Choy et al.
(2019)) solves the problem of voxel representation by exploiting sparsity, and outperforms other methods by a signiﬁcant margin in the ﬁeld of 3D semantic segmentation.
To the best of our knowledge, we are the ﬁrst to utilize the expressive power of sparse CNN to learn a probabilistic 3D generative model in a high-resolution 3D grid.
5. C ELLULAR A UTOMATA
Cellular automata (CA) is introduced to simulate biological or chemical systems (Wolfram (1982);
Markus & Hess (1990)).
CA consists of a grid of cells where individual cells are repeatedly updated with the rule depending only on the state of neighborhood cells.
Each cell is updated with the same set of local rules, but when the update is repeatedly distributed in the entire grid, complex and interesting behavior can emerge.
However, CA requires a ﬁxed rule to be given.
Wulff & Hertz (1992) learn simple rules with a neural network and model the underlying dynamics of CA. Neural Cellular
Automata (Mordvintsev et al. (2020)) shows an interesting extension of CA that incorporates neural network to learn the iterative update rule and successfully generates a pre-speciﬁed image. While the beneﬁts of CA is not clear in the image domain, we show that the local update rule of CA can excel in generating 3D shape, which is sparse and connected, by achieving near state-of-the-art performance. There is one major difference of GCA compared to the classical CA.
The transition kernel employs the deep sparse CNN and the effective perception neighborhood is much larger than the update neighborhood.
With the extension, GCA has the capacity to perceive the complex context and concurrently generates high-ﬁdelity local shape as demonstrated by multi-category and multi-object generation in Figure 5.
C ONCLUSION AND F UTURE W ORK
In this work, we present a probabilistic 3D generative model, named GCA, capable of producing diverse and high-ﬁdelity shapes.
Our model learns a transition kernel of a Markov chain operating only on the spatial vicinity of an input voxel shape, which is the local update rules of cellular automata.
We effectively reduce the search space in a high resolution voxel space, with the advantage of employing a highly expressive sparse convolution neural network that leads to state-of-the-art performance in probabilistic completion and yields competitive results against recent methods in shape generation.
Although our experiments are mainly focused on shape generation, we believe our framework is capable of modeling a wide range of sequential data, which tends to be sparse and connected.
For instance, particle-based ﬂuid simulation models continuous movement of ﬂuid particles, where the local update rules of our approach can be applied.
A P ROOF OF P ROPOSITION
We present the proposition in Sec. 3 and its proof.
Proposition 1.
Let state ˜ s t (cid:48) be partially connected to state x , where x has a ﬁnite number of occupied cells.
We denote a sequence of states ˜ s t (cid:48) : ∞ , recursively deﬁned as ˜ s t +1 =
N (˜ s t ) ∩ x .
Then, there exists an integer T (cid:48) such that ˜ s t
= x, t ≥ T (cid:48) .
Proof.
If ˜ s T (cid:48)
= x , ˜ s T (cid:48) +
= N (˜ s T (cid:48) )
∩ x = x and ˜ s t = x for t ≥ T (cid:48) .
Now we show that there exists an integer T (cid:48) such that ˜ s T (cid:48)
=
x by showing ˜ s T (cid:48) ⊂ x and ˜ s T (cid:48)
⊃ x .
We ﬁrst prove the former by showing that sequence of states ˜ s t (cid:48) : ∞ is an increasing sequence bounded by x . ∀ t > t (cid:48) , ˜
[Equation]
˜
[Equation]
Now we show ˜ s T (cid:48)
⊃ x to complete the proof.
Recall the deﬁnition partially connected .
Deﬁnition 1.
We call a state ˜ s (cid:48) to be partially connected to state x , if for any cell b ∈ x , there is a cell c 0 ∈ ˜ s (cid:48)
∩ x , and a ﬁnite sequence of coordinates c 0: T b in x that starts with c 0 and ends with c T b = b , where each subsequent elements are closer than given threshold distance r , i.e., for any b ∈ x, ∃ c 0: T b , such that c i ∈ x, d ( c i , c i +1 ) ≤ r , 0 ≤ i ≤ T b and c 0 ∈ ˜ s (cid:48) , c T b = b .
By deﬁnition, there exists a sequence of coordinates c
b 0: T b for each coordinate b ∈ x .
Now we show c bt ∈ ˜ s t (cid:48)
+ t using mathematical induction.
c b 0 ∈ ˜ s t (cid:48) .
Assuming c bt ∈ ˜ s t (cid:48)
+ t for t > 0 , c bt +1 ∈ N ( c bt )
∩ x ⊂ N (˜ s t (cid:48)
+ t ) ∩ x = ˜ s t (cid:48)
+ t +
So c bT b = b ∈ ˜ s t (cid:48)
+ T b .
If we set T (cid:48)
=
max b ∈ x T b , x ⊂ (cid:83) b ∈ x ˜ s T b ⊂ ˜ s T (cid:48) holds, where the second subset holds due to the increasing property of ˜ s t (cid:48) :
∞ proven above, i.e., ˜ s t 1 ⊂ ˜ s t 2 for t 1 < t 2 .
Thus we conclude that x ⊂ ˜ s T (cid:48) .
B F ULL D ESCRIPTION OF T RAINING P ROCEDURE
The training procedure described in Sec.
3 introduces the infusion chain and provides high-level description of the training procedure.
When the training data is sampled from the infusion chain, we utilizes the data buffer B as presented in experience replay (ji Lin (1992)).
Sequential state transitions of the same data point, including our proposed infusion chain, are highly correlated and increase the variance of updates.
With the data buffer B , we can train the network with a batch of state transitions from different data points, and de-correlate gradients for back-propagation.
The overall training procedure is described in Algorithm 1.
The buffer B carries tuples that consists of current state s , the whole shape x , and the time step t .
Given the maximum budget |B| , the buffer is initialized by the tuples (˜ s 0 , x, 0) where ˜ s 0 ∼ q 0 (˜ s 0 | x ) for a subset of data x ∈ D .
For probabilistic shape completion q 0 (˜ s 0 | x ) is a subset of x , and for shape generation we sample just one cell { c } ⊂ x .
Then each training step utilizes M tuples of mini-batch popped from the buffer B .
We update the parameters of neural network by maximizing the log-likelihood of the state that is closest to x among the neighborhood of the current state, i.e., arg max θ log p θ ( x ∩ N (˜ s t ) | ˜ s t ) .
Then we sample the next state from the infusion chain as deﬁned in Eq.
If the next state does not meet the stopping criterion, then the tuple with the next state (˜ s t
i +1 i , x i , t i + 1) is pushed back to the buffer.
Else the buffer samples new data from the dataset.
While the stopping criterion (line 9) should reﬂect the convergence to the whole shape x , the amount of time steps needed to generate the complete shape varies signiﬁcantly depending on the incompleteness
1: Given dataset D , neural network parameter θ 2: Initialize buffer B with maximum budget |B| from D 3: repeat 4:
Pop mini-batch
(˜ s t i i , x i , t i ) i =1: M from buffer B 5:
L =6: for each index i in mini-batch do 7:
L ← L + log p θ ( x i ∩ N (˜ s t i i ) | ˜ s
t i i ) 8: ˜ s t
i +1 i ∼ q t
i (˜ s t i +1 i | ˜ s t
i i , x i ) 9: if ˜ s t
i +1 i does not meet stopping criterion then 10:
Push (˜ s t i +1 i , x i , t i + 1) into buffer B 11: else 12:
Sample x i ∈ D 13:
Sample ˜ s
i ∼ q
(˜ s 0 i | x i ) 14:
Push (˜ s
i , x i , 0) into buffer B 15: end if 16: end for 17:
Update parameters θ ← θ + η ∂ L ∂θ 18: until convergence of training [Figure] MM D MMD TMD
{+UHD 
 T M D 5. UHD of the initial shape, the efﬁciency of the stochastic transitions, and the complexity of the full shape.+} In addition, we need to learn to stay at the complete state once it is reached.
We propose a simple solution with an adaptive number of training steps for each data: When ˜ s t contains 95% of the x for the ﬁrst time, we train only constant ˆ T more time steps.
The additional ˆ T steps lead to learn a transition kernel similar to that of identity, implicitly learning to stay still after the generation is completed as in Anirudh et al.
GCA framework is successfully trained to generate a wide range of shapes even though our transition kernel is conﬁned within its local neighborhood.
Over 99% of the training data in generation and completion experiments satisﬁes the stopping criterion, except for lamp in PartNet-Scan dataset on shape completion, in which 97% of data satisﬁes the stopping criterion.
C A BLATION STUDY ON HYPERPARAMETERS
In this section, we further investigate the effects of hyperparameters of neighborhood radius r , infusion speed w , and time step T , with probabilistic shape completion on lamp dataset.
The default hyperparameters are set to r = 3 , w = 0 .
005 , T = 70 , and for each ablation study, only the corresponding feature is changed.
For the study on neighborhood radius and infusion speed, the networks were retrained with the matching hyperparameters, while the ablation study on time steps show the result of the model trained on default hyperparameter but tested with the variation of time step T .
The Figure 8 shows the effects of r , w and T on MMD (quality), TMD (diversity), and UHD (ﬁdelity).
The effect of the neighborhood radius r .
The neighborhood radius r is the size of update neighborhood of the probabilistic distribution for individual cells, N ( c i )
{+= { c (cid:
+}
) ∈
Z n | d ( c i , c (cid:48) ) ≤ r } .
When the radius r is too small ( r = 1 , 2 ), the MMD (quality) is considerably high compared to when r = 3 , 4 .
Because the size of update is small, models require more time steps to reconstruct the whole shape, and are not able to generate the disconnected lamps as shown in Figure 7.
When the neighborhood size is adequate ( r = 3 , 4 ), GCA produces ﬁne reconstructed shapes with reasonable scores on all metrics.
However, when the radius is too high ( r = 5 , 10 ), the model yields shapes that are considerably irrelevant to the given initial state, resulting in a high TMD and UHD scores.
Due to the large possible transition states, few bad samplings lead to states that are irrelevant to the initial state, resulting in the degradation of performance.
The effect of the infusion speed w .
The infusion speed controls how likely the groudtruth shape is injected ( α t = max( wt, 1) in Eq.
(3)) with the increasing time step.
When the infusion speed is too low, the infusion chain is close to the sampling chain, but it is less likely to visit a state that observes the whole complete state.
Also, as Huszár (2015) said, the model learns a biased estimator, which implies that GCA may not converge to the correct model.
The results in Figure 8 show that MMD and
UHD is high when the infusion speed w = 0 , 0 .
001 compared to when w = 0 .
This indicates that small w generates shapes with worse quality and ﬁdelity.
On the other hand, when the infusion speed is set too high ( w = 0 .
03 , 0 . 05 ), the discrepancy between the infusion chain and sampling chain increases.
We noticed the diverging behavior of GCA, when the infusion speed was set too high.
Bordes et al.
(2017) state that the optimal value for the infusion speed differs depending on the time step T .
We empirically saw that w = 0 .
005 produced the best result for both shape generation and completion with T = 100 and T = 70 .
The effect of the number of time step T .
{+The time step T indicates the number of state transitions performed to generate the shape s 
+}
→ s 1 → ... → s T .
The right plot of Figure 8 shows the performance of GCA with different time steps trained on the default hyperparameter.
Even though
MMD is lowest when T=30, some lamps fail to complete the shape in the given time steps.
As the time steps increase, all scores tend to increase by morphing the initial state to other the complete state.
However, we would like to emphasize that the scale of the plot is relatively small and the model is able to keep the MMD (quality) below 0.002 even when ran on 200 time steps.
This is substantially low considering that the MMD of cGAN (Wu et al.
(2020)) is 0.00197.
This demonstrates that GCA is able to maintain the quality of shapes, being robust to the increasing time step.
D C OMPLETION RESULTS ON UNSEEN INITIAL STATES
We investigate the behavior of GCA when an unseen input is given as the initial state.
The Figureshows the result of GCA trained on chair completion, but a partial lamp is given as the input.
The behavior can be classiﬁed largely in three classes.
First, the model respects the initial state and is able to generalize to a novel shape as in Figure 9 (a).
Second, as in Figure 9 (b) and (c) which are the most common cases, the model deforms the initial state into a trained state and generates results learned during training.
The ﬁnal state contains a state similar to the initial, but deformed to a shape that belongs to the trained category.
Lastly, like in Figure 9 (d), if the initial state is dissimilar to the visited state, it fails to generalize and starts diverging.
Among the results presented in Sec. 4, our diversity score (TMD) for shape completion is signiﬁcantly higher than the state-of-the-art with lamp dataset (Table 1).
By further investigating instances with high TMD scores in lamp dataset, we could observe that the input part is small and highly incomplete.
The input partial data is created by randomly selecting a part from the instance, and the part labels in lamp dataset are fragmented and diverse with less regular structure with many small parts.
A typical example with high TMD score is shown in Figure 10.
The input is a small part of a lamp, and our completion results cover a wide variety of lamps including table lights and ceiling lights, and still exhibit ﬁne geometry.
In contrast, cGAN (Wu et al.
(2020)) handles the ambiguity with consistently blurry output.
The TMD score for this speciﬁc example is 20.45 for GCA, while the cGAN achieves 6.592.
F C ONVERGING TO A S INGLE M ODE
Our scalable formulation can generate multiple voxels at a single inference time.
This is unique characteristic of our formulation compared to other autoregressive models (van den Oord et al.
Sun et al.
(2020)), and the key to handle high-resolution 3D shapes.
Speciﬁcally, The multiple voxels of the next state are sampled from a conditionally independent occupancy for each cell, i.e., p θ ( s t +1 | s t ) =
(cid:81) c ∈N ( s t ) p θ ( c | s t ) .
While we gain efﬁciency by making multiple independent decisions in a single inference, there is no central algorithm that explicitly controls the global shape.
In other words, we can view the generation process of GCA as morphogenesis of an organism, but there is no uniﬁed ‘DNA’ to eventually move towards a single realistic shape.
We indeed encounter rare failure cases that make multiple conﬂicting decisions on the global structure, as presented in
Figure 11.
However, for most of the cases, our model is capable of generating a globally consistent shapes, converging to a single mode out of multi-modal data distribution.
For example, when a chair seat is given as the partial input shape as in Figure 12, there are multiple possible modes of shape completion, including four-leg chairs or swivel chairs.
The ambiguity is present in s 2:6 , where both the center and the corners have high probability of chair legs.
GCA eventually picks a mode and decides to erase the legs at the corners and only grow towards the center, creating a swivel chair.
As shown in this example, the transition kernel of GCA observes the change in the context and eventually converges to a globally consistent mode even with independent samples of individual cells.
G E XPERIMENTAL D ETAILS G. N EURAL N ETWORK A RCHITECTURE AND I MPLEMENTATION D ETAILS
All experiments conducted use a variant of U-Net (Ronneberger et al.
architecture implemented with sparse convolution library MinkowskiEngine (Choy et al.
, depicted in Figure 13. We train our method using the Adam (Kingma & Ba (2015)) optimizer with an initial learning rate of 5e-4 and the batch size 32.
The learning rate decays by 0.5 every 100k steps.
All experiments are run on RTX 2080 ti 11GB GPU, except for the analysis on the neighborhood size with r = 10 , which run on Titan RTX 24GB GPU. G. B ASELINES All experiments in Table 1 and Table 2 are excerpted from Wu et al. (2020) and Cai et al.
(2020) except the results of 3D-IWGAN (Smith & Meger (2017)). 3D-IWGAN was trained on the dataset same as ours for 4000 epochs using the author’s ofﬁcal code: https://github . com/ EdwardSmith1884/3D-IWGAN , with the default hyperparameters.
Since the original code only supports 32 x 32 x 32 voxel resolution, we added extra convolution / deconvolution layer for the
GAN’s discriminator, generator and VAE, generating voxel 64 x 64 x 64 resolution.
We provide a more detailed explanation regarding quantitative metrics for evaluation of our approach.
Since we compare our method against recent point cloud based methods, we convert voxels into point clouds simply by treating the coordinates of occupied voxels as points.
For all of the evaluations, we use the Chamfer distance (CD) to measure the similarity between shapes represented as point clouds.
Chamfer distance between two sets of point cloud X and Y is formally deﬁned as
[Equation]
Probabilistic Shape Completion .
We employ the use of minimal matching distance (MMD), total mutual difference (TMD), and unidirectional Hausdorff distance (UHD), as in Wu et al.
Let S p be the set of input partial shapes and S c be the set of complete shapes in the dataset.
For each partial shape P ∈ S p , We generate k = 10 complete shapes C P 1: k .
Let G =
{ C P 1: k } be the collection of the entire generated set started from all elements in S p .
• MMD measures the quality of the generated set.
For each complete shape in the test set, we compute the distance to the nearest neighbor in the generated set G and average it, which is formally deﬁned by
[Equation]
• TMD measures the diversity of the generated set.
We average the Chamfer distance of all pairs of the generated set for the same partial input, formally deﬁned by
[Equation]
• UHD measures the ﬁdelity of the completed results against the partial inputs.
We average the unidirectional Hausdorff distance d HD from the partial input to each of the k completed results, formally deﬁned as
[Equation]
Shape Generation .
We employ the use of 1-nearest-neighbor-accuracy (1-NNA), coverage (COV, and minimal matching distance (MMD)) as in Cai et al.
Since MMD was introduced above, we state the deﬁnition of 1-NNA and COV.
Let S g be the set of generated shapes and
S
r be the set of reference shapes.
• 1-NNA , proposed by Lopez-Paz [Equation] Oquab [Equation]
, evaluates whether two distributions are identical. For shape X , we denote the nearest neighbor as N X = arg min Y ∈ S − X d CD ( X, Y ) , where S − X represents the set including the entire generated and reference shapes except itself, S − X =
S r ∪ S g − X .
1-NNA is deﬁned to be
[Equation]
where 1 is an indicator function.
The optimal value of 1-NNA is 50%, when the distribution of two sets are equal, unable to distinguish the two sets.
• COV measures the proportion of shapes in the reference set that are matched to at least one shape in the generated set, formally deﬁned by
[Equation]
H A DDITIONAL S AMPLES O N P ROBABILISTIC C OMPLETION
I A DDITIONAL S AMPLES O N S HAPE G ENERATION