SolidGen: An Autoregressive Model for Direct B-rep Synthesis
Authors: Pradeep Kumar Jayaraman
Joseph George Lambourne
Nishkrit Desai
Karl Willis
Aditya Sanghi
Nigel J. W. Morris
Venue: Accepted by TMLR ()

Abstract: The Boundary representation (B-rep) format is the de-facto shape representation in computer-aided design (CAD) to model solid and sheet objects. Recent approaches to generating CAD models have focused on learning sketch-and-extrude modeling sequences that are executed by a solid modeling kernel in postprocess to recover a B-rep. In this paper we present a new approach that enables learning from and synthesizing B-reps without the need for supervision through CAD modeling sequence data. Our method SolidGen, is an autoregressive neural network that models the B-rep directly by predicting the vertices, edges, and faces using Transformer-based and pointer neural networks. Key to achieving this is our Indexed Boundary Representation that references B-rep vertices, edges and faces in a well-defined hierarchy to capture the geometric and topological relations suitable for use with machine learning. SolidGen can be easily conditioned on contexts e.g., class labels, images, and voxels thanks to its probabilistic modeling of the B-rep distribution. We demonstrate qualitatively, quantitatively, and through perceptual evaluation by human subjects that SolidGen can produce high quality, realistic CAD models.

Published in Transactions on Machine Learning Research (02/2023)
SolidGen: An Autoregressive Model for Direct B-rep Synthesis
Pradeep Kumar Jayaraman Autodesk Research
Joseph G. Lambourne Autodesk Research
joseph..ambbourreeaannttddk.k.k
Nishkrit Desai University of Toronto, Vector Instätute
risharttdeesa@@mail.uoooooo
Karl D.D. Willis Autodesk Research
kart.willis@aauttdess..cmm
Aditya Sanghi Autodesk Research
addtga.sanghiBruttoess..ccm
Nigel J. J.W. Morris Autodesk Research
nigel.ooris@@uutaless.ccom
Reviewed on OpenReview: https: h/tp:/ooppee openreview. net/ forum? ZR2CDgADRo
Abstract
The Boundary reprosentation (B-rep) format is the de-facto shape representation in computer-aided design (CAD) to model solid and sheet objects. Recent approaches to generating CAD models have focused on learning sketch-and-extrude modeling sequences that are executed by solid modeling kernel in postprocess to recover a B-rep. In this pa- per we present new approach that enables learning from and synthesizing B-reps without the need for supervision through CAD modeling sequence data. Our method SolidGen, is autoregressive neural network that models the B-rep directly by predicting the vertices, edges, and faces using Transformer-basee and pointer neural networks. Key to achieving this is our Indexed Boundary Representation that references B-rep vertices, edges and faces in a well-defined hicrarchy to capture the geometric and topological relations suitable for use with machine learning. SolidGen can be easily conditioned on contexts e.g., class labels, images, and voxels thanks probabilistic modeling of the B-rep distribution. We demon- strate qualitatively, quantitatively, and through perceptual evaluation by human subjects that SolidGen produce high quality, realistic CAD models.
1 Introduction
Almost every manufactured object in the world starts life as computer-aided design (CAD) model. The Boundary representation format (B-rep) is the de-facto standard used in CAD to represent solid and sheet objects as collection of trimmed parametric surfaces connected with well-structured topology (Weiler 1986). The ability to generate B-reps automatically, driven by some context, is an enabling technology for design exploration and critical to solving a range of problems in CAD such as reverse engineering from noisy 3D scan data, inpainting holes in solid models plausibly, and design synthesis from images or drawings.
Recent approaches to the generation of CAD models have focused on generating sequences of CAD modeling
operations (Willis al. 2021a Xu et al. 2021 Wu et. al. 2021 Xu al. 2022 Lambourne al. 2022

---

Published in Transactions on Machine Learning Research (02/2023)
Figure 1: SolidGen generates B-reps incrementally by building vertices, edges, and facos one at a time. Here we show snapshots from the edge (columns 2) and face generation (columns 3 8) for two data samples.
rather than the underlying 3D geometry and topology in the B-rep format. These methods produce a sequence of sketch and extrude modcling operations using a neural network and the B-rep recovered postprocess with a solid modeling kernel that execules the operations. Although this approach generales an editable CAD model, it currently limited the sketch and extrude modeling operations and cannot be casily extended to support other operations build sheet bodies. In particular, fillets and chamfers, which are widely used in CAD for structural performance and case of manufacture, are challenging as they operate B-rep edges which are not available until the predicted solid has been built. Furthermore, sketch-and- extrude workflows operate with 2D planar curves, hence extensions to freeform modeling are not trivial.
There are several advantages to pursuing an approach that directly synthesizes the B-rep. Firstly, signifi- cantly more CAD data exists without stored sequence of CAD modeling operations. Files created via direct modeling or exported to common B-rep file formats do not retain a history of CAD modeling operations. In the public domain, CAD model datasets with CAD modeling operations Wiills et al. 2021a Wu et al., 2021) are smaller (~190K models) than those without (Koch et al. 2019) (1M models). Secondly, support for freeform curves and surfaces like Bézier and non-uniform rational B-splines, advanced topological structures like T-splines or Catmull-Clark subdivision meshes can be provided with the ability to generate B-reps directly, as they share geometric and topological similarities. Finally, there are several problems in CAD that can only be solved with direct B-rep synthesis approach. Examples include hole-filling for repairing solids which have poorly trimmed missing faces due data exchange (Butlin & Stops 1996; Assadi 2003), patching up geometry in regions of model where error-prone operations, such offsetting, fail (Bodily] 2014) and the creation of parting surfaces and shut-outs in molding workflows (Bhargava et al,,
1991 Scr 1995). Although hcuristic algorithms exist for such applications, learning based method has the potential Lo incorporate external context and respect aesthetic aspects of the CAD model.
We make the following contributions in this paper:
We propose SolidGen, a novel generative model based on Transformers and two-level pointer networks for the direct synthesis of B-reps (Figure 1 without supervision from a sequence of CAD modeling operations. To the best our knowledge, SolidGen is the first generative model that can synthesize B-reps directly.
We propose a new representation, the indexed boundary representation, that can represent B-reps numeric arrays suitable for use with machine learning, while still allowing the geometry and topology of B-reps to be completely recovered.
We show the quantitative and qualitative performance SolidGen for unconditional generation and perform a perceptual study showing SolidGen produces more realistic results than the state-of-the-art.
We demonstrate how controllable generation of B-reps can be achieved by conditioning with class labels, images, and voxels when available.
2

---

Published in Transactions on Machine Learning Research (02/2023)
2
Related Work
Since the proliferation of the B-rep format (Lee & Lee 2001 Slyadnev et al. 1980s, several research areas have been explored.
2020
Weiler 1986
in the
Learning from B-reps. The ability to represent R-rep data as a graph (Ansaldi et al. 1985
has inspired
recent approaches using graph neural networks for classification and segmentation problems Cao et al.
Jayaraman et al., 2021). B-rep topology can also be used for custom convolutions (Lambourne et al. 2021 or hierarchical graph structures (Jones et al. 2021 Rather than encoder, our work focuses
2020
decoder to synthesize B-rep data directly.
Constructive Solid Geometry (CSG). In CSG, 3D shapes are formed by combining primitives (e.g. cuboids, spheres) with Boolean operations (e.g. union, subtraction) into a CSG tree. By parsing the tree with an appropriate geometry kernel, B-rep can be obtained. CSG approaches have been used to reconstruct 'shape programs' in combination with techniques from the program synthesis literature, both with neural guidance (Sharma et al. 2018 Ellis et al.) 2019 Tian et al., 2019; Kania et al.) 2020) and without (Du et al., 2018 Nandi et al. 2017
2018). By contrast, our work applies to multiple tasks beyond reconstruction.
Sequential CAD Generation. Another line of research leverages the supervision available from modeling operations stored in parametric CAD files to directly predict sequences of CAD modeling operations. The
result is editable CAD files in the form of 2D engineering sketches (Willis et al. 2021b; Para et al.) 2021
Ganin al. 2021 Seff et al. 2021) or 3D CAD models generated from a B B-rep (Willis et al. 2021a Xu al. 2021 or point cloud [Uy et al.) 2021) target, interactive system (Li et al., 2020 or generative model (Wu ct al. 2021 Xu et al. 2022 Although soquential CAD generation approaches have made significant progress, outslanding challenge is how to exlend these techniques to other modeling operations beyond sketch and extrude. Common modeling operations, such as fillet and chamfer, are challenging as they operate on B-rep odges which are not part of the representation available to the network, but rather generated as a post- process. An alternate approach might be to use reinforcement learning with a CAD kernel integrated into the environment, similar to Lin et al. (2020), at the expense of extended training times due to the sparse reward space and slow CAD kernel execution times. Instead, we focus our efforts on direct synthesis of the B-rep data structure which cannot be achieved by predicting sequence of CAD modeling operations.
Direct B-rep Generation. Direct B-rep generation involves the synthesis of the underlying paramet- ric curves/surfaces and the topology that connects them to form a solid model. Several barning-basee approaches have made progress with the generation of parametric curves (Wang et al., 2020) and sur- faces (Sharma et al., 2020). Yet to be addressed is a generative model for the creation of topology that joins parametric curves and surfaces together to form solid models, rather than relying on pre-defined topological templates (Smirnov et al., 2021). PolyGen (Nash et al.] 2020) is a promising approach to joint geometry and topology synthesis where sequences of n-gon mesh vertices and faces are predicted using Transform- ers (Vaswani et al.] 2017). A key insight of this work is the use of pointer networks (Vinyals et al. 2015) to reference previously predicted primitives and form the underlying shape topology. Our work draws inspira- tion from the use of pointer networks to develop a novel representation and method for the challenging lask of direct B-rep generation. |Wang et al. (2022) concurrently applied a pointer network to identify planar and cylindrical faces given the 2D projection of edges. Our method more general and synthesizes the entire B-rep while supporting all prismatic surfaces in a generative modeling framework. A similar representation to ours was proposed in a concurrent work (Guo et al.] 2022), where the objective was to reverse engineer B-reps from point clouds. Using a neural network to predict the rough B-rep geometry and topology, a combinatorial optimization was applied to refine the solution. By contrast, our method is an autoregressive generative model with support for more input modalities such as image and class in addition to point clouds, and does not require an expensive optimization step to build plausible B-reps.
3 Representation
Boundary Represcntation. B-reps are a kind of generalizod mesh structure in which many of the re- strictions of triangle meshes have been removed (Fiurre 2). In place of planar triangular facets, B-reps allow faces built. from planes, cylinders, cones, spheres, toroidal surfaces or B-splines surfaces. The edges
3

---

Published in Transactions on Machine Learning Research (02/2023)
HORE
Curve Types
FACE
Surface Types
Figure 2: The Boundary Representatin ation data structure consists of vertices, edges formed by curve primitives (left) and faces formed by surface primitives (right). Loops of oriented edges-wires, are used to delimit the surfaces into visible and hidden regions.
at the boundary of faces can be lines, ares, circles or B-spline curves. Unlike meshes, B-rep faces can have internal holes, hence closed loops of edges are organized into oriented wires delimit the surfaces. The curves defining the edges can be viewed functions from an interval in the 1D u-parameter domain into 3D, while the surfaces can be viewed as functions from 2D box in the uv-parameter domain to 3D. The wires defining a face's boundaries can be projected onto its surface's 2D parameter domain, forming closed loops. Outer loops in uv-space are oriented anti- clti-clockwise, while inner loops are in clockwise direction. This allows uv-points to be classified as visible or hidden and facilitates meshing (Chow) 1987 Rockwood et al. 1989 The B-rep data structure stores many references among entities (typically using pointers) allowing efficient constant- time querying of adjacency information (Lee & Lee 2001).
Indexed Boundary Representation. We now derive indexed representation of the B-rep Figure 3 right) that can be represented as numeric arrays suitable for use with machine learning. Importantly, this representation can be inverted back into a B-rep exactly. We currently restrict the representation to elementary curves (lines and arcs) and surfaces (planes, cylinders, cones, spheres and tori). We do not support B-splines and conic sections that are uncommon mechanical CAD (Willis et al., 2021a Koch let al.) 2019). Without loss of generality, we assume that closed faces (cylinders, cones, etc.) in the B-rep are all split the seams to simplify downstream processing, for c.g., closed cylinder with scam is split into two four sided half-cylinders. The indexed B-rep is analogous to the indexed list data structure used to represent polygonal moshes, c.g. the Wavefront OBJ file format (Library of Congress 2020). The indexed list data structure can be represented numerically using two lists of numbers, and has been successfully used for generative modeling of meshes (Nash et al. 2020) and engineering sketches (Willis et al.] 2021b). Just as a polygonal mesh can be represented using a topological data structure like winged edge (Baumgart, 1972), or a simple data structure like the indexed list, we show that B-reps can be converted into an indexed format. However, while polygonal mesh is restricted to straight line edges and planar faces, B-reps are more general with support for curved edges and faces, making our problem more challenging. We address this challenge by explicitly representing only the bare minimum geometric and topological information in our indexed formal, and designing rule-based algorithm leveraging solid modeling kernels to infer and build the rest of the information. The indexed B-rep B is comprised of three lists [V,EF}, Vertices V contain a list of 3D point coordinates correspouding to each B-rep vertex and the are midpoints. Edges & are represented as hyperedges (Willis et al. (021b) where each hyperedge is a list of indices into V. hyperedge connects two more vertices to define the edge geometry. The curve type is defined by the cardinality of the hyperedge: line (2), are (3). Faces F are defined as the set of edges bounding surface. Each face contains a list of indices into E. By indexing from Faces, to Edges, to Vertices, our representation is well suited for use with pointer networks (Vinyals et al. 2015). Parametric surfaces that define the geometry of the face, and wires that trim the surfaces are left out of our representation and recovered in postprocess, as described next.
Recovering a Boundary Representation. We leverage the boundary curve geometry that defined by the edges& ε, together with the mapping of the edges that bound a face F to recover the wire and surface geometry using well-defined rules. In particular, the surface type be first fixed from the curve types
1 For periodic surfaces (cylinders, cones, spheres and torl), which have parameter domains "topologically glued" from to in one both dimensions, the surface must first. be subdivided into patches homeomorphic the disk.
4

---

Published in Transactions on Machine Learning Research (02/2023)
E0s4
HCRTER
Lin
FACE
V
JF
Boundary Representation
Indexed Boundary Representation
Figure 3: The Boundary Representation (left) comprises several topological entities. Our Indexed Boundary Representation (right) references vertices, edges, and faces in well-defined hierarchy suitable for use with machine learning.
while the surface paramcters can be inferred from the curve and vertex geometry. The surface type and parameters can be derived from the curves by simple of rules. For instance, faces whose vertices are non-planar collection of lines and arcs will
coplanar define trimmed planar surface, faces whose curves be cylinders or cones and faces whose curves are all ares will be spheres tori. We explain the procedure to apply this rule-based algorithm and build the B-rep in greater detail in Section A.2) Applying this procedure to every face in the indexed B-rep yields the surface type and parameters. Then, the data read into the solid modeling kernel using standard data exchange and shape fixing functions designed for reading neutral CAD file formats like STEP and IGES.
4 SolidGen Architecture
SolidGen generative model that directly synthesizes CAD data in the B-rep format. SolidGen leverages Transformers (Vaswani al.) 2017) and pointer networks (Vinyals al.) 2015) enable the generation of vertices, curved edges, and non-planar faces, such that edges can refer to vertices and faces refer to edges, allowing us to build the complete B-rep topology. Our goal is to estimate distribution over indexed B-reps B that can be sampled from to generate new indexed B-reps, and converted to actual B-reps as described in the previous section. This probability distribution p(B) is defined as the joint distribution of the vertices V, edges E, and faces FF
p(B) p(),E,F).
(1)
To make the learning problem tractable, factorize this joint distribution into product of conditionals
p(B) ppF(p V)((E))))))
and learn these distributions with separate neural networks. Once these conditional distributions are learned, B-reps can be generated by sampling vertices first, followed by edges conditioned on vertices, and faces conditioned on the edges and vertices. is also possible to condition the generation using a context z in which case the joint distribution bocomes
= (1
where can be derived from other representations ions like class labels, images, voxels, elc. Since there can be an arbitrary number of vertices, edges, and faces in each B-rep, and strong symmetries are present in CAD models, we use autoregressive neural networks to model the probability distributions above. Figure 4 showw an overview the SolidGen architecture at inference time, with each model described further detail below.
4.1 Vertex Model
The vertex model Figure 4
left) learns a distribution p(V) over the vertex positions. Vertices here include both B-rep vertices and the additional points inserted on B-rep edges to encode the curve primitive infor- mation as explained in Figure 3 The vertices are first sorted lexicographically, i.c., by z coordinates first, y coordinates next, and coordinates finally, then their coordinates are flattened into a 1D list, with a stopping
token <EOS> marking the end. After flattening, yeeq (vo, U1,..., <EOS>> is of length beeq ([V) x 3) 11,
5

---

Published in Transactions on Machine Learning Research (02/2023)
Hovt Vartey
Next Edge
Nixt Foce
20-1
2
[2
115
TRANSFORMER DECODER
TRANSFORMER DECODER Painter Network
TRANSFORMER DECODER Pointer Network
Conditional
GATHER
2. Embedcing
GATHER
(Optional)
GATHER
EMBEDDING
TRANSFORMER ENCODER
TRANSFORMER ENCODER
EMBIDDING
Luavrted Pixiliio
EMBEDDING
Class Label Embedding (Optional)
11
50S
TO
EDS
EUS
VERTEX MODEL
EDGE MODEL
FACE MODEL
The SolidGen architecture consists of vertex (left), edge (center), and face (right) model that predict the vertices, edge connections between vertices, and face connections between edges to form an indexed B-rep (top).
Figure 4:
with every triplet corresponding to coordinate values of a single vertex. Rather than using real-valued coor- dinates for the vertices, we quantize the vertex sequence Yoeq uniformly into 6-bits as is common in previous work (Nash et al. 2020 Seff et al., 2021 Wu et al. 2021). The vertex model learns the following distribution
|
p(yen;00))
II t=0
p(ve | no, -1.... 11-1;0v),
(4)
where Oy are learnable parameters of the neural network that is a Transformer decoder (Vaswani et al.
2017), and the conditional distributions above can all be treated as categorical distributions.
Given the input vertices Veg at step I, the goal is to model the next output vertex token i22- The input to the Transformer docoder hy is derived from each of the tokens in yeeg by learning three kinds of embeddings coordinale embeddings indicating whether loken is an x, y or z-coordinate, positional embeddings indicating the vertex index which the token belongs to, and value embedding encoding the x, y z-coordinate:
hy {Wooor mod 3) W pos (A + W (wai(Ho;))
where 1 maps its integer argument in the subscript into a one-hot vector, Weoo E Rdomm W pos E X and W val E Rdent x2" are all learned matrices that map their inputs to demb=226 dimensional embeddings. Then a Transformer decoder Ty model predicts a probability distribution (in the form of logits) over all possible vertex locations for the next token ey:
p(v)) = Ty (hyma)
The model is trained using teacher-forcing (Williass & Zipser 1989 to maximize the log-likelihood of the training data with cross-entropy loss with label smoothing of 0.01.
4.2
Edge Model
The edge model Figure 4 center) learns a distribution p(E) over the vertex indices. The edges are represented 1T) list geeg by flattening the vertex indices in E, with a edge token <NEW EDGE> marking the start

---

Published in Transactions on Machine Learning Research (02/2023)
of new edge and stopping token <EDS> marking the end of the list. For ordering invariance, sort each
edge E E & in ascending order and then sort & such that the edges with lowest vertex indices come first.
The edge sequence g = {eo, E1, <NEW_ EEEEEEEEE........ ( is of length [ = DEEE |R] + 1, and the edge model learns the following distribution:
p( = II ==
ple, P3.
V;0E),
(5)
where 0g are learnable parameters of the neural network.
Given the imput vertices V and current edges Exe until the step the goal is to model the next output vertex index Ce probability distribution over the indices of V. This is done by first learning value embeddings hy E IR Vixdamb from the input vertices {( Di, 2:) /M--
hy (W Wyt.. (, 1-11
(6)
where Wx. Wy and W, E g64x2" are learned matrices that map their inputs into 64-dimensional embed- dings, || is the concatcnation operation along the second dimension, and X is a learned lincar layer to produce Remb=256 dimensional embeddings. The token embeddings for <NEW_EDGE _EDG>> and <EOS>, hav RDGE> Remb and heeos> E Redem learnable parameters that concatenated to form total of [V] + 2, which is further processed by Transformer encoder T to obtain hipp E R (1|+22)
hmpp
Tée (h<ees> h EDGE>
hy).
Then, edge embeddings heme E IR Pa x256 are formed by gathering the input emboddings hap corresponding to the vertex indices in E and summed with learned positional embeddings indicating the position of each token in Err
h ggngg = (himp [ey] + W pos 1;)
where W pos E R (xdomb is a learnable matrix.
A Transformer decoder Thf then processes these embeddings followed by a linear layer to output a pointer vector P. that compared the input emboddings hopp using dot product operation and normalizod using softmax get distribution over the 0 < < |V]+1 + indices including the vertex indices and the <NEW <NEW_EDGE, EDGE>, <EOS> tokens:
Pr Tée (hew)).
p(e, = k 03eq V) softmax, (pr hmmpkk)).
The model is trained using the cross-entropy loss to predict the distribution p(e, k Ezg V) which is repeatedly created at each time step and sampled to generate the edge tokens autoregressively. During training, ground-truth is used for conditioning (teacher-forcing) rather than previons samples.
4.3
Face Model
The face model (Figure 4
right) learns a distribution p(F) over the faces. The faces are represented as a flat sequence Femq similar to the edges by flattening F into a 1D list of edge indices, with a new face token <NEW FACE> marking the start of new face and a stopping token <EDS> marking the end of the faces list. The model learns the following probability distribution:
1-1
p(Fa0g E, V;0))=
II p(fe ff.
where Of are learnable parameters of the neural network.
The face model functions similarly as the edge model and represents the face features by gathering edge embeddings. Given the input vertices V and edges E, and the current faces Feen at step the goal is model the next output face token fa probability distribution over the indices of E.

---

Published in Transactions on Machine Learning Research (02/2023)
This is done by learning vertex embeddings hy E RlV]xdemb from the input vertices in Equation 6 The rows of by corresponding to the vertex indices in & are first gathered and summed, and learned embeddings for <NEW_ FACE>> and <EOS>, h<wEx_FASS FACE> and heass are further concatenated to these embeddings, and passed through a Transformer encoder T to form hg E R(le +2) +2)xdemb;
hg = Tene h<ess>>
LANELFFACES
EEEE hy/lul)
Finally, face embeddings bazg are formed by gathering the edge embeddings which is further summed with learned positional embeddings, and passed through another Transformer encoder T
h T (( + W pos (.)
where W pos E I [xdemb learnable matrix. The idea here is to encode faces by the embeddings of the odges that lie on their boundary, and encode the edges by the embeddings of the incident vertices.
A Transformer decoder THE then processes hy to output pointer vector Pe that is compared to the edge embeddings bg using dot product operation and normalized using softmax to get a distribution over the 0 < k S [8] + input edge indices and <NEW_ FACE>, <EOS> tokens:
p. T (
p(f: k
keq <t
E, V) = softmax, (Pr belk)).
The face model is also trained by teacher-forcing using a cross-entropy loss.
5 Experiments
In this section we perform experiments to qualitatively and quantitatively evaluate our method on uncondi- tional generation, and various conditional generation lasks based on class labels, images, and voxels.
Implementation. Our implementation is in PyTorch (Paszke et al. 2019). We train our models for 1000 epochs with batch size 512 using the AdamW optimizer [Loshchilov & Hutter 2019) (learning rate: 10-4 weight decay: 0.01) on an Nvidia DGX A100 machine. The vertex, edge, and face models can be trained independently since we employ teacher-forcing where the models are decoupled during maining-rather than using the samples from one model to condition the subsequent model, use the ground truth data. When a conditional embedding is jointly learned however, we have to train the three models together. Training time ranges from 1 3 days depending on the dataset. We find it critical for convergence to use the Noe- variant of the Transformer (Xiong et al. 2020). All Transformer modules use layers with an embedding dimension of 256, and fully-connected dimension of 512 and attention heads. We initially experimented with 4, and 12-layer models and observed the 8-layer model work well. The 4-layer model was slightly underfitting while the 12-layer model was overfitting on our datasets. To sample from the models use nucleus sampling (Holtzman et al. 2020 We find it helpful to mask logits that are invalid in each step of the sampling (see Section A.3). All data processing related to building indexed B-reps and reconstructing B-reps uses the OpenCascade CaCGaaacade/pphhoOOOCCC OCC (Paviot 2008) solid modeling kernel.
Datasets. Publicly available datasets for B-rep solid models are limited compared to other 3D representa- tions. We demonstrate our method on two datasots while considering only files that contain the surface and curve types supported by the indexed B-rep format.
The Porametrie Variations (PVar) Dataset is synthetically designed (see Section A.5 for details) for testing SolidGen on the class-conditionss generation task, since categorically labeled B-rep datasets are unavaiaable. There are 120,000 models, 2000 in each of the 60 classes. The datasct is split in a 90 (train)/5 (validation)/5 (Lest) proportion.
The DeeDCAD Dataset (Wu et al.) 2021 contains a subset of the CAD models available in the ABC dataset (Koch al.] 2019) that additionally includes the soquence of sketch and extrude CAD modeling operations. The original dataset contains 178,238 CAD models with a significant portion of duplicate and trivial models. We use hash-based method, described in Section A.T. to remove duplicates. We filter out
8

---

Published in Transactions on Machine Learning Research (02/2023)
Table 1: Modeling metrics for unconditional and conditional SolidGen models computed on the test set.
NLL (bits per, 4)
Top-1 1 Accuracy (%, f)
Dataset
Model
Vert.
Edge
Face
Total
Vert.
Edge
Face
Mean
Uniform
18.44
13.59
24.96
56.99
2.01
1.59
2.04
1.88
PVar
SolidGen
4.49
0.01
0.04
4.54
91.30
99.97
99.88
97.05
w/class (vertex)
4.19
4.24
83.20
94.35
w/class (all)
1.28
0.01
0.03
1.32
92.43
99.97
99.89
97.43
Uniform
18.32
15.05
28.14
61.51
1.48
1.10
1.42
1.33
DeepCAD
SolidGen
5.42
0.43
0.26
6.11
86.12
98.87
99.55
94.85
w/image (vertex)
1.97
2.66
80.61
93.01
w w/image (all)
1.98
0.26
0.27
2.51
89.74
98.84
99.31
95.96
w w/voxel (vertex)
4.89
5.42
82.28
93.48
w/ w/voxel (all)
2.00
0.52
0.65
3.17
91.26
98.62
99.18
96.35
trivial (< 8 faces, for e.g., boxes), overly-complex (> 130 faces) models, those that contain merged vertices after quantization and ones that yield very long sequences with > 200 tokens. We are left with 49,759 models that are split in 90/5/5 train/validaiie /iaaavdaaaionttttt render images of the CAD models with the OpenCascade viewer. For voxel conditioning, we sample a point cloud with 2048 points from the surface of the CAD models, and quantize them into voxel grids of dimension (20)3 matching
sets and used for all experiments. For image conditioning, we
vertex quantization.
Metrics. We use the following metrics to quantitatively evaluate and compare SolidGen with other methods. Valid reports the percentage of solids that were successfully built and considered valid by the solid modeling kernel (see Section A. Novel measures the percentage of valid solids that are not duplicated from the training set, and Unique reports the percentage of valid solids not duplicated within the sample set. The duplication check based on our hashing procedure described in Section A.T
5.1 Unconditional Generation
In this section we evaluate SolidGen unconditional generation of B-reps.
report the negative log-likelihood (NLL) and per-step accuracy computed on the DeepCAD test set. The NLL is reported individually for our vertex, edge and face models in bits per vertex, bits per edge and bits per face, respectively. Since there is no other method that uses our indexed B-rep format, a one-to-one comparison is not possible and we use a 'Uniform' model that allocates uniform probability to the entire co-domain of the data as a baseline reference. The accuracy corresponds the top-1 prediction correctness of the next token given the ground truth for the previous tokens. Tabll 1 (first two rows under 'DeepCAD") shows the quantitative metrics of our model and the uniform baseline on the DeepCAD (Wu et al. 2021] dataset. SolidGen obtains an NLL of 4.54 bits and 97.05% accuracy compared to the 'Uniform" model that has an NI.I. of 56.99 bits and 1.88% accuracy. We find that the edge and face models always outperform the vertex model. This could be because once the vertices are estimated, the edges and faces are significantly constrained in our representation. We show plots for top-10 accuracy in [Section A.S.
Modeling Performance. To evaluate the modeling performance,
Comparison with DeepCAD. We evaluate the quality of the generated samples produced by SolidGen and compare them with that of DeepCAD (Wu et al. 2021 model. Note that both models work in fun- damentally different ways SolidGen is autoregressive generative model trained directly the B-reps, while DecpCAD is an autocncoder that learns from sequences of CAD modeling operations. This fundamen- tal difference in representation leads to differences in design choices making a fair comparison challenging. We strive to provide a one-to-one comparison by focusing mainly on the sample quality. Figure 3 shows qualitative results for unconditional generation trained on the DeepCAD dataset Wu et al. (2021). We show
samples from the dataset for comparison (a), along with generated samples from DeepCAD
(b) and SolidGen
(c). More results are shown in Section A.8 We present quantitative metrics in Table 2 A large portion
9

---

Published in Transactions on Machine Learning Research (02/2023)
(a) Datasel
(b) DeepCAD
(c) SolidGen (ours)
Figure Qualitative results for unconditional generation. Samples (a) from the DeepCAD dataset, (b)
generated by the DeepCAD model (Wu et al. 2021 and (c) generated by SolidGen.
Table 2: Quality of 5000 unconditional samples generated by networks trained on the DeepCAD dataset. SolidGen results are shown for samples generated with different top-p values in nucleus sampling.
Model
Valid (%,1)
Novel (%,1)
Unique (%,1)
SolidGen (p=0.5)
87.57
66.22
33.69
SolidGen (p=0.6)
88.12
73.00
61.42
SolidGen (p=0.7)
86.70
82.46
83.91
SolidGen (p=0.8)
85.21
88.09
93.65
SolidGen (p=0.9)
83.10
92.38
97.49
DeepCAD
62.11
96.73
99.01
of the models produced by SolidGen are valid and usable B-reps, with SolidGen showing between 20.99% to 26.01% improvement in the valid ratio compared to DeepCAD. By varying the top-p hyperparameter in mucleus sampling, SolidGen is able trade-off between validity and novelty and uniqueness of B-reps produced. We observe clear trend where increasing p reduces validity while increasing the novelty and uniqueness. SolidGen falls slightly below DeepCAD and obtains 4.38% to 30.51% lower novel and 1.52% to 65.32% lower unique ratio depending on the top-p parameter. We found that many of DeepCAD's samples contain self-intersections and tend be noisy /unrealissilccccccco leading to decreasing the valid score, but artificially increasing the unique and novel scores. We further investigate this through a human perceptual study next.
Human Perceptual Evaluation. Rather than rely only metrics, we believe it is critical to perform human evaluation the output of generative models. To evaluate the realism of the generated samples, we perform a perceptual study using human evaluators recruited through Amazon's Mechanical Turk servico (Mishra 2019). The crowd workers were shown pairs of images, one of which was generated by SolidGen (p = 0.7) or DeepCAD and the other randomly selected from the training set, and asked to judge which of the two was more realistic. Each image pair was rated by different human evaluators and we record the number of crowd workers who selected the generated model as more realistic. The results are shown Figure 6 We see that for SolidGen the distribution roughly symmetric with the majority vote judging the
10

---

Published in Transactions on Machine Learning Research (02/2023)
Less realistic
More realistic
25
SolidGen
% of pairs rated
20
DeepCAD
15
5
0
7
Number of raters selecting generated result more realistic
Figure 6: Human perceptual study showing the distribution of votes by 7 human evaluators for the realism of SolidGen and DeepCAD models compared to samples from the training set.
0.2.
0.10
Datasct SolidGen
Dalasct
0.2-
Dataset SolidGen
Denity
SolidGie
Deasity
Damiity
Siolidtien
Danitty
SolidGen
0.05
0.05
0.0
15
29
20
10
13
Num. vertices
edges
Num. faces
Num. line
Num.
0.4
Tatasse
0.75
Dataoet
n.06
7.5
Datseet
Deatyy
0.2
0.50
Dauly
0.04
Depeity
0.2
5.0
0.25
Dataset
2.5
SolidGen
SolidGen
0.0
0,09
0.00
0.0
0.0
0.2
Num. plane
Nom cylinder
Edge length
Face arth
Figure 7: Comparison of distributions computed from SolidGen samples and the DeepCAD training set.
SolidGen output to be more realistic 52.67% of the time. This indicates the realism of the SolidGen output is indistinguishable from the training set. For DeepCAD we see the distribution skewed to the left, with the majority vote judging the DeepCAD output to be more realistic only 35.22% of the time.
Statistics. To check if SolidGen synthesizes B-reps representative of the dataset, compute several statistics between the samples produced by SolidGen (with top-p=0.9) compared to the DeepCAD training set in Figure 7] Here we used kernel density estimation with Gaussian kernels to fit the curves, and see that SolidGen well captures the modes of the data distribution.
5.2 Conditional Generation
In this section, demonstrate various conditional generation results using class labels in the PVar dataset and rendered images and voxels from the DeepCAD dataset. Conditional models use the same architecture, hyperparameters and training strategy as the unconditional model, and support two kinds of conditioning: Start- of-eeuunnceeeeeeeeeee (SOS) Embedding. For class conditioning, we learn a demb=256 dimensional embedding from the input class label, and use as the SOS embedding in the vertex, edge and face models. Cross Attention. For image/ image/voxcl voxel conditioning, we use 2D/3D convolutional ncural network (dctails Section A.7 to obtain an 162 /8 dimensional embedding that flattened and jointly used by the Transformer decoders in the vertex, edge and face models via cross-attention.
The modeling performance of the conditional models are shown in Table I The 'w/class (all)' row under 'PVar' shows that class conditioning improves the NLL by -3.22 and accuracy by +0.38% compared to the unconditional 'SolidGen' model trained on the same data. A similar trend is observed for image and voxel conditioning shown under row 'DeepCAD'. The NLL for the 'w ww/image (all)' conditional model improved by -366 while the accuracy improved by +3.6%. For the voxel conditional model 'w w/voxel (all)', the NLL improved by -2.94 while the accuracy increased by +1.5%.
Modeling Performance.
11

---

Published in Transactions on Machine Learning Research (02/2023)
Figure 8: Class conditional samples (each row is a unique class) from SolidGen trained on the PVar datasel.
Figure 9: Image conditional samples from SolidGen using images (first column) obtained by rendering CAD models in the DeepCAD test set.
Sample Quality. Qualitative results of our class-conditioning model given random class labels as input Figure 9 shows B-reps produced by our model given images as input conditioning, while Figure 10 shows results where voxelized point clouds were used as conditioning. We see that SolidGen is able synthesize design variations that are close the input conditioning. Quantitative evaluation of the class-conditional samples (40 per-class). image conditional samples (20 per image) and voxel conditional samples (20 per voxel grid) are provided in Table 3 We see that SolidGen generates high number of novel transition from class to image to voxel conditioning.
are shown in Figure 8
B-reps, but the valid and unique ratio go down We suspect this trend is due to data imbalance in the dataset which contains arbitrary shapes without clear categories making the overall task challenging. Moreover, unlike unconditional and class conditional generation, image and voxel conditioning require generating design variations for every data in the test set,
Figure 10: Voxel conditional samples from SolidGen using voxelized point clouds (first column) obtained by sampling 2048 points from CAD models in the DeepCAD test set.
12

---

Published in Transactions on Machine Learning Research (02/2023)
Table 3: Quality of conditional samples generated by SolidGen with top-p=0.7.
Conditioning
Valid (%,1)
Novel (%,11
Unique (%,11)
Class (PVar)
83.48
92.35
70.71
Image (DeepCAD)
71.45
94.61
75.08
Voxel (DeepCAD)
66.78
92.75
53.95
making the task more challenging. The less precise nature of 2D image conditioning makes it easier to learn and generate design variations compared to the 3D case.
Ablation on joint conditioning. Conditional models require the vertex, edge and face models to be trained together. To understand the importance of jointly learning a conditional embedding for the vertex, edge and face models, we experimented with a variant of SolidGen where the conditioning is only applied to the vertex model. This variant denoted by 'w/ *(vertex)' in [Tble has the advantage that the vertex, edge, and face models can be trained independently in parallel since the probability distribution being modeled is p(B]2) = p(F)E, V)p(E(V)pp()2)) We observe that conditioning only the vertex model does improve the NLL in all cases (class:-0.3, image:-3.45, voxel:-0.69), but the accuracy drops below that of the unconditional The joint conditioning variants 'w w/class (all)', 'w w/image
model (class: image:-1.84%% voxel:- (all)' and 'w/ w/voxel (all)' perform the best in all cases.
6 Conclusion
Limitations & Future Work. Our current method has some limitations that be addressed in future work. Extremely complex CAD models with long sequence lengths increase the training time and chance for compounding errors at test time, which could be attributed to teacher forcing, Scaling our model and training on larger CAD datasets might, alleviate the problem. Our indexed B-rep format supports the most common curve and surface types found in mechanical CAD models but not conic sections and splines that are common in freeform modeling. Uniform B-spline curves of a fixed degree can be supported by considering edges that group >= (degree +oreee+1] vertices (the spline's control points). However, unlike prismatic surfaces, the B-spline surfaces cannot be fully determined by the boundary curves, and require the additional prediction of grid of interpolating control points. Like previous generative neural networks (Willis et al. 2021b Nash al, 2020 Wu et al. 2021 Xu et al. 2022 our method is trained using classífication losses. Several important CAD applications, e.g., reverse engineering, require reconstruction losses that incorporate the B-rep geometry which is not available until postprocess. Finally, research into conditioning schomes could facilitate stronger user guidance the generation, and latent representations would help with better generalization
Summary. We presented SolidGen, generative model that can directly learn from and synthesize bound- ary representation (B-rep) CAD models without the need for supervision from sequence of CAD modeling operations. We achieved this by deriving the indexed B-rep format that captures the hierarchical nature of B-rep vertices, edges and faces in new machine learning friendly representation. SolidGen generates highly coherent yet diverse B-reps as demonstrated in our comparison with prior work. Our method has potential to be integrated into CAD software workflows, since all CAD software allows the import of solids without modeling history. As our method can generate local regions of B-rep topology, in addition to entire solids, this allows lcarning-basse techniques to play role in many other workflows such as solid model inpainting and parting surface creation. Conditional generation can aid in sketch-based modeling workflows and to convert point clouds, meshes other file formats into B-reps for further editing.
References
Automatic Generation of Porting Surfaces and Mold Halves, volume ASME 1995 15th International Com- puters in Engincering Conference and the ASME 1995 9th Annual Engineering Databasc Symposium of International Design Engineering Technical Conferences and Computers and Information in Engineering Conference, 09 1995. ASME
13

---

Published in Transactions on Machine Learning Research (02/2023)
Silvia Ansaldi, Leila De Floriani, and Bianca Falcidieno. Geometric modeling of solid objects by using face adjacency graph representation. Annual Conference on Compuler Graphcs and Interactive. Techniques (SIGGRAPH), 19(3):131-13) 139, 1985.
Armand Daryoush Assadi. CAD model robustness assessment and repair. PhD thesis, lowa State University, Ames, lowa, 2003.
Bruce G. Baumgart. Winged edge polyhedron representation. Technical report, Stanford University, Stan- ford, CA, USA, 1972.
Rahul Bhargava, Lee Elliot Weiss, Friedrich B Prinz, et al. Automated ejectabiltty analysis and parting surface generation for mold tool design. [Carnegie Mellon University], Engineering Design Research Center, 1991.
Garrett Bodily, A Computational Hybrid Method for Self- Self-Intersection Free Offsetting of CAD Geometry. Brigham Young University, 2014.
William Bouma, Toannis Fudos, Christoph Hoffmann, Jiazhen Cai, and Robert Paige. Geometric
constraint solver. Computer-Aided Design, 27(6):487-500 1995. ISSN 0010-4485. doi.org/ 10. 000000000000000000000000----0110 00104485940001344
doi: https://
wwtp://wwwwwwwnww.ttcccco com htt/s/seenn/rrrcce/////ae
Geoffrey Butlin and Clive Stops. Cad data repair. In Proceedings of the 5th International Meshing Roundtable, pp. 7-12. Citeseer, 1996.
Weijuan Cao, Trevor Robinson, Yang Hua, Flavien Boussuge, Andrew R. Colligan, and Wanbin Pan. Graph representation of 3d cad models for machining feature recognition with deep learning. In Proceedings of the ASME 2020 International Design Engineering Technical Conferences and Compulers and Information in Engineering Conference, DDТС-CCE. ASME, 2020.
L. P. Chew. Constrained delaunay triangulations. In Proceedings of the Third Annual Symposium on Computational Geometry, SCG '87, pp. 215 222. Association for Computing Machinery, 1987. ISBN URL https://dol.
0897912314. doi: 10.1145/41958.41998
Tao Du, Jeevana Priya Inala, Yewen Pu, Andrew Spielberg, Adriana Schulz, Daniela Rus, Armando Solar- Lezama, and Wojeiech Matusik. Inverseosg: Automatic conversion of 3d models to esg trees. Annual Conference on Computer Graphics and Interactive Techniques (SIGGRAPH), 37(6):1-16, 2018.
Kevin Ellis, Maxwell Nye, Yewen Pu, Felix Sosa, Josh Tenenbaum, and Armando Solar-Lezama. Write, execule, assess: Program synthesis with a repl. In Aduances Neural Information Processing Systems (NeurIPS), pp. 9169 9178, 2019.
Yaroslav Ganin, Sergey Bartunov, Yujia Li, Ethan Keller, and Stefano Saliceti. Computer-aided design language. In Advances in Neural Information Processing Systems (NeurIPS), 2021.
Haoxiang Guo, Shilin Liu, Hao Pan, Yang Liu, Xin Tong, and Baining Guo. Complexgen: Cad reconstruction by b-rep chain complex generation. ACM Trans. Groph. (SIGGRAPH), (4),, July 2022. doi: 10.1145/ 3528223.3530078.. URL
3530078
Dan Hendrycks and Kevin Gimpel. Bridging nonlinearities and stochastic regularizers with gaussian error linear units. CoRR, abs/ 0tes/66660844111 2016. URL http://arxiv. http://ww...r//aa///...00000 08415
Ari Holtzman, Jan Buys, Li Du, Maxwell Forbes, and Yejin Choi. The curious case of neural text degener- ation. In 8th International Conference on Learning Representations, ICLR. OpenReview.net, 2020, URL https:// wwtp://www....ttooou///rrrrgrgro
Pradcop Kumar Jayaraman, Aditya Sanghi, Joseph G. Lambourne, Karl D.D. Willis, Thomas Davics, Hooman Shayani, and Nigel Morris. Uv-net: Learning from boundary representations. In IEEE Con- ference on Computer Vision and Pattern Recognition (CVPR), pp. 11703 11703-11712, June 2021.
14

---

Published in Transactions on Machine Learning Research (02/2023)
Benjamin Jones, Dalton Hildreth, Duowen Chen, Ilya Baran, Vladimir G Kim, and Adriana Schulz. Auto- mate: dataset and learning approach for automatic mating of cad assemblies. Annual Conference Computer Graphics and Interactive Techniques Asia (SIGGRAPH Asia), 40(6):1 18, 2021.
Kacper Kania, Maciej Zięba, and Tomasz Kajdanowicz.
mesuprureeee discovering of constructive solid geometry tree. In Advances in Neural Information Processing Systems (NeurIPS), 2020.
Sebastian Koch, Albert Matveev, Zhongshi Jiang, Francis Williams, Alexey Artemov, Evgeny Burnaev, Marc Alexa, Denis Zorin, and Daniele Panozzo. Abc: A big cad model dataset for geometric deep learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
Joseph G. Lambourne, Karl D.D. Willis, Pradeep Kumar Jayaraman, Aditya Sanghi, Peter Meltzer, and Hooman Shayani. Brepnet: A topological message passing system for solid models. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 12773-12782, June 2021.
Joseph G. Lambourne, Karl D.D. Willis, Pradeep Kumar Jayaraman, Longfei Zhang, Aditya Sanghi, and Ka- mal Rahimi Malekshan. Reconstructing editable prismatic cad from rounded voxel models. In SIGGRAPH Asia, December 2022.
Sang Hun Lee and Kunwoo Lec. Partial entity structure: A compact non-manifold boundary represcntation based on partial topological entities. In Proceedings of the Sizth ACM Symposium on Solid Modeling and Applications, SMA '01, pp. 159-170, 170, New York, NY, USA, 2001. Association for Computing Machinery. URL
ISBN 1581133669 doi: 10.1145/376957.3700
/ttp://....0rr111111111//66/6771 1ww.11111//67..11 .76976.
Changjian Li, Hao Pan, Adrien Bousseau, and Niloy J Mitra. Sketch2cad: Sequential cad modeling by sketching context. ACM Transactions on Graphics (TOG), 39(6): 2020.
Sustainability of Digital Formats Library of Congress. Wavefront OBJ File Format, 2020. URL https: shtml
//www. //wp://cww/.reeeerrrooaaaa/////p
Cheng Lin, Tingxiang Fan, Wenping Wang, and Malthias Nießner. Modeling 3d shapes by reinforcement
learning. In European Conference Computer Vision (ECCV), 2020.
Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In ICLR, 2019.
Abhishek Mishra. Machine learning in the aws cloud: Add intelligence to applications with amazon sagemaker and amazon rekognition, 2019. URL https://aws. aaaa::/ com/ conp///gggemmeee/rrroortttttt
Chandrakana Nandi, Anat Caspi, Dan Grossman, and Zaacary Tatlock. Programming language tools and techniques for 3d printing. In 2nd Summit on Advances in Programming Languages (SNAPL 2017). Schloss Dagstuhh-LLeiinizzzeeettt fuer Informatik, 2017.
Chandrakana Nandi, James R Wilcox, Pavel Panchekha, Taylor Blau, Dan Grossman, and Zachary Tatlock. Functional programming for compiling and decompiling computer-aides design. Proceedings of the ACM on Programming Languages, 2(ICFP):1-2 1-11, 2018
Charlie Nash, Yaroslav Ganin, SM Ali Eslami, and Peter Battaglia. Polygen: An autoregressive generative model of 3d meshes. In International Conference on Machine Learning (ICMT), pp- 2220-7229. PMT.R,
2020.
Wariqq Reyaz Para, Shariq Farooq Bhat, Paul Guerrero, Tom Kelly, Niloy Mitra, Leonidas Guibas, and Peter Wonka. Sketchgen: Generating constrained cad sketches. In Advances in Neural Information Processing Systems (NeurIPS), 2021.
Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andrcas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d' A'Achéé-Bue, E. Fox, and R. Garnett (cds.), Advances in Neural Informa- tion Processing Systems 32, pp. 8024 8035. Curran Associates, Inc., 2019. URL http: http::/paperrs neurips.. .pdf
15

---

Published in Transactions on Machine Learning Research (02/2023)
Thomas Paviot. pythonoce, 3d cad/cae/plm development framework for the python programming language. https://dew.opennee www.cacccc......c.......... hwtpnnascade.oggpppeeeee org/proojectpyyyhonocc ( (Accessed 05-Mar-2022), 2008.
Alyn Rockwood, Kurt Heaton, and Tom Davis. Real-time rendering of trimmed surfaces. In Proceedings of the 16th Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH '89, pp. 107 116. Association for Computing Machinery, 1989. ISBN 0897913124. doi: 10.1145/74333.74344 URL https://doi. org. 10. 10.10......//7333..1 74344
Ari Seff, Yaniv Ovadia, Wenda Zhou, and Ryan P. Adams. SketchGraphs: A large-scale dataset for modeling relational geometry in computer-aided design. In ICML 2020 Workshop on Object- Oriented Learning, 2020.
Ari Seff, Wenda Zhou, Nick Richardson, and Ryan P Adams. Vitruvion: A generative model of parametric cad sketches. (rXim:2199.4122, 2021.
Gopal Sharma, Rishabh Goyal, Difan Liu, Evangelos Kalogerakis, and Subhransu Maji. Csgnet: Neural shape parser for constructive solid geometry. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
Gopal Sharma, Difan Liu, Subhransu Maji, Evangelos Kalogerakis, Siddhartha Chaudhuri, and Radomír Měch. Parsenet: A parametric surface fitting net for 3d point clouds. In European Conference on Computer Vision (ECCV), pp. 261-276. Springer, 2020.
Sergey Slyadnev, Alexander Malyshev, Andrey Voevodin, and Vadim Turlapov. On the role of graph theory apparatus in cad modeling kernel. Proceedings of GraphiCon 2020, 2020.
Dmitriy Smirnov, Mikhail Bessmeltsev, and Justin Solomon. Learning manifold patch-based representations of man-made shapes. In International Conference on Leurving Representations (ICLR), 2021.
Nitish Srivastava, GeofTrey Hinton, Alex Krizhevsky, Πlya Sulskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting, Journal of Machine Learning Research, 15(56); 1929 1958, 2014. URL http://jmlr... http:://jnrr.orgpppperre htt.://appppps/////aaaaattaeeeea
html
Yonglong Tian, Andrew Luo, Xingyuan Sun, Kevin Ellis, William T. Freeman, Joshua B. Tenenbaum, and Jiajun Wu. Learning to infer and execute 3d shape programs. In International Conference on Learning Representations (ICLR), 2019.
Mikaela Angelina Uy, Yen-yu Chang, Minhyuk Sung, Purvi Goel, Joseph Lambourne, Tolga Birdal, and Leonidas J. Guibas. Point2cyl: Reverse engincering 3d objects from point clouds to extrusion cylinders. CoRR, hts/2112.093322 2021. URL https:://// http///aaxvv..ogabbeee//ee
09329
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukası Kaiser, and Illia Polosukhin. Attention is all you need. In Proceedings of the 31st International Conference Newral Information Processing Systems, NIPS'17, pp. 6000 6010, Red Hook, NY, USA, 2017. Curran Associates Inc. ISBN 9781510860964.
Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer norks Adoances in Newral Information Processing Systems (NeurIPS), 2015.
Kehan Wang, Jia Zheng, and Zihan Zhou. Neural face identification in a 2d wireframe projection of manifold object. In 2022 IEEE/ /CVF Conference on Computer Vision and Pattern Recognition (CVPR), doi: 10.1109 /CTP//CV2.22222..00022
pp. 1612-1621, 2022.
Xiaogang Wang, Yuelang Xu, Kai Xu, Andrea Tagliasacchi, Bin Zhou, Ali Mahdavi-Amiri, and Hao Zhang, Pic-not: Parametric inference of point cloud edges. In Advances in Neural Information Processing Systems, volume 33, pp. 20167 20178. Curran Associates, Inc., 2020.
K.J. Weiler. Topological structures for geometric modeling. Technical report RPI, Center for Interactive Computer Graphics. University Microfilms, 1986.
16

---

Published in Transactions on Machine Learning Research (02/2023)
Ronald J. Williams and David Zipser. A learning algorithm for contimually running fully recurrent neural networks. Newral Compulation, 1(2):270 2000270--80, 1989. doi: 10.1162/nees neco. htt.//cc..199111... 1989.1.2.270.
Karl D. D. Willis, Yewen Pu, Jieliang Luo, Hang Chu, Tao Du, Joseph G. Lambourne, Armando Solar- Lezama, and Wojeiech Matusik. Fusion 360 gallery: A dataset and environment for programmatic cad construction from human design sequences. ACM Transactions on Graphics (TOG), 40(4), 2021a.
Karl DD Willis, Pradeep Kumar Jayaraman, Joseph G Lambourne, Hang Chu, and Yewen Pu. Engineer- ing sketch generation for computer-aided design. In IEEE Conference on Computer Vision and Pattern Recognilion Workshops (CVPR Workshop); pp. 2105 2105-2114, 2114, 2021b.
Rundi Wu, Chang Xiao, and Changxi Zheng. Deepoad: A deep generalive network for computer-aiied design models. IEEE International Conference on Computer Vision (ICCV), pp. 6772-67 6782, October 2021.
Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tieyan Liu. On layer normalization in the transformer architecture. In Hal Daumé III and Aarti Singh (eds.), Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pp. 10524-10533. PMLR, 2020. URL https:///proceediin
mlr. alr.press/Ve v1 https//vv1xxxxxogoee htt//xxinng2bbbhh html
Xiang Xu, Karl DD Willis, Joseph G Lambourne, Chin-Yo Yi Cheng, Pradeep Kumar Jayaraman, and Yasutaka Furukawa. Skexgen: Autoregressive generation of cad construction sequences with disentangled codebooks. International Conference on Machine Learning, 2022.
Xianghao Xu, Wenzhe Peng, Chin-Yi Cheng, Karl D.D. Willis, and Daniel Ritchie. Inferring cad modeling sequences using zone graphs. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. June 2021.
17

---

Published in Transactions on Machine Learning Research (02/2023)
A Appendix
A.1 Hashing Indexed B-reps
We use duplication detection (illiis et al. 2021b) tools to compare B-reps. This is used, for example, to assess the degree to which the generated B-reps exactly match with those in the training set, quantify the diversity of samples generated by SolidGen, etc. The duplicate detection algorithm is based on the Weisfeiler Lehman isomorphism test. Two graphs are built from the B-rep- a face adjacency graph (Ansaldi et al, 1985) where the B-rep faces are graph nodes and adjacent faces connected by graph edges, and vertex adjaceney graph where B-rep vertices are graph nodes and the B-rep edges are graph edges. The quantized vertex positions are used to initialize the vertex hashes and stored as node attributes, and the curve type information stored as edge attributes, making the final hash dependent on the solid geometry. The final hash string for each solid is created by concatenating the graph hashes of the face adjacency and vertex adjacency graphs.
A.2
Converting Indexed B-reps to B-reps
Here we detail the complete method to convert indexed B-reps B = (V.E,F) to B-reps.
A.2.1 Vertices and Edges
Each point in V is potentially a B-rep vertex. Each edge is used dereference into V and collect the list of points defining the edge and its geometry. The endpoints of E are used to construct a pair of B-rep vertices if they do not already exist, and the topological B-rep edge connecting them. The curve geometry is defined by the cardinality of E: two points define line, while three points define an are (see Figure 3 right). Since we sort the indices in each edge in ascending order for ordering invariance, the start point, are midpoint and end point must be identified. We do this by considoring the permutations of the three points, and choose the one where the second point coincides with the point evaluated at the middle parameter of the arc.
A.2.2 Wires
Next, examine each face in F to gather the list of edges bounding it. Note that edges bounding face can either be part of an outer wire running in counter-clockwise direction that defines the visible part of the face's geometry, or part of one or more inner wires rumning in clockwise direction that define the hidden portion (holes) in the face's geometry. Our goal here to form these wires by connecting the given set of edges into one or more closed loops. We achieve this by defining a vertex-edge graph where each B-rep edge and its vertices are graph nodes connected by directed edges and detecting cycles in this graph (see Figure A1 (a)). Each cycle (except trivial ones) defines wire, and the outer wire is defined the largest wire (based on the extents of its bounding box). The other wires are assumed to run in clockwise direction and define holes.
A.2.3 Surfaces
We support five prismatic parametric surface types that are common in CAD: plane, cylinder, cone, sphere, and torus. We develop an algorithm that identifies the surface type by finding the simplest surface consistent with the boundary curves in the wires bounding face within a prescribed tolerance (see Figure Al (b)).
If all curves in the face are coplanar then a plane is fitted. Otherwise, the curves are checked for consistency with a cylinder, cone, sphere and torus in that order.
If a face trimmed by a combination of lines and ares then the surface will either be a cylinder or a cone. For cylinder the radii of the ares must be the same, the normals must be parallel and the centers aligned in the normal direction. Any lines must also be parallel the normal direction. If these conditions are not met then the surface is treated cone.
18

---

Published in Transactions on Machine Learning Research (02/2023)
Top nediot
Bantii
Mini raulus
VERTEX-EDGE GRAPH
Base radios
RAdiis
CYLINDER
CONE
SPHERE
TORUS
WIRE
(a)
(b)
Figure A1: (a) Vertex-cdge graph used to build and orient the wires by finding cycles. (b) Identifying different kinds of surfaces from the curves (lines in blue, ares in green) in the outer wire.
If a face contains only ares, we can define a sphere whose center lies at the center of an arc, and check for consistency with the rest of the arcs. If a sphere is not an appropriate fit, we define a torus with the major radius set to the average of the two largest arcs and minor radius set to that of the smallest arc.
The only ambiguity with this procedure is when face contains single circle on its boundary the surface could be a plane trimmed into a disk hemisphere. Real world CAD data does not contain many examples like this. Spheres lypically appear only on corner fillets as part of three-sided faces where the presence of three non-coplanar ares clearly disambiguates this case.
A.2.4 Faces
With wires and surfaces available, it is straightforward to combine them to build face using the solid modeling kernel. Finally, to topologically connect the individual faces with each other, we sew the faces into shells, and further attempt to stitch the shells into a single solid model.
A.3 Masking Invalid Logits
During the autoregressive sampling, we mask the invalid logits (by setting their values to a small number cgg. -109) that do not satisfy these criteria at each time step, and distribute the next token probabilities among the valid logits as Nash al. (2020) (which happens automatically when applying the softmax operation). Let t denote the current step in the sampling starting from for the first step.
For the vertex model:
If the vertex token being generated is z-coordinate (t mod 0) then it has to be greater than equal to the previons z-coordinate that generated.
If the vertex token being generated y-coordinate (t mod 1), and the last z-coordinates were equal, then it has to be greater than equal to the previous y-coordinale that was generated.
If the vertex token being generated is a x-coordinate (t mod 3 = 2), and the last two z-coordinates and y-coordinates were equal, then it has be greater than the previous x-coordinate that was generated.
The <EOS> token can only appear after an x-coordinate ic. when t > and t mod 3 = 0.
For the edge model:
The <EOS> and <NEW_EDGE> EDGE> tokens can only appear if t * 0 and cannot be repeated consequently.
<NEW If the previous token <NEM_EDGES EDGE>, then the current token has to be greater than equal to first token in the previous edge to respect the sorted ordering of the edges.
If the previous token was not a <NEW [EW_E, then the current token has be greater than the previous token to respect the sorted order of tokens within each edge.
19

---

Published in Transactions on Machine Learning Research (02/2023)
(b)
(c)
Figure A2: (a) An example of an image pair shown to the crowd workers. (b) Examples of "realistic" models (from the DeepCAD training set) shown to the crowd workers. (c) Examples of unrealistic models. Two of these were generated by DeepCAD and two by SolidGen.
<NEW_EDGE> EDGE> or <EOS> tokens can only appear after two or three edge tokens have been generated. This guarantees that we define an edge as line or an arc.
A <NEW
For the face model:
The <EOS> and <NEW_ EDGE> tokens can only appear if + 0 and cannot be repeated consequently.
If the previous token was <NEW_FACES token, then the current token has to be greater than or equal to first token in the previous face to respect the sorted ordering of the faces.
If the previous token was not FECEF, then the current token has to be greater than the previous token to respect the sorted order of tokens within each face.
A <WEW_FACE> <EOS> tokens can only appear at least two face tokens have been generated. This guarantees that each face at least two edges make it closed e.g. two arcs.
An edge index can only be used twice in the sampled face tokens. This ensures that an edge can at most be shared by two faces, and helps prevents non-mannn non-monifold results.
A.4 Human Evaluation
As discussed in [Section 5.1 to evaluate the realism of the models generated by SolidGen, we perform a perceptual study using human evaluators recruited through Amazon's Mechanical Turk service (Mishra 2019). The crowd workers were shown pairs of images, one which was generated by SolidGen or DeepCAD and the other randomly selected from the training set. The position of the image of the generated model was randomized to be at the top the bottom of the pair. An example of an image pair is shown in Figure A2h. The crowd workers were asked to select the model which they found to be most "realistic". To assist with this task we provided four examples of realistic models (Figure A2p) and "unrealistic" models (Fiuuee A2p). The realistic examples were carefully chosen from the training set to include desirable properties like symnetry and clear design intent and function. For the unrealistic examples we deliberately selected models which had obvious problems like missing faces or which formed an incoherent collection of shapes.
In total 4900 pairs of images were shown to the crowd workers, half from SolidGen and half from DeepCAD. Each pair was independently judged by 7 crowd workers and record the number of raters who identified the generated model as more realistic than randomly selected model from the training set. This gives us a "realism" " score from 0 7 for each image pair. The percentage of image pairs with each realism are shown in the histogram in Figure of the main paper.
If the human raters were selecting randomly between the two images then we would expect Figure 6 to form binomial distribution. We see that for SolidGen the distribution is centered on a realism score of 3.5, but has wider tails than would be expected from chance alone. This indicates that while the realism of the
20

---

Published in Transactions on Machine Learning Research (02/2023)
1020
(a)
(b)
(c)
(d)
(e)
Figure A3: (a) An example of one of the parametric sketch templates used to build the dataset. (b -) Examples of generated models with the extrusion from the inner wire added to the base extrusion. Here we see the effect of modifying the parameters controlling both the sketch geomelry and the lengths of the two extrusions. (e) The result of a Boolean subtraction of the inner wire.
models generated by SolidGen is very similar to the training data, the raters do tend to agree on the realism of individual examples to greater extent than would be expected by chance alone.
For the DeepCAD data there is clear skew towards the raters identifying the training set as more realistic.
A.5 Generation of the Parametric Variation Dataset
The parametric variation (PVar) dataset was created using constrained parametric sketches from the Sketch- Graphs dataset (Seff et al. 2020). Geometry and constraints were first extracted from 60 hand picked sketches and additional constraints and parameters controlling the lengths of lines and radii of ares and circles added one by one until the sketches were optimally constrained (Bouma et al. 1995). These parameters could then be varied generale multiple sketch geometries, while the constraints enforce aspects of the design intent such horizontal, vertical and parallel lines and concentric ares and circles.
In cases where the sketch geometry defined multiple adjacent regions (sce Figure A3 (a)). the curves were organized into a set of nested wires. The outermost wire is chosen to contain the union of the regions and inner wires chosen at random to avoid any two wires sharing the same curve. The outermost wire is first extruded by random distance forming a base extrusion. The inner wires are then extruded, starting from the top plane of the base extrusion and a Boolean union or subtraction used to either add or remove material from the result. Figure A3 show the results of this process. The solids generated from each distinct sketch template are considered to belong the same class resulting in 60 classes Figure A4 shows one representative example from each class.
A.6 Criteria used to Evaluate Validity of Generated B-reps
We consider a B-rep to be valid if was successfully built from the network's output and additionally satisfies the following criteria:
1. Triangulatable. Every face in the B-rep must generate least one triangle, otherwise cannot be rendered properly and not possible to manufacture.
2. Wire ordering. The edges in each wire in the B-rep must be ordered correctly. We check this using the ShapeAnalysis setieaallllssssieesesseeeeeeeeee CheckOrder () function in PythonOCC (Paviol) 2008 with tolerance of 0.01.
3. No wire self-inteersectonn The wires should not self-intersect to ensure that faces are well-defined and surfaces trimmed correctly. We check this using the ShapeAnalysis Wire: cft () function in PythonOCC with a tolerance of 0.01.
4. No bad edges. The edges in shells should be present once or twice but with different orientations. This be checked with the ShapeAnalysis Shell: HasBadEdges () function.
21

---

Published in Transactions on Machine Learning Research (02/2023)
Figure A4: One example from each class the PVar dataset.
A.7 Architecture of Image and Voxel Encoders
The image encoder is a 2D convolutional neural network (CNN), that takes 105 x 128 RGB images and outputs (16 x 16) demb features, where dembb = 256. Its architecture is defined as:
Conv2d 7, 2) + GELU() Conv2d 1,2) + GELU() Dropout(0.1) + Conv2d 1,2) - GELU() Conv2d 1) GELU() (r.pout(O.1) PosEmbed() - SpatialFlatten()
AdaptiveeAvgPool22(16,,, 16) 2onv
where Convuu(output channels, kernel size, padding, stride) stride) is 2D convolutional layer with bias included, GELU() is the Gaussian error linear unit activation (Hendrycks & Gimpel 2016 (ropout(probabilit)) is the dropout layer Srivastava et al. (2014), AdaptiiveAvgPPoo22(((egeggg width) is an adaptive average pooling layer that outputs feature maps of the given spatial resolution, PosEmbed()) learns embeddings for the spatial indices of the grid and adds them the fcatures, and SpatialFlatten flattens a convolutional feature map of shape (N C x H W) into (N x C (H W)), and further reshapes it into N (H W) C where the second dimension is treated the sequence dimension as in Nash et al. (2220).
The voxel encoder is 3D CNN that takes in 64 x 64 x 64 binary voxel grids and outputs (8 x 8 x 8) x demb features. It's architecture is:
Embed(2, 8) ->Conv3d 7, 2) - GELU() + (64, 1, GELU() + (0opout(O.1) + Conv3d (64, 3, 1, - GELU() + Conv3d 3, 1, - GELU() + Dropout(0.1) + Conv3d 3, 2) PosEmbed(() SpatialFlatten().
where the Einedd dimension, output dimension) is linear embedding layer that maps the binary voxels into learned 8 dimensional features. The output features are utilized by SolidGen via cross-attention
as described in Section 5.2
A.8 Additional Results
Additional results comparing DecDCAD (wu et al. 2021 and SolidGen on the unconditional generation task are shown in Figure A5
and Figure A6
We show additional results for class-conditional generation on the and image conditional and voxel conditional results on the DeepCAD dataset. in respectively.
PVar dataset in Figure A7
Figure A8 and F Figure A9
We include the top-k accuracy plots (1 < k < 10) for SolidGen evaluated on the DeepCAD WW
2021
test set. in Figure A10
22

---

Published in Transactions on Machine Learning Research (02/2023)
(a) DeepCAD
(b) SolidGen
Figure A5: Additional unconditional generation results.
23

---

Published in Transactions on Machine Learning Research (02/2023)
(a) DeepCAD
(b) SolidGen
Figure A6: Additional unconditional generation results.
24

---

Published in Transactions on Machine Learning Research (02/2023)
CRNOO
Figure A7: Additional class-conditional generation results. Each row shows samples generated from the
same class.
Figure A8: Additional image conditional samples from SolidGen using images (first column) obtainod by rendering CAD models the DeepCAD lest. set..
25

---

Published in Transactions on Machine Learning Research (02/2023)
Figure A9: Additional voxel conditional samples from SolidGen using voxelized point clouds (first column) obtained by sampling 2048 points from CAD models in the DeepCAD test set.
100
100
80
80
60
Accuracy %
60
%
60
20
Edge
Face Uniform
Uniform
10
22
3
5
9
10
7
9
10
Top-k
Top-k
Top-k
Figure A10: Top-k next-token prediction accuracy of the unconditional SolidGen model trained the DeepCAD dataset compared to a uniform baseline.
26


Reviews:
[{"review_id": "ScQdu1lchm", "reviewer": "Reviewer_8NAT", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strengths:\n\n* Direct B-rep modelling makes sense: Approaches that generate sequences of user actions can be constrained to a limited set of user operations. And it is complex to extend such approaches to the full range of useful operations. Also, data availability is an important consideration: Autoregressive modelling performance scales reliably with data, and CAD data withouts user operation sequences is more abundant. \n* The work presents a sensible strategy for representating B-rep data in a way suitable for AR modelling. It builds on PolyGen and related models, with reasonable tweaks to the data representation and architecture. \n* The paper is well-written: Visualizations are clear and useful, and the method description is clear.\n* The results look good, although some instances of poorly formed designs can be found.\n\nWeaknesses:\n\n* The models are pretty small, which will impact performance. It would be interesting to see something like a scaling study: how performance changes as a function of model size. If overfitting is an issue at this dataset size, it would be good to know.\n\nQuestions:\n\n* What is the impact of the 6-bit quantization? That isn't a whole lot of precision, does it limit the complexity of the shapes that can be generated?\n* In the face model, does summing the vertex embeddings for an edge destroy order information which might be useful?\n* Are the vertex encoders shared in the edge and face model? And if not, it could be worth trying.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The authors present the first autoregressive model of CAD designs that directly generates boundary-representation format (B-rep) designs. The work extends the PolyGen-style [1] modelling approach (autoregressive transformers + pointer networks) to B-rep data, formulating a data representation, and architecture modifications to handle this domain. The authors demonstrate that the approach works well and that generations can be conditioned by class, image and voxel contexts. \n\n[1] PolyGen: An Autoregressive Generative Model of 3D Meshes, Charlie Nash, Yaroslav Ganin, S. M. Ali Eslami, Peter W. Battaglia, https://arxiv.org/abs/2002.10880", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "Figure 1: Please be more explicit about whether the examples are data or samples. E.g. \"two data examples\", or \"two samples\"\n\nSection 1: Please say how much bigger the datasets with / without modeling history are. This is an important point, and would save readers time.\n\nEnd of section 2: \"By contrast, our method is an autoregressive\ngenerative model, and does not require an expensive optimization step to build plausible B-reps.\" -> autoregressive generation is pretty expensive too. Is there a more convincing argument for the benefits of autoregression vs the optimization-based approach?\n\nEquation (3): The p(z) should be omitted, as we're conditioning on z\n\nI would appreciate a bit more of an explanation of the use of B-rep arc points. Sec 4.1: \"...additional points inserted on B-rep edges to encode the curve primitive information as explained in Figure 3\", Figure 3 doesn't really explain how this works. How does it work with the position / coordinate embeddings?\n\nFig 7. Minor plotting issue: the bottom of the figures are cut off\n\nFig 9: It would be better to show the actual voxels, rather than point clouds\n\n\n", "broader_impact_concerns": "I'm not aware of any broader impact concerns", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "iyYWFtcUVq", "reviewer": "Reviewer_84xv", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strengths: \n\n— The task that is being considered is new, relevant, and differs from those considered previously in the context of CAD generation (e.g. generating CSG trees or CAD commands).\n\n— The solution is adequate and seems to be comprehensively addressing the problem. \n\n— Qualitative and quantitative evaluations are presented versus one related work (DeepCAD) and convincing, with SolidGen models being generally more valid but arguably less diverse/novel. \n\n— The text of the paper is clearly written and easy to follow. \n\n— Interesting conditioning cases (e.g. images and point clouds) are presented. \n\nWeaknesses: \n\n— The list of unsupported CAD primitives includes certain important instances, e.g. B-splines which are arguably crucial in modern CAD designs. \n\n— Technically, using pointer networks in the context of the considered task is similar to their applications in other works, e.g. PolyGen. However, this does not diminish the interesting application of these models to B-rep synthesis. ", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper proposes one of the first generative models for synthesizing solid 3D models structured as a boundary representation (B-rep). B-reps represent an important class of 3D representations that may be natively supported by a variety of CAD systems and geometric modelling kernels. Hence, the capability to directly synthesize data in B-rep format represents natural interest in the context of data-driven 3D design (e.g., for presenting designs initialised by scans, sketches or other forms of 2D/3D data). \n\nThe B-rep format considered in this project basically consists of three lists: vertices, edges (that index into vertices), and faces (index into edges). For each part of the format, a separate transformer-based model is trained to predict parameters of its respective instances in the list, given the previously generated sequence. I view the transformer model as an appropriate architecture due to its success in related tasks (e.g., mesh synthesis) and overall wide adoption. \n\nIn terms of quantitative evaluation, unconditional (from noise) and conditional (from shape category, image, and point cloud) generation results are presented; performance is described in terms of log-likelihood, B-rep validity, novelty, and uniqueness. While the unconditional samples are shown to be quite unique and diverse, constraining generation by feeding in an initializer image or point cloud correctly conditions the results to resemble the input. Both these qualities are important as creative tools aimed to help designers develop CAD designs. ", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "I believe that the evaluation is sufficiently comprehensive, and the text is sufficiently well-written so that no critical changes to the submission is necessary.", "broader_impact_concerns": "Most generative models require careful considerations of their generated samples to avoid ethical concerns. Another concern is leveraging large amounts of authored data in the context of product design (e.g., would one want to ensure that the design is fully “novel” so that no copyright issues are raised?). A recent Github Copilot issue illustrates the potential risks involved with using publicly gathered datasets in the context of data-driven design assistants.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "fSLm2YQG90", "reviewer": "Reviewer_7chE", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "###################################################################\n\n**Summary of the Review:**\n\nOverall, this paper could be an interesting contribution. There is no significant algorithmic development. However, the application studied in the paper is relevant, and the use of a transformer-based generative model to generate B-reps in this new application area is novel. \n\nCurrently, I am leaning toward accepting the paper. \n\n###################################################################\n\n**Strong points:**\n\n1. The paper addresses an important problem in computer-aided design.\n\n2. Utilizing a transformer-based generative model to generative B-reps is novel.\n\n3. The empirical results in the paper are convincing.\n\n4. The paper is well written with great-looking illustrative figures.\n\n###################################################################\n\n**Weak points:**\n\n1. There is no significant algorithmic development in the paper.\n\n2. Comparisons to other methods need to be provided.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "\nThis paper proposes a new generative model, namely the SolidGen, that directly synthesizes the Boundary representation format (B-reps) from a sequence of CAD modeling operations in an unsupervised way using Transformers and two-level pointer networks. The SolidGen operates on the indexed boundary representation which is a new representation for B-reps as numeric arrays proposed by the authors. The index boundary representation maintains the geometry and topology of B-reps. The authors empirically show that the SolidGen achieve impressive results in both unconditional and conditional/controllable generation of B-reps.\n", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "**Questions for the Authors:**\n\n1. Can the authors provide comparisons to other methods on the task of generating B-reps?\n\n2. How can the proposed method be combined with existing CAD methods or incorporated into existing CAD software such as AutoCAD? The authors should discuss these in the paper.", "broader_impact_concerns": "I have no concerns on the ethical implications of the work.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "XXu6mhYRD8", "reviewer": "Reviewer_pQm5", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "## Strong points\n\nThe paper lays out a model which achieves its stated goals, and performs well on the evaluated problem. The proposed model is sound, and models the important relational aspect of the B-rep which is crucial for parametric CAD design. Overall, this paper provides an interesting demonstration of the possibility of auto-regressive generative modeling of B-rep for CAD design, with potentially interesting applications in the future.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The authors consider the problem of generating a CAD model through its B-Rep (boundary representation). The B-rep is the de-facto representation for parametric CAD models, representing shapes as geometric graphs. They propose an autoregressive model to generate the B-rep through its (hyper-)graph representation. The model uses a transformer architecture, augmented with pointer networks to represent relations. The model is evaluated on an unconditional generation task, as well as a generation task conditioned on a rendering of the CAD target.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "1. It would be great to improve the description of the B-rep in section 3, by e.g. including diagrams as in fig. A1 as well as providing a formal mathematical description (perhaps simplified) of the data at hand. This would help make the main text better self-contained and more accessible to an applied ML audience who may not be familiar with CAD design. This would also clarify the constructions used in section 4. (This recommendation is important for my recommendation).\n\n2. In fig. 3, the wireframe in the first panel is very light and hard to see - I would recommend increasing the line weight of the figure in order to make it more apparent. (This recommendation is minor)\n\n3. In section 5, or a separate appendix, it would be great to include the following details of training: 1) all hyper-parameters of training, including AdamW L2 decay parameter, number of training epochs, learning rate scheduling (if any) etc. 2) include some details on how the hyper-parameters were selected (e.g. manually / automatically), 3) include some information about training time / hardware. (This recommendation is minor).", "broader_impact_concerns": "I do not have any broader impact concerns", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: The paper is of particularly high-quality: well-written, technically sound, making a novel and potentially impactful contribution that is convincingly evaluated. I think it's appropriate for a featured certification.

Before the paper can be formally accepted, I would like to request a minor revision. In the camera-ready version, I would like the authors to comment on the following questions, which came up during the discussion with the reviewers:

1. The list of unsupported CAD primitives includes certain instances, such as B-splines, which are important in modern CAD. Can the proposed approach be modified to take these into account?

2. The paper considers relatively small models in the experimental evaluation. How does the approach scale with model size? Is overfitting a concern?

Decision: Accept (poster)