user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Learning to Infer and Execute 3D Shape Programs

Paper content:
Human perception of 3D shapes goes beyond reconstructing them as a set of points or a composition of geometric primitives: we also effortlessly understand higher-level shape structure such as the repetition and reflective symmetry of object parts.
In contrast, recent advances in 3D shape sensing focus more on low-level geometry but less on these higher-level relationships.
In this paper, we propose 3D shape programs, integrating bottom-up recognition systems with top-down, symbolic program structure to capture both low-level geometry and high-level structural priors for 3D shapes.
Because there are no annotations of shape programs for real shapes, we develop neural modules that not only learn to infer 3D shape programs from raw, unannotated shapes, but also to execute these programs for shape reconstruction.
After initial bootstrapping, our end-to-end differentiable model learns 3D shape programs by reconstructing shapes in a self-supervised manner.
Experiments demonstrate that our model accurately infers and executes 3D shape programs for highly complex shapes from various categories.
It can also be integrated with an image-to-shape module to infer 3D shape programs directly from an RGB image, leading to 3D shape reconstructions that are both more accurate and more physically plausible.
Given the table in Figure 1 , humans are able to instantly recognize its parts and regularities: there exist sharp edges, smooth surfaces, a table top that is a perfect circle, and two lower, square layers.
Beyond these basic components, we also perceive higher-level, abstract concepts: the shape is bilateral symmetric; the legs are all of equal length and laid out on the opposite positions of a 2D grid.
Knowledge like this is crucial for visual recognition and reasoning (Koffka, 2013; Dilks et al., 2011) .Recent
AI systems for 3D shape understanding have made impressive progress on shape classification, parsing, reconstruction, and completion BID9 BID19 , many making use of large shape repositories like ShapeNet (Chang et al., 2015) . Popular
shape representations include voxels BID23 , point clouds BID9 , and meshes BID21 . While each
has its own advantages, these methods fall short on capturing the strong shape priors we just described, such as sharp edges and smooth surfaces.A few recent papers have studied modeling 3D shapes as a collection of primitives BID19 , with simple operations such as addition and subtraction BID15 . These representations
have demonstrated success in explaining complex 3D shapes. In this paper, we go
beyond them to capture the high-level regularity within a 3D shape, such as symmetry and repetition.In this paper, we propose to represent 3D shapes as shape programs. We define a domain-specific
language (DSL) for shapes, containing both basic shape primitives for parts with their geometric and semantic attributes, as well as statements such as loops to enforce higher-level structural priors.Inverse procedural graphics. The problem of inferring programs
from voxels is closely related to inverse procedural graphics, where a procedural graphics program is inferred from an image or declarative specification BID11 Št'ava et al., 2010) . Where the systems have been most
successful, however, are when they leverage a large shape-component library (Chaudhuri et al., 2011; BID14 or are applied to a sparse solution space BID20 . Kulkarni et al. (2015a) approached
the problem of inverse graphics as inference in a probabilistic program for generating 2D images, or image contours, from an underlying 3D model. They demonstrated results on several
different applications using parametric generative models for faces, bodies, and simple multi-part objects based on generalized cylinders. In this work, we extend the idea of
inverse procedural graphics to 3-D voxel representations, and show how this idea can apply to large data sets like ShapeNet. We furthermore do not have to match
components to a library of possible shapes, instead using a neural network to directly infer shapes and their parameters.A few recent papers have explored the use of simple geometric primitives to describe shapes BID19 Zou et al., 2017; , putting the classic idea of generalized cylinders BID12 Binford, 1971) or geons (Biederman, 1987) in the modern context of deep learning. In particular, BID15 extended these
papers and addressed the problem of inferring 3-D CAD programs from perceptual input. We find this work inspiring, but also
feel that a key goal of 3-D program inference is to reconstruct a program in terms of semantically meaningful parts and their spatial regularity, which we address here. Some other graphics papers also explore
regularity, but without using programs BID5 BID24 BID7 .Work in the HCI community has also addressed
the problem of inferring parametric graphics primitives from perceptual input. For example, BID6 proposed to learn to instantiate
procedural primitives for an interactive modeling system. In our work, we instead learn to instantiate multiple
procedural graphics primitives simultaneously, without assistance from a human user. The domain specific language (DSL) for 3D shapes. Semantics
depends on the types of objects that are modeled,
i.e., semantics for vehicle and furniture should be different. For details of DSL in our experimental setting, please refer
to supplementary.Program synthesis. In the AI literature, Ellis et al. (2018) leveraged symbolic
program synthesis techniques to infer 2D graphics programs from images, extending their earlier work by using neural nets for faster inference of low-level cues such as strokes (Ellis et al., 2015) . Here, we show how a purely end-to-end network can recover 3D
graphics programs from voxels, conceptually relevant to RobustFill (Devlin et al., 2017) , which presents a purely end-to-end neural program synthesizer for text editing. The very recent SPIRAL system (Ganin et al., 2018) also takes
as its goal to learn structured program-like models from (2D) images. An important distinction from our work here is that SPIRAL explains
an image in terms of paint-like "brush strokes", whereas we explain 3D voxels in terms of high-level objects and semantically meaningful parts of objects, like legs or tops. Learning to execute programs. Neural Program Interpreters (NPI) have
been extensively studied for
programs that abstract and execute tasks such as sorting, shape manipulation, and grade-school arithmetic BID10 Cai et al., 2017; Bošnjak et al., 2017) . In NPI BID10 , the key insight is that a program execution trace can
be decomposed into predefined operations that are more primitive; and at each step, an NPI learns to predict what operation to take next depending on the general environment, domain specific state , and previous actions. Cai et al. (2017) improved the generalization of NPIs by adding recursion
. Johnson et al. (2017) learned to execute programs for visual question and
answering. In this paper, we also learn a 3D shape program executor that renders 3D
shapes from programs as a component of our model.
We have introduced 3D shape programs as a new shape representation.
We have also proposed a model for inferring shape programs, which combines a neural program synthesizer and a neural executor.
Experiments on ShapeNet show that our model successfully explains shapes as programs and generalizes to shapes outside training categories.
Further experiments on Pix3D show our model can be extended to infer shape programs and reconstruct 3D shapes directly from color images.
We now discuss key design choices and future work.Analyzing the neural program executor.
We look deep into the intermediate representation of the neural program executor, which is a 64-dimensional vector output by the LSTM (see Figure 3) .
We manipulate individual dimensions and visualize the generated voxels.
FIG5 shows that these dimensions capture interpretable geometric features (e.g., height, radius, and number of repetitions).Design
of the DSL. Our design
of the DSL for shape programs makes certain semantic commitments. A DSL with
these semantics has advantages and disadvantages: it naturally supports semantic correspondences across shapes and enables better in-class reconstructions; on the other hand, it may limit the ability to generalize to shapes outside training classes. Our current
instantiation focuses on the semantics of furniture (a superclass, whose subclasses share similar semantics). Within this
superclass, our model generalizes well: trained on chairs and tables, it generalizes to new furniture categories such as beds. In future work
, we are interested in learning a library of shape primitives directly from data, which will allow our approach to adapt automatically to new superclasses or domains of shape.Structure search vs. amortized inference. For our program
synthesis task, we use neural nets for amortized inference rather than structure search, due to the large search space and our desire to return a shape interpretation nearly instantaneously, effectively trading neural net training time for fast inference at test time. Our model takes
5 ms to infer a shape program with a Titan X GPU. We also considered
various possible approaches for structured search over the space of shape programs, but decided that these would most likely be too our slow for our goals. One approach to structured
search is constraint solving. Ellis et al. (2015) used the
performant Z3 SMT solver (De Moura & Bjørner, 2008) to infer 2D graphics programs, taking 5-20 minutes for problems arguably simpler than our 3D shape programs. Other approaches could be based
on stochastic search, such as MCMC in the space of programs. For the related problem of inverse
graphics from 2D images, MCMC, like constraint solving, takes too long for perception at a glance BID1 . Efficient integration of discrete
search and amortized inference, however, is a promising future research direction.

assistant: text: An approach to infer shape programs given 3D models, with architecture consisting of a recurrent network that encodes a 3D shape and outputs instructions, and a second module that renders the program to 3D.