Geometry-Informed Neural Networks

## Abstract

Abstract Geometry is a ubiquitous tool in computer graphics, design, and engineering.
However, the lack of large shape datasets limits the application of state-of-the-art supervised learning methods and motivates the exploration of alternative learning strategies.
To this end, we introduce geometry-informed neural networks (GINNs) – a framework for training shape-generative neural fields without data by leveraging user-specified design requirements in the form of objectives and constraints.
By adding diversity as an explicit constraint, GINNs avoid mode-collapse and can generate multiple diverse solutions, often required in geometry tasks.
Experimentally, we apply GINNs to several validation problems and a realistic 3D engineering design problem, showing control over geometrical and topological properties, such as surface smoothness or the number of holes.
These results demonstrate the potential of training shape-generative models without data, paving the way for new generative design approaches without large datasets.

## 1 Introduction

Recent advances in deep learning have revolutionized fields with abundant data, such as computer vision and natural language processing. However, the scarcity of large datasets in many other domains, including 3D computer graphics, design, engineering, and physics, restricts the use of advanced supervised learning techniques, necessitating the exploration of alternative learning strategies.

Fortunately, these disciplines are often equipped with formal problem descriptions, such as objectives and constraints.
Previous works for PDEs [], molecular science [], and combinatorial optimization [] demonstrate these can suffice to train models even in the absence of any data.
The success of these data-free approaches motivates an analogous attempt in geometry, raising the question:
*Is it possible to train a shape-generative model on objectives and constraints alone, without relying on any data?*

We address this question by introducing *geometry-informed neural networks* or *GINNs*.
GINNs are trained to satisfy specified design constraints and to produce feasible shapes without any training samples.
A GINN solves a topology optimization problem using *neural fields*, which offer detailed, smooth, and topologically flexible geometry representations, while being compact to store. This setup is analogous to physics-informed neural networks but with a high number of varied constraints: differential, integral, geometrical, and topological.

In contrast to both physics-informed neural networks and classical topology optimization, GINNs allow to generate multiple solutions by enforcing solution *diversity* as an explicit constraint.
This is of high interest when applied to problems with solution multiplicity, e.g., induced by under-determinedness or near-optimality common in geometry problems.
To connect back to our research question: with GINNs we can train neural fields that satisfy user-specified design constraints, and by adding diversity as an explicit constraint, we can generate a multiplicity of solutions.
GINNs can thus be used as shape-generative models trained purely on constraints and without data.

We take several steps to demonstrate GINNs experimentally.
We formulate a tractable learning problem using constrained optimization and by converting constraints into differentiable losses.
After solving several introductory problems, we proceed to a realistic 3D engineering design problem.
Figure 1 illustrates this task of designing a jet-engine lifting bracket, or geometrically – connecting cylindrical interfaces within the given design region.
We show different GINNs trained with various additional smoothness and topology requirements.
Figure 6 shows a GINN trained on the same task but with an additional diversity constraint.
Surprisingly, this induces a structured latent space, with generalization capacity and interpretable directions.

We show that training shape-generative networks using constraints and objectives without data is a feasible learning strategy, paving the way for new generative design approaches without large datasets.
Our main contributions are summarized as follows:

- 1.
We introduce GINN - a framework for training shape-generative neural fields without data by leveraging design constraints and avoiding mode-collapse using a diversity constraint.
- 2.
We apply GINNs to several validation problems and a realistic 3D engineering design problem, showing control over geometrical and topological properties.
(^1^11 Code available at [https://github.com/ml-jku/GINNs-Geometry-informed-Neural-Networks](https://github.com/ml-jku/GINNs-Geometry-informed-Neural-Networks))

Figure: Figure 2: GINNs build on neural fields, generative modeling, and theory-informed learning.

## 2 Related work

We begin by reviewing and relating three important facets of GINNs: theory-informed learning, neural fields, and generative modeling.

### 2.1 Theory-informed learning

Theory-informed learning has introduced a paradigm shift in scientific discovery by using scientific knowledge to remove physically inconsistent solutions and reducing the variance of a model [].
Such knowledge can be included in the model via equations, logic rules, or human feedback [, , ].
Geometric deep learning [] introduces a principled way to characterize problems based on symmetry and scale separation principles, e.g. group equivariances or physical conservation laws.

Notably, most works operate in the typical deep learning regime, i.e., with an abundance of data.
However, in theory-informed learning, training on data can be replaced by training with objectives and constraints. More formally, one searches for a solution $f$ minimizing the objective $o(f)\text{ s.t. }f\in\mathcal{K}$, where $\mathcal{K}$ defines the feasible set in which the constraints are satisfied. For example, in Boltzmann generators [], $f$ is a probability function parameterized by a neural network to approximate an intractable target distribution. Another example is combinatorial optimization where $f\in\{0,1\}^{N}$ is often sampled from a probabilistic neural network [, , ].

#### Physics-informed neural networks

(PINNs) [] are a prominent example of neural optimization. In PINNs, $f$ is a function that must minimize the violation $o$ of a partial differential equation (PDE), the initial and boundary conditions, and, optionally, some measurement data.
Since PINNs can incorporate noisy data and are mesh-free, they hold the potential to overcome the limitations of classical mesh-based solvers for high-dimensional, parametric, and inverse problems.
This has motivated the study of the PINN architectures, losses, training, initialization, and sampling schemes [].
We further refer to the survey by Karniadakis et al. [].
Same as PINNs, GINNs use neural fields to represent the solution.
Consequentially, we also observe that some best practices of training PINNs [] transfer to training GINNs.
However, PINNs may suffer from ill numerical properties due to minimizing the squared residual of the strong-form different to classical PDE solvers [, ].
In contrast, GINNs share the same underlying formulation and numerical properties as classical topology optimization methods.
In addition to a high number of various constraints (differential, integral, geometrical, and topological), geometric problems often require solution multiplicity, motivating the generative extension.

### 2.2 Neural fields

A *neural field* (NF) (also coordinate-based NN, implicit neural representation (INR)) is a NN (typically a multilayer-perceptron) representing a function $f:x\mapsto y$ that maps a spatial and/or temporal coordinate $x$ to a quantity $y$. Compared to discrete representations, NFs are significantly more memory-efficient while providing higher fidelity, continuity, and access to automatic differentials.
They have seen widespread success in representing and generating a variety of signals, including shapes [, , ], scenes [], images [], audio, video [], and physical quantities [].
For a more comprehensive overview, we refer to the survey by Xie et al. [].

#### Implicit neural shapes

(INSs) represent geometries through scalar fields, such as occupancy [, ] or signed-distance [, ].
In addition to the properties of NFs, INSs also enjoy topological flexibility supporting shape reconstruction and generation.
We point out the difference between these two training regimes.
In the generative setting, the training is supervised on the ground truth scalar field of every shape [, , ].
However, in surface reconstruction, i.e., finding a smooth surface from a set of points measured from a single shape, no ground truth is available and the problem is ill-defined  [, ].

#### Regularization

methods have been proposed to counter the ill-posedness in geometry problems. These include leveraging ground-truth normals [] and curvatures [], minimal surface property [], and off-surface penalization [].
A central effort is to achieve the distance field property of the scalar field for which many regularization terms have been proposed: eikonal loss [], divergence loss [], directional divergence loss [], level-set alignment [], or closest point energy [].
The distance field property can be expressed as a PDE constraint called *eikonal equation* $|\nabla{f(x)}|=1$, establishing a relation of regularized INSs to PINNs [].

#### Inductive bias.

In addition to explicit loss terms, the architecture, initialization, and optimizer can also limit or bias the learned shapes.
For example, typical INSs are limited to watertight surfaces without boundaries or self-intersections [, ].
ReLU networks are limited to piece-wise linear surfaces and together with gradient descent are biased toward low frequencies [].
Fourier-feature encoding [], sine activations [], and wavelet activations [] allow to control this frequency bias. Similarly, initialization techniques are important to converge toward desirable optima [, , , ].

### 2.3 (Data-free) Generative modeling

Generative modeling [, , , ] is almost exclusively performed in a data-driven (i.e., supervised) setting to capture and sampling from the underlying data-distribution. However, notable exceptions exist.

#### Boltzmann generators

[] are a prominent example of *data-free* generative models.
They are trained to capture the Boltzmann distribution associated with an energy landscape. In the generative setting, GINNs also learn a distribution minimizing an energy as an implicit combination of constraint violations and objectives.
However, Boltzmann generators avoid mode-collapse using an entropy-regularizing term which presupposes invertibility making them not directly applicable to function spaces.
Instead, GINNs use a more general diversity term to hinder mode-collapse over the function space of shapes.

#### Conditional neural fields

allow for generative modeling of functions.
By conditioning a base network $F$ on a modulation (i.e, latent) variable $z$, a conditional NF encodes multiple fields simultaneously: $f(x)=F(x;z)$. The different choices of the conditioning mechanism lead to a zoo of architectures, including input concatenation [], hypernetworks [], modulation [], and attention []. These can be classified into global and local mechanisms, which also establishes a connection between conditional NFs and operator learning [].
For more detail we refer to Xie et al. [], Rebain et al. [], Wang et al. [].

#### Generative design

refers to computational methods that automatically conduct design exploration under constraints set by designers [].
It holds the potential of streamlining innovative solutions, e.g., in material design, architecture, or engineering.
In particular, GINNs can be seen as solving the general task of *topology optimization* – finding the material distribution that minimizes a specified objective subject to constraints. However, while classical methods optimize a single shape directly, we optimize a GINN that generates diverse feasible shapes. This encourages design space exploration and supports downstream tasks, while allowing to incorporate even sparse data samples, if available.
While generative design datasets are not abundant, deep learning has previously shown promise in material design and topology optimization.
For more detail, we refer to surveys on generative models in engineering design [] and topology optimization via machine learning [].

## 3 Method

Consider the metric space $(d,\mathcal{F})$ of functions, such as those representing a shape or a PDE solution.
Let the set of constraints define the feasible set $\mathcal{K}=\{f\in\mathcal{F}|c_{i}(f)=0,i=1..m\}$.
Additionally, let the geometric problem be equipped with an objective $o:\mathcal{F}\mapsto\mathbb{R}$.
Selecting the objectives and constraints of a geometric nature lays the foundation for a *GINN*, which is trained to produce an optimal feasible solution by solving $\min_{f\in\mathcal{K}}o(f)$.
A key feature of geometric problems is that one is often interested in finding different near-optimal solutions, for example, due to incompleteness, uncertainty, or under-determinedness in the problem specification (e.g. see Figure A.4). This motivates making GINN *generate* a set of sufficiently diverse near-optimal solutions $S\subset\mathcal{K}$:

$$ $\min_{\begin{subarray}{c}S\subset\mathcal{K}\\ \delta(S)\geq\delta_{\text{min}}\end{subarray}}O(S)\ .$ (1) $$

$O(S)$ aggregates the objectives $o(f)$ of all solutions $f\in S$ and $\delta$ captures some intuitive notion of *diversity*.
It is yet another constraint, however it acts on the entire solution set instead of each solution separately.
Section 3.1 first discusses representing shapes as functions, in particular, neural fields, and formulating differentiable constraints.
In Section 3.2, we generalize to representing and finding diverse solutions using conditional neural fields.

Figure: Figure 3: The user can define geometric problems and solve them using the GINN framework. Here, we illustrate the results of progressively adding more design requirements, overall resulting in a shape generative model trained without data.
Refer to caption: x2.png

### 3.1 Finding a solution

**Table 1: Geometric constraints used in our main experiment. The shape $\Omega$ and its boundary $\partial\Omega$ are represented implicitly by the (sub-)level set of the function $f$. The shape must be contained within the *design region* $\mathcal{E}\subseteq\mathcal{X}$ and attach to the *interface* $\mathcal{I}\subset\mathcal{E}$ with a prescribed *normal* $\bar{n}(x)$. Other interesting constraints are listed in Table 5.**
|  | Set constraint $c_{i}(\Omega)$ | Function constraint | Constraint violation $c_{i}(f)$ |
| --- | --- | --- | --- |
| Design region | $\Omega\subset\mathcal{E}$ | $f(x)>0\ \forall x\notin\mathcal{E}$ | $\int_{\mathcal{X}\setminus\mathcal{E}}\left[\operatorname{min}(0,f(x))\right]^<br>{2}\operatorname{d}\!{x}$ |
| Interface | $\partial\Omega\supset\mathcal{I}$ | $f(x)=0\ \forall x\in\mathcal{I}$ | $\int_{\mathcal{I}}\left[f(x)\right]^{2}\operatorname{d}\!{x}$ |
| Prescribed normal | $n(x)=\bar{n}(x)\ \forall x\in\mathcal{I}$ | $\frac{\nabla f(x)}{||\nabla f(x)||}=\bar{n}(x)\ \forall x\in\mathcal{I}$ | $\int_{\mathcal{I}}\left[\frac{\nabla f(x)}{||\nabla f(x)||}-\bar{n}(x)\right]^<br>{2}\operatorname{d}\!{x}$ |
| Topology | Using persistent homology; see Section 4.1 and Appendix E |  |  |

#### Representation of a solution.

Let $f:\mathcal{X}\mapsto\mathbb{R}$ be a continuous scalar function on the domain $\mathcal{X}\subset\mathbb{R}^{n}$.
The sign of $f$ *implicitly* defines the shape $\Omega=\left\{x\in\mathcal{X}|f(x)\leqslant 0\right\}$ and its boundary $\partial\Omega=\left\{x\in\mathcal{X}|f(x)=0\right\}$.
We use a NN $f=f_{\theta}$ with parameters $\theta$ to represent the implicit function, i.e. an *implicit neural shape*, due to its memory efficiency, continuity, and differentiability.
Nonetheless, the GINN paradigm extends to other representations, as demonstrated in Section 4.2.
We additionally require $f$ to approximate the *signed-distance function* (SDF) of $\Omega$ (defined in Eq. 21).
This alleviates the ambiguity of many implicit functions representing the same geometry and aids the computation of persistent homology, surface point samples, and diversity.
In training, the eikonal constraint is treated analogously to the geometric constraints.

#### Constraints on a solution.

To perform gradient-based optimization, we must first ensure each constraint can be written as a differentiable constraint violation $c_{i}:\mathcal{F}\mapsto\mathbb{R}$.
A geometric constraint has the general form $c_{i}(\Omega,\partial\Omega)=0$.
By representing the shape and its boundary as the (sub-)level-set of the function $f$, the constraints on the sets can be translated into constraints on $f$.
This in turn allows to formulate differentiable constraint violations $c_{i}$, although this choice is not unique.
Table 1 shows several examples using the constraints from our main experiment.
Some losses are straightforward and some have been previously demonstrated as regularization terms for INSs (see Section 2.2).
Section 4.1 discusses two complex losses in more detail: connectedness and smoothness.

### 3.2 Generating diverse solutions

#### Representation of the solution set.

The *generator* $G:z\mapsto f$ maps a latent variable $z\in Z$ to a function $f$. The solution set is hence the image of the latent set under the generator: $S=\operatorname{Im}_{G}(Z)$.
Furthermore, the generator transforms the input probability distribution $p_{Z}$ over $Z$ to an output probability distribution $p$ over $S$. In practice, the generator is a modulated base network producing a conditional neural field: $f(x)=F(x;z)$.

#### Constraints on the solution set.

By adopting a probabilistic view, we extend each constraint violation and the objective to their expected values:
$C_{i}(S)=\mathop{\mathbb{E}}_{z\sim p_{Z}}\left[c_{i}(G(z)\right]$
and $O(S)=\mathop{\mathbb{E}}_{z\sim p_{Z}}\left[o(G(z)\right]$.

#### Diversity of the solution set.

The last missing piece to training a generative GINN is making $S$ a diverse collection of solutions.
In the typical supervised generative modeling setting, the diversity of the generator is inherited from the diversity of the training dataset.
The violation of this is studied under phenomena like *mode-collapse* in GANs [].
Exploration beyond the training data has been attempted by adding an explicit diversity loss, such as
entropy [],
Coulomb repulsion [],
determinantal point processes [, ],
pixel difference, and structural dissimilarity [].
We observe that simple generative GINN models are prone to mode-collapse, which we mitigate by adding a *diversity constraint*.
Many scientific disciplines require to measure the diversities of sets which has resulted in a range of definitions of diversity [, , ].
Most start with a *distance* $d:\mathcal{F}^{2}\mapsto[0,\infty)$, which can be transformed into the related *dissimilarity*. *Diversity* $\delta:2^{\mathcal{F}}\mapsto[0,\infty)$ is then the collective dissimilarity of a set [], aggregated in some way.
In the following, we describe these two aspects: the distance $d$ and the aggregation into the diversity $\delta$.

#### Aggregation.

Adopting terminology from Enflo [], we use the *minimal aggregation measure*:

$$ $\displaystyle\delta(S)=\left(\sum_{i}\left(\min_{j\neq i}d(f_{i},f_{j})\right) ^{1/2}\right)^{2}\ .$ (2) $$

This choice is motivated by the *concavity* property, which promotes uniform coverage of the available space, as depicted in Figure 11.
Figure 5 illustrates how it counteracts mode-collapse in a geometric problem.
However, Equation 2 is well-defined only for finite sets, so, in practice, we apply $\delta$ to a batch of $k$ i.i.d. sampled shapes $S_{k}=\{G(z_{i})|z_{1},...,z_{k}\overset{iid}{\sim}p_{Z}\}$.
We leave the consideration of diversity on infinite sets, especially with manifold structure, to future research.

#### Distance.

A simple choice for measuring the distance between two functions is the $L^{2}$ function distance $d_{2}(f_{i},f_{j})=\sqrt{\int_{\mathcal{X}}(f_{i}(x)-f_{j}(x))^{2}
\operatorname{d}\!{x}}$.
However, recall that we ultimately want to measure the distance between the shapes, not their implicit function representations.
For example, consider a disk and remove its central point.
While we would not expect their shape distance to be significant, the $L^{2}$ distance of their SDFs is.
This is because local changes in the geometry can cause global changes in the SDF.
For this reason, we modify the distance (derivation in Appendix F) to only consider the integral on the shape boundaries $\partial\Omega_{i},\partial\Omega_{j}$ which partially alleviates the globality issue:

$$ $d(f_{i},f_{j})=\sqrt{\int_{\partial\Omega_{i}}f_{j}(x)^{2}\operatorname{d}\!{x }+\int_{\partial\Omega_{j}}f_{i}(x)^{2}\operatorname{d}\!{x}}\ .$ (3) $$

If $f_{j}$ is an SDF then $\int_{\partial\Omega_{i}}f_{j}(x)^{2}\operatorname{d}\!{x}=\int_{\partial
\Omega_{i}}\min_{x^{\prime}\in\partial\Omega_{j}}||x-x^{\prime}||_{2}^{2}
\operatorname{d}\!{x}$ (analogously for $f_{i}$) and $d$ is closely related to the *chamfer discrepancy* [].
We note that $d$ is not a metric distance on functions, but recall that we care about the geometries they represent.
Using appropriate boundary samples, one may also directly compute a geometric distance, e.g., any point cloud distance [].
However, the propagation of the gradients from the geometric boundary to the function requires the consideration of boundary sensitivity [], which we leave for future work.

In summary, training a GINN corresponds to solving a constrained optimization problem, i.e. improving the expected objective $O(S)$ and feasibility $C_{i}(S)$ w.r.t. to each geometric constraint $i=1..m$ and the diversity constraint $C_{m+1}(S_{k})=\max(\delta(S_{k})-\delta_{\text{min}},0)$.
In practice, we convert this into a sequence of unconstrained optimization problems using the augmented Lagrangian method introduced in Section 4.1.

## 4 Experiments

We proceed to demonstrate the proposed GINN framework experimentally on a set of validation problems concluding with a realistic 3D engineering design use case.
To the best of our knowledge, data-free shape-generative modeling is an unexplored field with no established baselines, problems, and metrics.
In addition to the problems defined and solved in Sections 4.2 and 4.3, we define metrics for each constraint in the main problem as detailed in Appendix C.1.
We use these to perform quantitative ablation studies in Appendix C.2, reserving the primary text for the main findings.
We proceed with an overview of key experimental considerations with more implementation and experiment details available in Appendix A.

### 4.1 Experimental details

#### Constrained optimization.

To solve the aforementioned constrained optimization problems in Eq. 1, we employ the *augmented Lagrangian method* (ALM).
It is well studied in the classical and more recently deep learning literature and balances the feasibility and optimality of the solution by controlling the influence of each constraint while avoiding the ill-conditioning and convergence issues of simpler methods.
Specifically, we use an *adaptive* ALM proposed by Basir and Senocak [] which uses adaptive penalty parameters $\mu_{i}$ for each constraint to solve problem 1 as the unconstrained optimization problem $\max_{\lambda}\min_{\theta}\mathcal{L}(\theta,\lambda,\mu)$ where

$$ $\mathcal{L}(\theta,\lambda,\mu):=O(S_{k}(\theta))+\sum_{i=1}^{m+1}\lambda_{i}C _{i}(S_{k}(\theta))+\frac{1}{2}\sum_{i=1}^{m+1}\mu_{i}C_{i}^{2}(S_{k}(\theta))\ .$ (4) $$

The multipliers $\lambda_{i}$ and the penalty parameters $\mu_{i}$ are updated during training according to Equations (18) - (20).
Adaptive ALM allows GINNs to handle different constraints without manual hyperparameter tuning for each loss.
Appendix D provides a more detailed introduction and motivation for this approach.

#### Topology

describes properties of a shape that are invariant under deformations, such as the number of connected components or holes.
Certain materials and objects display specific topological properties [, , ], e.g., *connectedness*, which is a basic requirement for the propagation of forces and by extension manufacturability and structural function.
Despite topological properties being discrete-valued, *persistent homology* (PH) is a tool that allows to formulate a differentiable loss.
In brief, it identifies topological features (e.g., connected components) and quantifies their *persistence* w.r.t. some *filtration* function.
For our implicit shapes, this is the implicit function $f$ itself.
Consequentially, the *birth* and *death* of each feature can be matched to a pair of critical points of $f$.
Their values can then be adjusted to achieve the desired topology.
In practice, we follow the standard procedure of first discretizing the continuous function onto a cubical complex.
We additionally filter cells outside the given design space to prevent undesirable connections.
Throughout this section, we use a constraint that encourages connected shapes with a minimal number of holes.
We detail PH and our approach in Appendix E.

#### Smoothness

constitutes another computationally non-trivial design requirement that we consider.
Many alternative smoothing energies exist, each leading to different surface qualities [, ], but a broad class can be written as the surface integral $\int_{\partial\Omega\setminus\mathcal{I}}e(\kappa_{1}(x),\kappa_{2}(x))
\operatorname{d}\!{x}$ of some curvature expression $e:\mathbb{R}^{2}\mapsto\mathbb{R}$.
The principal curvatures $\kappa_{1}$ and $\kappa_{2}$, same as other differential-geometric quantities, can be computed from $\nabla_{x}f$ and $H_{x}f$ in closed-form [].
To solve Plateau’s problem, we use the *mean curvature* $\kappa_{H}:=\frac{\kappa_{1}+\kappa_{2}}{2}$.
In the main experiment, we primarily focus on the *surface-strain* $E:=\kappa_{1}^{2}+\kappa_{2}^{2}$ and a variant thereof $E_{\text{log}}:=\log(1+E)$ to produce visually appealing shapes.

#### Surface sampling

is required to estimate the surface integrals for smoothness and diversity. We first sample points in the envelope and project them onto the surface using Newton iterations.
We then repel the points on the surface to achieve a more uniform distribution similar to Yifan et al. [].
Finally, we exclude points sampled within a small distance to the interface $\mathcal{I}$, as the surface should not change here.
We also begin to sample surface points and compute the surface integrals only after a warm-up phase of 500 iterations.
In combination, these aspects lead to a lower variance and better convergence.

#### Models.

Across the experiments, we consider several neural field models.
We require these to have a well-defined and non-vanishing second derivative w.r.t. the inputs $x$ to compute the surface normals and curvatures.
As the simplest models, we use MLPs with a softplus (i.e., differentiable ReLU) activation.
These suffice for the simpler validation experiments, but their simplicity bias is limiting for the physics and the 3D experiment.
Following the recommendation of Wang et al. [], we find SIREN suitable for the physics task. For the main task, we employ WIRE [] – a generalization of SIREN that replaces sine with Gabor wavelet activation functions, which are localized in both the spatial and frequency domains. We show a qualitative comparison in Figure 7.
As the neural field conditioning mechanism, we always use input concatenation (see Section 2.3), denoting the latent space dimension as $\dim(z)$.

### 4.2 Validation problems

#### Generative PINN solving an under-determined reaction-diffusion problem.

As a primer to geometry tasks, we begin by illustrating solution multiplicity on an under-determined physics system.
While most familiar problems in physics are well-defined, cases exist where, e.g., the initial conditions are irrelevant and general PDE solutions are sought, such as in chaotic systems or animations.
We first demonstrate how a PINN can also be extended to provide diverse stationary solutions using a system of *reaction-diffusion* with *no initial condition*.
Figure 4 illustrates the resulting Turing patterns that continuously morph during latent space traversal.
For more detail, we refer to Appendix B.

Figure: Figure 4: A generative PINN producing Turing patterns that morph during latent space interpolation. This is a result of searching for diverse solutions to an under-determined Gray-Scott system.
Refer to caption: extracted/5925591/figures/PINN/5.png

#### Plateau’s problem to demonstrate GINNs on a well-posed problem.

Plateau’s problem is to find the surface $M$ with the minimal area given a prescribed boundary $\Gamma$ (a closed curve in $\mathcal{X}\subset\mathbb{R}^{3}$).
A *minimal surface* is known to have zero mean curvature $\kappa_{H}$ everywhere.
Minimal surfaces have boundaries and may contain intersections and branch points [] which cannot be represented implicitly.
For simplicity, we select a suitable problem instance, noting that more appropriate geometric representations exist [, ].
Altogether, we represent the surface as $M=\partial\Omega\cap\mathcal{X}$ and the two constraints are: $\Gamma\subset M$ and $\kappa_{H}(x)=0\ \forall x\in M$.
The result in Figure 5 qualitatively agrees with the known solution.

#### Parabolic mirror to demonstrate a different geometry representation.

Although we mainly focus on the implicit representation, the GINN framework extends to other representations, such as explicit, parametric, or discrete shapes.
Here, the GINN learns the height function $f:[-1,1]\mapsto\mathbb{R}$ of a mirror with the interface constraint $f(0)=0$ and that all the reflected rays should intersect at the single point $(0,1)$.
The result in Figure 5 approximates the known solution: a parabolic mirror.
This is a very basic example of caustics, an inverse problem in optics, which we hope inspires future work combining GINNs and the recent developments in neural rendering techniques.

#### Obstacle to introduce diversity and connectedness.

Consider a 2D rectangular design region $\mathcal{E}$ with a circular obstacle in the middle.
The interface $\mathcal{I}$ consists of two vertical line segments and has prescribed outward-facing normals $\bar{n}$.
We seek shapes that connect these two interfaces while avoiding the obstacle.
Despite this problem admitting infinitely many solutions, the naive application of the generative softplus-MLP leads to mode-collapse.
This is mitigated by employing the additional diversity constraint as illustrated in Figure 5.

Figure: Figure 5: GINN solving three validation problems. (a) Plateau’s problem: the unique minimal surface that attaches to the prescribed boundary. (b) Parabolic mirror: the unique surface that collects reflected rays into a single point. (c) Obstacle: connecting the two interfaces within the allowed design region. A superposition of 16 solutions is shown trained with and without a diversity loss, which is required to avoid mode-collapse.
Refer to caption: extracted/5925591/figures/GINN/minsurf.png

### 4.3 Engineering design case study

#### The problem specification

is based on an engineering design competition hosted by General Electric and GrabCAD [].
The challenge was to design the lightest possible lifting bracket of a jet engine subject to both physical and geometrical constraints.
Here, we focus only on the geometric requirements: the shape must fit in a provided design region $\mathcal{E}$ and attach to five cylindrical interfaces $\mathcal{I}$: a horizontal loading pin and four vertical fixing bolts.
Instead of minimizing the volume subject to a linear elasticity PDE constraint, we minimize the surface smoothness $E$ subject to a topological connectedness constraint.
Conceptually, this formulation is similar but avoids the need for a PDE solver in the training loop.
These requirements are detailed in Table 1 and illustrated in Figs. 1 and 3.

#### Single solution

to the above problem is included in Figure 3.
The trained GINN model represents a smooth, singly connected shape attaching to the interfaces while remaining within the given design space.

#### Ablations.

In addition to the qualitative presentation, we perform quantitative evaluation and ablations in Appendix C.
Table 3 quantifies the impact of the connectedness constraint and the smoothness objective, as well as some experimental decisions, including the WIRE hyperparameters and eikonal regularization.

#### User control.

We further solve variations of the above problem to highlight the user’s ability to tune the problem and the resulting solutions.
In particular, we include an additional topology constraint on the number of holes and employ another surface smoothness $E_{\text{log}}$.
The variety of produced shapes is illustrated in Figure 1.
This also illustrates the robustness of ALM and GINNs to problem variations.

#### Multiple solutions.

Upon the addition of the diversity constraint, GINNs do not only produce multiple solutions, but we also observe the emergence of a *latent space structure*.
This is illustrated in Figure 6 using a $\dim(z)=2$ latent space from which $k=9$ random samples are drawn every training iteration. Traversing the latent space of the trained GINN produces continuously morphing feasible shapes, i.e. the model *generalizes*.
Furthermore, the latent space is *organized*.
However, we find that the learned structure depends on the exact setup of the diversity constraint.
In particular, we observe a more pronounced organization emerge for larger $\delta_{\text{min}}$ while over-specifying it impacts convergence.

#### Optimization.

The convergence behavior of the aforementioned runs with and without diversity is shown in Figures 9 and 10.
Despite having up to seven loss terms, adaptive ALM automatically balances these and minimizes each constraint violation.
However, the variance in several losses remains high.
This is largely due to the diversity and smoothness terms, which are hard to optimize and increase the necessary number of iterations by roughly a factor of two and five, respectively.
In addition, the necessary surface point sampling accounts for roughly 50% of the runtime, motivating improved strategies.
Overall, training a single shape takes roughly 10K iterations and 1 hour.
Similarly, the discussed diverse model takes 50K iterations and 72 hours.

#### Surface smoothness.

As illustrated in Figure 3, the smoothness term significantly improves the visual quality of the shapes.
However, it is a difficult objective.
First, the values of the surface-strain $E$ span several orders of magnitude and small deviations in the surface sampling cause large variance.
Hence, the strategies described in Section 4.1 are critical to stabilize training.
Employing $E_{\text{log}}$ improves convergence further, but also leads to a different surface quality due to the concavity property of $\log{}$ (cf. top and bottom rows in Figure 1).
In previous works optimizing integrals over fixed domains, adaptive ALM deals with the range issue by adjusting location-specific penalties.
However, this strategy is not directly applicable to our moving surfaces, which presents a unique future challenge.
In addition, curvature is a second-order differential operator and is expected to be ill-conditioned, motivating the use of second-order optimizers to further refine the results [, ].

Figure: Figure 6: With diversity, GINNs do not only produce multiple solutions but also learn a *latent space structure*. Traversing the 2D latent space continuously morphs solutions, i.e., the model *generalizes*. The latent space is also *organized* – a central bulky shape becomes thinner in the radial direction and the axes can be identified by how the shape connects on the sides. Figure 8 shows a $9\times 9$ version.
Refer to caption: x3.png

## 5 Conclusion

We have introduced geometry-informed neural networks demonstrating shape-generative modeling driven solely by geometric constraints and objectives.
After formulating the learning problem and discussing key theoretical and practical aspects, we applied GINNs to several validation problems and a realistic engineering task.

#### Limitations and future work.

GINNs combine several known and novel components, each of which warrants an in-depth study of theoretical and practical aspects, including alternative shape distances and their aggregation into a diversity, conditioning mechanisms, and a broader range of constraints.
In this work, we focused on building the conceptual framework of GINNs and validating it experimentally.
This included a realistic generative design task.
However, we considered a modified version of the original task and did not compare to established topology-optimization methods as this required an integration of a PDE solver – a task that future work should address.
Even though ALM is a significant improvement over the naive approach of manually weighted loss terms, the recent literature on multi-objective and second-order optimizers suggest further possible improvements.
Finally, we investigated GINNs in the limit of no data.
However, GINNs can integrate partial observations of a single or multiple shapes.
This combination of classical and machine learning methods suggests a new approach to generative design in data-sparse settings, which are of high relevance in practical engineering settings.

## Acknowledgments

We sincerely thank Georg Muntingh and Oliver Barrowclough for their feedback on the paper.

The ELLIS Unit Linz, the LIT AI Lab, and the Institute for Machine Learning are supported by the Federal State of Upper Austria.
We thank the projects Medical Cognitive Computing Center (MC3), INCONTROL-RL (FFG-881064), PRIMAL (FFG-873979), S3AI (FFG-872172), EPILEPSIA (FFG-892171), AIRI FG 9-N (FWF-36284, FWF-36235), AI4GreenHeatingGrids (FFG- 899943), INTEGRATE (FFG-892418), ELISE (H2020-ICT-2019-3 ID: 951847), Stars4Waters (HORIZON-CL6-2021-CLIMATE-01-01).
We thank the European High Performance Computing initiative for providing computational resources (EHPC-DEV-2023D08-019, 2024D06-055, 2024D08-061).
We thank Audi.JKU Deep Learning Center, TGW LOGISTICS GROUP GMBH, Silicon Austria Labs (SAL), FILL Gesellschaft mbH, Anyline GmbH, Google, ZF Friedrichshafen AG, Robert Bosch GmbH, UCB Biopharma SRL, Merck Healthcare KGaA, Verbund AG, Software Competence Center Hagenberg GmbH, Borealis AG, TÜV Austria, Frauscher Sensonic, TRUMPF, and the NVIDIA Corporation.

Arturs Berzins was supported by the European Union’s Horizon 2020 Research and Innovation Programme under Grant Agreement number 860843.

## Appendix A Implementation and experimental details

We report additional details on the experiments and their implementation.
We run all experiments on a single GPU (one of NVIDIA RTX2080Ti, RTX3090, A40, or P40).
For single-shape training, the maximum GPU memory requirements are ca. 9GB for the jet engine bracket and less than a GB for the rest.
For multi-shape training the maximum GPU memory requirements are ca. 45GB for the jet engine bracket (9 shapes) and ca. 7GB for the obstacle problem (16 shapes).

### A.1 Reaction-diffusion

See Appendix B.

### A.2 Plateau’s problem

The model is an MLP with $[3,256,256,256,1]$ neurons per layer and the $\operatorname{tanh}$ activation.
We train with Adam (default parameters) for 10000 epochs with a learning rate of $10^{-3}$ taking around three minutes.
The three losses (interface, mean curvature, and eikonal) are weighted equally but mean curvature loss is introduced only after 1000 epochs.
To facilitate a higher level of detail, the corner points of the prescribed interface are weighted higher.

### A.3 Parabolic mirror

The model is an MLP with $[2,40,40,1]$ neurons per layer and the $\operatorname{tanh}$ activation.
We train with Adam (default parameters) for 3000 epochs with a learning rate of $10^{-3}$ taking around ten seconds.

### A.4 Obstacle

The obstacle experiment serves as a proof of concept for including several losses, in particular the connectedness loss.

#### Problem definition.

Consider the domain $\mathcal{X}=[-1,1]\times[-0.5,0.5]$ and the design region that is a smaller rectangular domain with a circular obstacle in the middle: $\mathcal{E}=([-0.9,0.9]\times[-0.4,0.4])\setminus\{x_{1}^{2}+x_{2}^{2}\leq 0.1
^{2}\}$.
There is an interface consisting of two vertical line segments $\mathcal{I}=\{(\pm 0.9,x_{2})|-0.4\leqslant x_{2}\leqslant 0.4\}$ with the prescribed outward facing normals $\bar{n}(\pm 0.9,-0.4\leqslant x_{2}\leqslant 0.4)=(\pm 1,0)$.

#### Softplus-MLP.

The neural network model $f$ should be at least twice differentiable with respect to the inputs $x$, as necessitated by the computation of surface normals and curvatures.
Since the second derivatives of an ReLU MLP is zero everywhere, we use the softplus activation function as a simple baseline.
In addition, we add residual connections [] to mitigate the vanishing gradient problem and facilitate learning.
We denote this architecture with "softplus-MLP".
We train a softplus-MLP with Adam (default settings) and the hyperparameters in Table 2.

#### Conditioning the model.

For training the conditional models, we approximate the one-dimensional latent set $Z=[-1,1]$ with $N=16$ fixed equally spaced samples.
This enables the reuse of some calculations across epochs and results in a well-structured latent space, illustrated through latent space interpolation in Figure 5.

**Table 2: Hyperparameters for the generative 2D obstacle and 3D jet engine bracket experiments. The input is a 2D or 3D point concatenated with a 1D latent vector. For both experiments, the initial learning rate is halved every 1000 (Obstacle) or 5000 (jet engine bracket) iterations. The hidden layers do not include an input layer of input-dimension $\dim(x)+\dim(z)$, whereas $x$ is a coordinate and $z$ is a modulation vector, and an output layer of output-dimension 1. Interestingly, the WIRE network overall had fewer parameters, while fitting a more complex shape.**
| Hyperparameter | Obstacle (2D) | JEB (3D) |
| --- | --- | --- |
| Architecture | Residual-MLP | WIRE |
| Hidden layers | $[512,512,512,512]$ | $[128,128,128]$ |
| Activation | softplus | Gabor wavelet |
| $\omega_{0}$ for WIRE | n/a | 18.0 |
| $s_{0}$ for WIRE | n/a | 6.0 |
| Learning rate | 0.001 | 0.001 |
| Learning rate schedule | $0.5^{t/1000}$ | $0.5^{t/5000}$ |
| Iterations | 3000 | 10000 |

#### Computational cost.

The total training wall-clock time is around 10 minutes for a single shape and approximately 60 minutes for 16 shapes. These numbers are without applying a smoothness loss.

### A.5 Jet engine bracket

The jet engine bracket (JEB) is our most complex experiment.
We tested different architectures (c.f. Figure 7) and found that WIRE [] produced the best results, while being easier to train with the augmented Lagrangian method than softplus-MLP or SIREN [].
We train with Adam (default settings) and the hyperparameters summarized in Table 2.
To decrease the training time, we use multi-processing to asynchronously create diagnostic plots or computing the PH loss for multiple shapes.

#### WIRE.

For the jet engine bracket settings, early experiments indicated that the softplus-MLP cannot satisfy the given constraints.
We therefore employ a WIRE network [], which is biased towards higher frequencies of the input signal.
As mentioned by the authors, the spectral properties of a WIRE model are relatively robust.
Several values for $\omega_{0}$ and $s_{0}$, which control the frequency and scale of the gaussian of the first layer at initialization, were tested.
As there was no big difference in the results, we fixed them to $\omega_{0}=18$ and $s_{0}=6$
For more detailed results, we refer to Section C.

Figure: Figure 7: Comparison of architectures trained for 10k epochs to produce a single shape. From left to right: softplus-MLP, SIREN, WIRE. The softplus-MLP is unable to fit the interfaces due to the low-frequency bias. SIREN converges much slower than WIRE, especially at the interfaces, and does not produce a smooth shape.
Refer to caption: x4.png

#### Conditioning the model.

In the generative GINN setting, we condition WIRE using input concatenation which can be interpreted as using different biases at the first layer.
As we refer in the main text, we leave more sophisticated conditioning techniques for future work.
We use $N=9$ different latent codes spaced in the interval $Z=[0,0.1]$ and are resampled every iteration. The results are shown in Figure 8.

Figure: Figure 8: GINNs produce diverse shapes with a structured latent space. The shapes morph continiously into one another when traversing the 2 dimensional latent space. These shapes are produced by the same model as Figure 6. A trained GINN allows the user to sample densely in the latent space with shapes all meeting the constraints: Interfaces are modeled correctly, shapes are not disconnected or leave the design space.
Refer to caption: x5.png

#### Spatial resolution.

The curse of dimensionality implies that with higher dimensions, exponentially (in the number of dimensions) more points are needed to cover the space equidistantly.
Therefore, in 3D, substantially more points (and consequently memory and compute) are needed than in 2D.
In our experiments, we observe that a low spatial resolution around the interfaces prevents the model from learning high-frequency details, likely due to a stochastic gradient.
Increased spatial resolution results in a better learning signal and the model picks up the details easier.
To facilitate learning we additionally increase the resolution around the interfaces.

## Appendix B Generative PINNs

Having developed a generative GINN that is capable of producing diverse solutions to an under-determined problem, we ask if this idea generalizes to other areas.
In physics, problems are often well-defined and have a unique solution.
However, cases exist where the initial conditions are irrelevant and a non-particular PDE solution is sufficient, such as in chaotic systems or animations.
We conclude the experimental section by demonstrating an analogous concept of *generative PINNs* on a *reaction-diffusion* system.
Such systems were introduced by Turing [] to explain how patterns in nature, such as stripes and spots, can form as a result of a simple physical process of reaction and diffusion of two substances.
A celebrated model of such a system is the Gray-Scott model [], which produces a variety of patterns by changing just two parameters – the feed-rate $\alpha$ and the kill-rate $\beta$ – in the following PDE:

$$ $\displaystyle\frac{\partial u}{\partial t}=D_{u}\Delta u-uv^{2}+\alpha(1-u)\ , \quad\frac{\partial v}{\partial t}=D_{v}\Delta v+uv^{2}-(\alpha+\beta)v\ .$ (5) $$

This PDE describes the concentration $u,v$ of two substances $U,V$ undergoing the chemical reaction $U+2V\rightarrow 3V$.
The rate of this reaction is described by $uv^{2}$, while the rate of adding $U$ and removing $V$ is controlled by the parameters $\alpha$ and $\beta$.
Crucially, both substances undergo diffusion (controlled by the coefficients $D_{u},D_{v}$) which produces an instability leading to rich patterns around the bifurcation line $\alpha=4(\alpha+\beta)^{2}$.
Computationally, these patterns are typically obtained by evolving a given initial condition $u(x,t=0)=u_{0}(x)$, $v(x,t=0)=v_{0}(x)$ on some domain with periodic boundary conditions.
A variety of numerical solvers can be applied, but previous PINN attempts fail without data [].
To demonstrate a generative PINN on a problem that admits multiple solutions, we omit the initial condition and instead consider stationary solutions, which are known to exist for some parameters $\alpha,\beta$ [].
We use the corresponding stationary PDE ($\partial u/\partial t=\partial v/\partial t=0$) to formulate the residual losses:

$$ $\displaystyle L_{u}=\int_{\mathcal{D}}(D_{u}\Delta u-uv^{2}+\alpha(1-u))^{2} \operatorname{d}\!{x}\ ,\quad L_{v}=\int_{\mathcal{D}}(D_{v}\Delta v+uv^{2}-( \alpha+\beta)v)^{2}\operatorname{d}\!{x}\ .$ (6) $$

To avoid trivial (i.e. uniform) solutions, we encourage non-zero gradient with a loss term $-\max(1,\int_{\mathcal{D}}(\nabla u(x))^{2}+(\nabla v(x))^{2}\operatorname{d}
\!{x})$.
We find that architecture and initialization are critical (see Appendix B.1).
Using the diffusion coefficients $D_{v}=1.2\times 10^{-5}$, $D_{u}=2D_{v}$ and the feed and kill-rates $\alpha=0.028,\beta=0.057$, the generative PINN produces diverse and smoothly changing pattern of worms, illustrated in Figure 4.
To the best of our knowledge, this is the first PINN that produces 2D Turing patterns in a data-free setting.

### B.1 Experimental details

We use two identical SIREN networks for each of the fields $u$ and $v$.
They have two hidden layers of widths 256 and 128.
We enforce periodic boundary conditions on the unit domain $\mathcal{X}=[0,1]^{2}$ through the encoding $x_{i}\mapsto(\sin{2\pi x_{i}},\cos{2\pi x_{i}})$ for $i=1,2$.
With this encoding, we use $\omega_{0}=3.0$ to initialize SIREN.
We also find that the same shaped Fourier-feature network [] with an appropriate initialization of $\sigma=3$ works equally well.
We compute the gradients and the Laplacian using finite differences on a $64\times 64$ grid, which is randomly translated in each epoch.
Automatic differentiation produces the same results for an appropriate initialization scheme, but finite differences are an order of magnitude faster.
The trained fields $u,v$ can be sampled at an arbitrarily high resolution without displaying any artifacts.
The generative PINNs are trained with Adam for 20000 epochs with a $10^{-3}$ learning rate taking a few minutes.

## Appendix C Evaluation

### C.1 Metrics

We introduce several metrics for each individual constraint independently.
Let $vol(P)=\int_{P}dP$ be the generalized volume of $P$.
We will use the chamfer divergence [] to compute the divergence measure between two shapes $P$ and $Q$.
For better interpretability, we take the square root of the common definition of chamfer divergence

$$ $\displaystyle CD_{1}(P,Q)=\sqrt{\frac{1}{\left|Q\right|}\sum_{x\in Q}\min_{y \in P}||x-y||^{2}_{2}}$ (7) $$

and, similary, for the two-sided chamfer divergence

$$ $\displaystyle CD_{2}(P,Q)=\sqrt{\frac{1}{\left|Q\right|}\sum_{x\in Q}\min_{y \in P}||x-y||^{2}_{2}+\frac{1}{\left|P\right|}\sum_{x\in P}\min_{y\in Q}||x-y| |^{2}_{2}}\ .$ (8) $$

Reusing the notation from the paper, let $\mathcal{E}$ be the design region, $\delta\mathcal{E}$ the boundary of the design region, $\mathcal{I}$ the interface consisting of $n_{\mathcal{I}}$ connected components, $\mathcal{X}$ the domain, $\Omega$ the shape and $\delta\Omega$ its boundary.

#### Shape in design region.

We introduce two metrics to quantify how well a shape fits the design region.
Intuitively for 3D, the first metric quantifies how much volume is outside the design region $\mathcal{E}$ compared to the overall volume that is available.
The second metric compares how much surface area intersects the boundary of the design region.

- •
$\frac{\operatorname{vol}(\Omega\setminus\mathcal{E})}{\operatorname{vol}(
\mathcal{X}\setminus\mathcal{E})}$: The $d$-volume (i.e. volume for $d=3$ or area for $d=2$) outside the design region, divided by the total $d$-volume outside the design region.
- •
$\frac{\operatorname{vol}(\Omega\cap\delta\mathcal{E})}{\operatorname{vol}(
\delta\mathcal{E})}$: The $(d-1)$-volume (i.e. the surface area for $d=3$ or length of contours for $d=2$) of the shape intersected with the design region boundary, normalized by the total $(d-1)$-volume of the design region.

#### Fit to the interface.

To measure the goodness of fit to the interface, we use the *one-sided* chamfer distance of the boundary of the shape to the interface, as we do not care if some parts of the shape boundary are far away from the interface, as long as there are some parts of the shape which *are* close to the interface.
A good fit is indicated by a 0 0 value.

- •
$CD_{1}(\Omega,\mathcal{I})$: The average minimal distance from sampled points of the interface to the shape boundary.

#### Connectedness.

For the connectedness, we care whether the shape and whether the interfaces are connected.
Since it is possible that the shape connects though paths that are outside the design region, we also introduce a metric that excludes such parts.
The function $DC(\Omega)$ denotes all connected components of a shape $\Omega$ except the largest.
We define the metrics as follows:

- •
$b_{0}(\Omega)$: The zeroth Betti number represents the number of connected components of the shape. The target in our work is always 1.
- •
$b_{0}(\Omega\cap\mathcal{E})$: The zeroth Betti number of the shape restricted to the design region.
- •
$\frac{\operatorname{vol}(DC(\Omega))}{\operatorname{vol}(\mathcal{E})}$: To measure the $d$-volume (i.e. volume for $d=3$ and area for $d=2$) of disconnected components, we compute their volume and normalize it by the volume of the design region.
- •
$\frac{\operatorname{vol}(DC(\Omega\cap\mathcal{E}))}{\operatorname{vol}(
\mathcal{E})}$: Measures the $d$-volume of disconnected components *inside the design region*.
- •
$\frac{CI(\Omega,\mathcal{I})}{n_{\mathcal{I}}}$ computes the share of connected interfaces. If an interface is an $\epsilon$-distance from a connected component of a shape, we consider it connected to the shape. This metric then represents the maximum number of connected interfaces of any connected component, divided by the total number of interface components. By default, we set $\epsilon=0.01$ when then domain bounds are comparable to the unit cube.

#### Diversity.

We define the diversity $\delta_{\text{mean}}$ on a finite set of shapes $S=\{\Omega_{i},i\in[N]\}$ as follows:

$$ $\displaystyle\delta_{\text{mean}}(S)=\left[\frac{1}{N}\sum_{i\in[N]}\left( \frac{1}{N-1}\sum_{j\neq i\in[N]}CD_{2}(\Omega_{i},\Omega_{j})\right)^{\frac{1 }{2}}\right]^{2}\ .$ (9) $$

#### Smoothness.

There are many choices of smoothness measures in multiple dimensions.
In this paper, we use a Monte Carlo estimate of the *surface strain* [] (also mentioned in Section 4).
To make the metric more robust to large outliers (e.g. tiny disconnected components have very large curvature and surface strain), we clip the surface strain of a sampled point $x_{i},i\in[N]$ with a value $\kappa_{\text{max}}=1000000$.

$$ $\displaystyle E_{\text{strain}}(\Omega)=\frac{1}{N}\sum_{i\in[N]}\text{min} \left[\text{div}^{2}\left(\nabla\frac{f(x_{i})}{|f(x)|}\right),\kappa_{\text{ max}}\right]$ (10) $$

### C.2 Jet engine bracket

#### Eikonal loss facilitates learning.

Column 2 in Table 3 ablates the eikonal loss. Using the eikonal loss has a positive influence on the connectedness (see $b_{0}(\omega)$) and provides additional smoothness (see $E_{\text{strain}}(\Omega)$).

#### Connectedness loss is crucial for connected shapes.

Column 3 in Table 3 ablates the connectedness loss.
Quantitatively, the zeroth Betti number $b_{0}(\Omega)$ (similary, $b_{0}(\Omega\cap\mathcal{E})$) is very high, i.e., there are many disconnected components.
Furthermore, the share of connected interfaces $\frac{CI(\Omega,\mathcal{I})}{n_{\mathcal{I}}}$ is only $0.83$.
Since for this problem there are 6 interfaces to connect, a value of $0.83$ implies that one of the interfaces is disconnected from the others.

**Table 3: Metrics for GINNS trained to produce a single shape of the jet engine bracket dataset.**
| Ablation | eikonal | connectedness | smoothness | log-smoothness | base |
| --- | --- | --- | --- | --- | --- |
| smoothness | $E_{\text{strain}}$ | $E_{\text{strain}}$ | $E_{\text{strain}}$ | $E_{\text{log}}$ | $E_{\text{strain}}$ |
| $\lambda_{\text{eikonal}}$ | 0 | 1 | 1 | 1 | 1 |
| $\lambda_{\text{connectedness}}$ | 1 | 0 | 1 | 1 | 1 |
| $\lambda_{\text{smoothness}}$ | 1 | 1 | 0 | 1 | 1 |
| $\downarrow b_{0}(\Omega)$ | 9 | 2 | 1 | 1 | 1 |
| $\downarrow b_{0}(\Omega\cap E)$ | 7 | 2 | 1 | 1 | 1 |
| $\downarrow\frac{\operatorname{vol}(DC(\Omega))}{\operatorname{vol}(E)}$ | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
| $\downarrow\frac{\operatorname{vol}(\Omega\setminus E)}{\operatorname{vol}(X<br>\setminus E)}$ | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
| $\uparrow\frac{CI(\Omega,I)}{n_{\mathcal{I}}}$ | 0.67 | 0.83 | 1.00 | 1.00 | 1.00 |
| $\downarrow CD_{1}(\Omega,I)$ | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
| $\downarrow\frac{\operatorname{vol}(\Omega\cap\delta E)}{\operatorname{vol}(<br>\delta E)}$ | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
| $\downarrow\frac{\operatorname{vol}(DC(\Omega\cap E))}{\operatorname{vol}(E)}$ | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
| $\downarrow E_{\text{strain}}(\Omega)$ | 28,115 | 22,708 | 8,497 | 47,842 | 7,422 |

#### Explicit smoothness also quantitatively improves smoothness.

Comparing Table 3, col. 4 to col. 6 shows that not using the smoothness loss leads to less smooth shapes. Qualitatively this is also depicted in Figure 3.

#### Explicit diversity loss improves diversity.

Comparing Table 4, col. 2 to col. 4 shows that not using the diversity loss halves the diversity $\delta_{\text{mean}}(S)$.
Interestingly, also not using the eikonal loss reduces the diversity.
We hypothesize, that the reason is that for training we compute a diversity loss on neural fields, sampled at points close to the individual boundaries. In contrast, the diversity metric (defined in section C.1) is computed using shapes *at the zero level set* of those fields with the chamfer-divergence as a pseudo-distance measure.
Using the eikonal loss, leads to enforcing a more regular neural field, which in turn makes the diversity on neural fields more suitable.

#### Sampling generalizes better than fixed z.

Comparing Table 4, col. 3 to col. 4, the metrics for connectedness (e.g. $b_{0}(\Omega)$) and the number of connected interfaces improve when uniformly sampling the z from the domain during training.

**Table 4: Metrics for GINNS trained to produce multiple shapes of the jet engine bracket dataset. These are aggregated metrics averaged across all shapes.**
| Ablation | diversity | fixed z | base |
| --- | --- | --- | --- |
| Training shapes | 9 | 9 | 9 |
| dim(z) | 2 | 2 | 2 |
| z sample method | uniform | fix | uniform |
| smoothness | $E_{\text{strain}}$ | $E_{\text{strain}}$ | $E_{\text{strain}}$ |
| $\lambda_{\text{eikonal}}$ | 1 | 1 | 1 |
| $\lambda_{\text{connectedness}}$ | 1 | 1 | 1 |
| $\lambda_{\text{smoothness}}$ | 1 | 1 | 1 |
| $\lambda_{\text{div}}$ | 0 | 1 | 1 |
| $\downarrow b_{0}(\Omega)$ | 1.00 | 3.00 | 1.11 |
| $\downarrow b_{0}(\Omega\cap E)$ | 1.00 | 3.00 | 1.11 |
| $\downarrow\frac{\operatorname{vol}(DC(\Omega))}{\operatorname{vol}(E)}$ | 0.00 | 0.00 | 0.00 |
| $\downarrow\frac{\operatorname{vol}(\Omega\setminus E)}{\operatorname{vol}(X<br>\setminus E)}$ | 0.00 | 0.00 | 0.00 |
| $\uparrow\frac{CI(\Omega,I)}{n_{\mathcal{I}}}$ | 1.00 | 0.69 | 0.96 |
| $\downarrow CD_{1}(\Omega,I)$ | 0.00 | 0.01 | 0.00 |
| $\downarrow\frac{\operatorname{vol}(\Omega\cap\delta E)}{\operatorname{vol}(<br>\delta E)}$ | 0.00 | 0.01 | 0.00 |
| $\downarrow\frac{\operatorname{vol}(DC(\Omega\cap E))}{\operatorname{vol}(E)}$ | 0.00 | 0.01 | 0.00 |
| $\downarrow E_{\text{strain}}(\Omega)$ | 23,059 | 27,563 | 31,592 |
| $\uparrow\delta_{\text{mean}}$ | 0.01 | 0.23 | 0.21 |

## Appendix D Optimization

In general, an equality-constrained optimization problem can be written as

$$ $\displaystyle\min_{\theta}O(\theta)$ such that $\displaystyle C_{i}(\theta)=0\quad\forall i\in 0,\dots,m$ (11) $$

where $O,C_{1}\dots C_{m}$ are smooth scalar functions $\mathbb{R}^{N}\rightarrow\mathbb{R}$. $O$ is the objective function and constraint functions $C_{i}$ represent the collection of equality constraints. A naive approach to solve this optimization problem is to simply relax the constraints into the objective function and solve the unconstrained optimization problem

$$ $\displaystyle\min_{\theta}O(\theta)+\mu_{0_{k}}\sum_{i=0}^{m}C_{i}(\theta)$ (12) $$

for a sequence $\{\mu_{0_{k}}\}$ with $\mu_{0_{k}}\leqslant\mu_{0_{k+1}}$ for all $k$ and $\mu_{0_{k}}\rightarrow\infty$. This so-called penalty method can however suffer from numerical instabilities for large $\mu_{0_{k}}$, hence the sequence is generally capped at a maximum value $\mu_{max}$. A further problem, which has recently been studied in regard to PINNs, is that the different objectives in 12 behave on different scales leading to instabilities in training as the gradients of the larger objective functions dominate training.

This issue is addressed by weighting each constraint term individually

$$ $\min_{\theta}O(\theta)+\sum_{i=0}^{m}\mu_{i_{k}}C_{i}^{2}(\theta).$ (13) $$

Besides manual tuning of the weights $\mu_{i_{k}}$, several schemes to dynamically balance the different terms throughout training have been proposed, such as loss-balancing via the sub-gradients ([]), via the eigenvalues of the Neural Tangent Kernel ([]) or using a Soft Attention mechanism ([]).

A different method for solving 11 is the augmented Lagrangian method (ALM) defined as:

$$ $\min_{\theta}\max_{\lambda,\mu}\mathcal{L}(\theta,\lambda,\mu):=O(\theta)+\sum _{i=0}^{m}\lambda_{i}C_{i}(\theta)+\frac{1}{2}\mu_{0}\sum_{i=0}^{m}C_{i}^{2}(\theta)$ (14) $$

Using the min-max inequality or weak duality

$$ $\max_{\lambda,\mu}\min_{\theta}\mathcal{L}(\theta,\lambda,\mu)\leqslant\min_{ \theta}\max_{\lambda,\mu}\mathcal{L}(\theta,\lambda,\mu)$ (15) $$

we can solve the max-min problem instead. In each epoch $k$, a minimization over network parameters $\theta_{k}$ is performed using gradient descent, yielding new parameters $\theta_{k+1}$. Then, the Lagrange multipliers are updated as follows:

$$ $\displaystyle\lambda_{i_{k+1}}=\lambda_{i_{k}}+\mu_{0_{k}}C_{i}(\theta_{k+1})$ $\displaystyle\forall i\in 0,\dots,m.$ (16) $$

Note that this so-called dual update of the Lagrange multipliers is simply a gradient ascent step with learning rate $\mu_{0_{k}}$ for each multiplier $\lambda_{i_{k}}$. Typically, there is also an increase of $\mu_{0_{k}}$ up to maximum value $\mu_{max}$ as in the penalty method. Constrained optimization with neural networks using the ALM has been shown to perform well in previous works, such as in [], [], [], [] and [].

In this classical ALM formulation, there is only a single penalty parameter $\mu_{0}$, which is monotonically increased during optimization. As outlined above, this is often insufficient to handle diverse constraints with different scales. Thus, we opt for the adaptive ALM proposed in [] using adaptive penalty parameters for each constraint, solving 11 as the unconstrained optimization problem:

$$ $\max_{\lambda}\min_{\theta}\mathcal{L}(\theta,\lambda,\mu):=o(\theta)+\sum_{i= 0}^{m}\lambda_{i}C_{i}(\theta)+\frac{1}{2}\sum_{i=0}^{m}\mu_{i}C_{i}^{2}(\theta)$ (17) $$

In each epoch $k$ again a minimization step over the parameters $\theta_{k}$ via gradient descent is performed. Then the penalty parameters $\mu_{i_{k}}$, which are simultaneously the learning rate of the Lagrange multipliers $\lambda_{i_{k}}$, are updated using RMSprop followed by the gradient ascent step for $\lambda_{i_{k}}$

$$ $\displaystyle\bar{\nu}_{i_{k+1}}$ $\displaystyle\leftarrow\alpha\bar{\nu}_{i_{k}}+(1-\alpha)C_{i}^{2}(\theta_{k+1})$ (18) $\displaystyle\mu_{i_{k+1}}$ $\displaystyle\leftarrow\frac{\gamma}{\sqrt{\bar{\nu}_{i_{k}}}+\epsilon}$ (19) $\displaystyle\lambda_{i_{k+1}}$ $\displaystyle\leftarrow\lambda_{i_{k}}+\mu_{i_{k}}C_{i}(\theta_{k+1})$ (20) $$

where $\bar{\nu}_{i}$ is the weighted moving average of the squared gradient w.r.t. $\lambda_{i}$, $\alpha$ is the discounting factor for old gradients, $\gamma$ is a global learning rate and $\epsilon$ is a constant added for the numerical stability of the division. This adaptive approach enables us to handle the diverse set of constraints in GINNs without the need for manual hyperparameter tuning.

Algorithm 1 shows the full algorithm used to train for $\mathcal{T}$ epochs and specifies the hyperparameters we used. The only difference to [] is we set $\alpha=0.90$, which is the default value of RMSprop in PyTorch, instead of $\alpha=0.99$.

Figure: Algorithm 1 Adaptive augmented Lagrangian method

### D.1 Loss plots

In Figures 9 and 10 we show the loss plots for training single and multiple shapes respectively.
As expected the unweighted losses (middle rows in the Figures) decrease, while the Lagrange terms (bottom rows) increase over training.

Figure: Figure 9: Loss plots for training a *single* shape. The lines with higher alpha are exponential-moved averages of the lower-alpha values by the factor 0.99. (a) The top plot shows the losses as used for backpropagation. (b) The middle plot shows the unweighted losses for individual constraints. (c) The bottom plots show the $\lambda$ values for the individual constraints.
Refer to caption: extracted/5925591/figures/loss_plots/single_shape-3xq707nt/losses.png

Figure: Figure 10: Loss plots for training *multiple* shapes. The lines with lower transparency are exponential-moved averages with factor 0.99 of the higher-transparency values. (a) The top plot shows the losses as used for backpropagation. (b) The middle plot shows the unweighted losses for individual constraints. (c) The bottom plots show the $\lambda$ values for the individual constraints.
Refer to caption: extracted/5925591/figures/loss_plots/multi_shape-hcw86uql/losses.png

## Appendix E Connectedness

We provide additional details on our approach to the connectedness loss.
We break this down in three parts: First, we define the signed distance function of a shape $\Omega$ which the neural field we train approximates. Then, we give a short rundown on computing the persistent homology (PH), in particular the PH of a neural field in a not rectangular region. Lastly, we explain how to obtain a differentiable loss on the field from the outputs of the, in general non-differentiable, PH computation.

Signed distance function (SDF) $f:X\rightarrow\mathbb{R}$ of a shape $\Omega$ gives the (signed) distance from the query point $x$ to the closest boundary point:

$$ $f(x)=\begin{cases}d(x,\partial\Omega)&\quad\text{if }x\in\Omega^{c}\text{ (if }x\text{ is outside the shape)},\\ -d(x,\partial\Omega)&\quad\text{if }x\in\Omega\text{ (if }x\text{ is inside the shape)}.\end{cases}$ (21) $$

A point $x\in X$ belongs to the medial axis if its closest boundary point is not unique. The gradient of an SDF obeys the eikonal equation $\|\nabla f(x)\|=1$ everywhere except on the medial axis where the gradient is not defined. In INS, the SDF is approximated by a NN with parameters $\theta$: $f_{\theta}\approx f$.

Connectedness refers to an object $\Omega$ consisting of a single connected component.
It is a ubiquitous feature enabling the propagation of mechanical forces, signals, energy, and other resources.
Consequentially, connectedness is an important constraint for enabling GINNs.
In the context of machine learning, connectedness constraints have been multiply applied in segmentation [, , ], surface reconstruction [], and 3D shape generation with voxels [], point-clouds [] and INSs [].

### E.1 Persistent Homology

Persistent Homology is one of the primary tools which has emerged from topological data analysis (TDA) to extract topological features from data. Data modalities such as point clouds, time series, graphs and $n$-dimensional images can all be transformed into weighted cell complexes from which the homology can be computed. The homology provides global information about the underlying data and is generally robust.

Homology is an invariant originating from algebraic topology. A topological space $X$ is encoded as cell complexes $C_{n}(X)$ consisting of n-dimensional balls $B^{n}$ ($n=0,1,2,...$) and boundary maps $\partial_{n}$ from dimension $n$ to $n-1$ which satisfy $\partial_{n}\circ\partial_{n+1}=0$ and $\partial_{0}=0$. The homology $H_{n}(X)$ is then defined as the quotient space

$$ $H_{n}(X)=\frac{\text{ker}(\partial_{n})}{\text{im}(\partial_{n+1})}$ (22) $$

The dimension of $H_{n}(X)$ counts the number of $n$-dimensional features and defines the Betti number $b_{n}$: for $n=0$ the number of connected components, for $n=1$ the number of holes, for $n=2$ the number of voids.

Filtrations on the space $X$ are defined using a filter function $f:X\rightarrow\mathbb{R}$. Using a sequence of increasing parameters $\alpha_{n}$ with $\alpha_{k}<\alpha_{n}$ for $k<n$ we can define a sequence of nested subspaces of $X$ as sub-level sets $X_{n}=f^{-1}([-\infty,\alpha_{n}])$. We then have

$$ $\varnothing\subseteq X_{1}\subseteq\dots\subseteq X_{N}=X$ (23) $$

The homology of each of these nested complexes $C_{n}(X_{i})$ can be computed.

Persistent Homology encodes how the homology of an increasing sequence of complexes changes under a given filtration. Topological features appear and and vanish as the filter function sweeps over $X$. The birth time $b$ of a feature defined as the value $\alpha_{n}$ at which the homology of $C_{n}(X_{n})$ changes to include this feature. The death time $d$ of a feature is analogously defined as the value $\alpha_{n}$ at which it is removed from $C_{n}(X_{n})$. The persistence of a feature is defined as the length of its lifetime $l=d-b$.

For each Betti number $b_{n}$ (for each homology class $H_{n}$) the information about the persistent homology of a given filtration is encoded in a persistence diagram containing the points $(b,d)$ of the birth and death pairs of all $n$-dimensional topological features (changes in the dimension of $H_{n}$). The persistence diagrams contain the entire topological information about underlying the space or shape for a sufficiently fine filtration.

To compute the persistent homology of a neural field, we evaluate the network on a cubical complex on the domain of the field, i.e. a grid in $\mathbb{R}^{N}$. The output is simply a gray scale image (we are only dealing with scalar fields in this work) and the PH can computed with existing algorithms. The current SotA algorithm for PH computation on cubical complexes is CRipser [].

Given a grayscale image and a filtration value $a$, the sublevel set at $a$ is the binary image resulting from thresholding the image for values smaller or equal to $a$. For every such binary image, which defines a weighted cubical complex with coefficients in $\mathbf{Z}/2\mathbf{Z}$, the homology can be computed. The persistence homology is then obtained by sweeping the thresholding value $a$ through $\mathbb{R}$.

In general, we are interested in computing the PH within a given envelope, which is not necessarily a rectangular region. We achieve this by sampling the field in a rectangular domain containing the envelope and setting the value of points not in the envelope to $\infty$. Applying the PH computation to this altered image then correctly returns the evolution of persistence features within the envelope. The only drawback of this method is the additional computational cost of having to include the grid points outside the envelope in the PH computation, which is why the bounding domain should be chosen tightly around the envelope.

The PH computation itself does not have to be differentiable (and the CRipser library we use is not) because the cells, i.e. the grid point of the image, at which a given persistence feature is born or killed are stored. Hence we can simply use the network output at this grid coordinate to compute the loss and there are no issues concerning differentiability or having to re-implement the PH computation into PyTorch.

### E.2 Differentiable topology loss

To compute a differentiable loss, we use the outputs of the PH computation: For each homology class $H_{n}$ we obtain the points $\prescript{n}{}{p}_{i}$ in the persistence diagram with the associated birth and death times $\prescript{n}{}{b}_{i}$, $\prescript{n}{}{d}_{i}$ and the coordinates of these births $x_{\prescript{n}{}{b}_{i}}$, $y_{\prescript{n}{}{b}_{i}}$, $z_{\prescript{n}{}{b}_{i}}$ and deaths $x_{\prescript{n}{}{d}_{i}}$, $y_{\prescript{n}{}{d}_{i}}$, $z_{\prescript{n}{}{d}_{i}}$.
Remark: The representatives of homology class are not uniquely determined. The CRipser library internally chooses a representative and then outputs its coordinates. In practice this caused no issues.

For a selected iso-level $a_{0}$ we select all $\prescript{n}{}{p}_{i}$ for which $\prescript{n}{}{b}_{i}<a_{0}<\prescript{n}{}{d}_{i}$ and sort them by lifetime $\prescript{n}{}{l}_{i}=\prescript{n}{}{d}_{i}-\prescript{n}{}{b}_{i}$. Now let the index $i$ run from $1\dots M$ sorting the selected $\prescript{n}{}{p}_{i}$. To train the network $f_{\theta}$ to produce a single connected component at iso-level $a_{0}$ the loss is given by the residuals of the deaths $\prescript{n}{}{d}_{i}$ to $a_{0}$ for all $i=2\dots M$, effectively pushing down all but the most persistent component.

$$ $\mathcal{L}_{cc}=\sum_{i=2}^{M}\left(a_{0}-f_{\theta}(x_{\prescript{0}{}{d}_{i }},y_{\prescript{0}{}{d}_{i}},z_{\prescript{0}{}{d}_{i}})\right)^{2}$ (24) $$

It is immediately clear that this term is differentiable with respect to $\theta$.

More generally, to obtain a shape with a Betti number $b_{n}=m$ at iso-level $a_{n}$, the summation above runs from $i=m+1\dots M$. The full topology loss for a $N$-dimensional shape is then given as

$$ $\mathcal{L}_{topo}=\sum_{n=0}^{N-1}\sum_{i=m+1}^{M}\left(a_{n}-f_{\theta}(x_{ \prescript{n}{}{d}_{i}},y_{\prescript{n}{}{d}_{i}},z_{\prescript{n}{}{d}_{i}}) \right)^{2}$ (25) $$

## Appendix F Diversity

Figure: Figure 11: A visual comparison of different diversity losses in a simple 2D example ($\mathcal{F}=\mathbb{R}^{2}$ and the feasible set $\mathcal{K}$ is the partial annulus). Each point $f\in\mathcal{F}$ represents a candidate solution. The points are optimized to maximize the diversity within the feasible set. The top row shows the *minimal aggregation* $\delta_{\text{min}}$ as defined in Equation 26. The bottom row shows the *total aggregation* $\delta_{\text{sum}}$ as defined in Equation 27. Each column uses a different exponent $p\in\{0.5,1,2\}$. For $0\leqslant p\leqslant 1$ the minimal aggregation diversity $\delta_{\text{min}}$ is concave meaning it favors increasing smaller distances over larger distances. This leads to a uniform coverage of the feasible set. In contrast, the $\delta_{\text{min}}$ is convex for $p\geq 1$ as indicated by the formed clusters for $p=2$. Meanwhile, $\delta_{\text{sum}}$ pushes the points to the boundary of the feasible set for all $p$.
Refer to caption: extracted/5925591/figures/repelling/0.5closest.png

#### Concavity.

We elaborate on the aforementioned *concavity* of the diversity aggregation measure with respect to the distances.
We demonstrate this in a basic experiment in Figure 11, where we consider the feasible set $\mathcal{K}$ as part of an annulus.
For illustration purposes, the solution is a point in a 2D vector space $f\in\mathcal{X}\subset\mathbb{R}^{2}$.
Consequentially, the solution set consists of $N$ such points: $S=\{f_{i}\in\mathcal{X},i=1,\dots,N\}$.
Using the usual Euclidean distance $d_{2}(f_{i},f_{j})$, we optimize the diversity of $S$ within the feasible set $\mathcal{K}$ using minimal aggregation measure

$$ $\displaystyle\delta_{\text{min}}(S)=\left(\sum_{i}\left(\min_{j\neq i}d_{2}(f_ {i},f_{j})\right)^{p}\right)^{1/p}\ ,$ (26) $$

as well as the total aggregation measure

$$ $\displaystyle\delta_{\text{sum}}(S)=\left(\sum_{i}\left(\sum_{j}d_{2}(f_{i},f_ {j})\right)^{p}\right)^{1/p}\ .$ (27) $$

Using different exponents $p\in\{1/2,1,2\}$ illustrates how $\delta_{\text{min}}$ covers the domain uniformly for $0\leqslant p\leqslant 1$, while clusters form for $p>1$.
The total aggregation measure always pushes the samples to the extremes of the domain.

#### Distance.

We detail the derivation of our geometric distance.
We can partition $\mathcal{X}$ into four parts (one, both or neither of the shape boundaries): $\partial\Omega_{i}\setminus\partial\Omega_{j},\partial\Omega_{j}\setminus
\partial\Omega_{i},\partial\Omega_{i}\cap\partial\Omega_{j},\mathcal{X}
\setminus(\partial\Omega_{i}\cup\partial\Omega_{j})$.
Correspondingly, the integral of the $L^{p}$ distance can also be split into four terms. Using $f(x)=0\ \forall x\in\partial\Omega$ we obtain

$$ $\begin{split}d^{p}_{2}(f_{i},f_{j})&=\int_{\mathcal{X}}(f_{i}(x)-f_{j}(x))^{p} \operatorname{d}\!{x}\\ &=\int_{\partial\Omega_{i}\setminus\partial\Omega_{j}}(0-f_{j}(x))^{p} \operatorname{d}\!{x}+\int_{\partial\Omega_{j}\setminus\partial\Omega_{i}}(f_{ i}(x)-0)^{p}\operatorname{d}\!{x}\\ &+\int_{\partial\Omega_{i}\cap\partial\Omega_{j}}(0-0)^{p}\operatorname{d}\!{x }+\int_{\mathcal{X}\setminus(\partial\Omega_{i}\cup\partial\Omega_{j})}(f_{i}( x)-f_{j}(x))^{p}\operatorname{d}\!{x}\\ &=\int_{\partial\Omega_{i}\setminus\partial\Omega_{j}}f_{j}(x)^{p} \operatorname{d}\!{x}+\int_{\partial\Omega_{j}\setminus\partial\Omega_{i}}f_{i }(x)^{p}\operatorname{d}\!{x}+\int_{\mathcal{X}\setminus(\partial\Omega_{i} \cup\partial\Omega_{j})}(f_{i}(x)-f_{j}(x))^{p}\operatorname{d}\!{x}\\ &=\int_{\partial\Omega_{i}}f_{j}(x)^{p}\operatorname{d}\!{x}+\int_{\partial \Omega_{j}}f_{i}(x)^{p}\operatorname{d}\!{x}+\int_{\mathcal{X}\setminus( \partial\Omega_{i}\cup\partial\Omega_{j})}(f_{i}(x)-f_{j}(x))^{p}\operatorname {d}\!{x}\end{split}$ (28) $$

## Appendix G Geometric constraints

In Table 5, we provide a non-exhaustive list of more constraints relevant to GINNs.

**Table 5: A non-exhaustive list of geometric and topological constraints relevant to GINNs but not considered in this work.**
| Constraint | Comment |
| --- | --- |
| Volume | Non-trivial to compute and differentiate for level-set function (easier for density). |
| Area | Non-trivial to compute, but easy to differentiate. |
| Minimal feature size | Non-trivial to compute, relevant to topology optimization and additive manufacturing. |
| Symmetry | Typical constraint in engineering design, suitable for encoding. |
| Tangential | Compute from normals, typical constraint in engineering design. |
| Parallel | Compute from normals, typical constraint in engineering design. |
| Planarity | Compute from normals, typical constraint in engineering design. |
| Angles | Compute from normals, relevant to additive manufacturing. |
| Curvatures | Types of curvatures, curvature variations, and derived energies. |
| Euler characteristic | Topological constraint. |

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: - How robust is the method to the choice of hyperparameters?
- Would it be possible to demonstrate results on more than one example for engineering design?
soundness: 2
strengths: + Paper is well-written and is easy to follow.
+ Overall framework is meaningful and has a large number of potential applications (in particular in generative design and shape optimization).
+ The promise of representation that does not require significant amount of data is very valuable specifically because the amount of data in generative design is often scarce or requires expensive simulations. 
+ Diversity measure that is demonstrated to work in practice for tackling mode collapse in implicit field learning is a potentially a critical contribution.
summary: This work introduces a novel framework for data-free geometry learning. The framework relies on implicit geometry representation - which is a  modulated conditional neural field - where conditioning is on latent variables to ensure diversity. Given such a representation, authors propose to formulate a constrained optimization problem, in practice written down as a set of differentiable losses. The proposed constraints include: minimizing genus, smoothness, and diversity of generated shapes. Authors conduct a series of toy experiments to validate the model, and test it on a single engineering design problem.
weaknesses: - (minor) Most of the proposed constraints have been developed in previous work. 
- (minor) For the method to actually be useful for the real-world applications (e.g. in shape optimization in engineering fields), a mapping to an explicit representation could be a hard requirement to be compatible with existing simulation.  
- Although the representation/optimization framework that does not require data has promise, it would be interesting to see if these methods can be used in combination with available data.  
- The experimental evaluation is very limited. In particular for shape optimization (which is the only truly realistic test iiuc), there is only single example provided, which makes it hard to understand how much of the results is due to parameter tuning.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 4
questions: Although the authors have attempted to provide some formulations in Table 1, I still feel that these modules are far from sufficient to support the design of a workpiece. However, designing new constraints requires extreme caution and a significant amount of skill. Therefore, I am not particularly optimistic about this section. If the authors could propose a more universal paradigm for generating such constraints, many of my concerns would be alleviated.
soundness: 2
strengths: This paper presents a well-formulated approach for shape-generative modeling driven by geometric constraints and objectives. It starts by considering the problem from a theoretical perspective and successfully translates it into an executable framework. The research problem addressed in this paper is valuable, and the preliminary experimental results provided by the authors demonstrate the effectiveness of their proposed method. Additionally, the paper is well-written and easy to follow.
summary: This paper presents a framework for achieving controllable generation of industrial part geometry. Specifically, the authors utilize an implicit neural field to represent the surface of industrial parts. Through optimization objectives in different aspects, the implicit neural field is adjusted to closely match the given targets, such as ensuring the zero-level set of the implicit field aligns with the geometric surface and the first-order derivatives of the implicit field align with the surface normals. Additionally, the authors attempt to introduce a regularization term to promote diverse optimization results. Finally, the authors conduct experiments on a challenging example and demonstrate the effectiveness of their approach.
weaknesses: The framework solution proposed in the paper is effective from a high-level perspective, but I anticipate numerous challenges when it comes to practical implementation. My primary concern is whether we truly have the capability to account for all objective functions based on individual intuition, especially considering that these functions must be feasible, differentiable, and ideally, non-conflicting. For instance, how should we approach the generation of a nut that matches a specific type of screw, or a particular joint bearing?

Moreover, while the article emphasizes its data-free approach, it appears to me as an optimization-based strategy, with the optimization target being the implicit field represented by the neural network—a relatively conventional method. I do not find this particularly innovative.

Additionally, although Figure 6 does showcase a variety of workpieces, I doubt the compliance of these pieces with standard usage requirements; many seem to be diverse merely for the sake of diversity. 

Lastly, the experiments are conducted on only one workpiece, which, despite its complexity, does not suffice to demonstrate the universality of the method.

---

confidence: 2
contribution: 2
initial_rating: 5
presentation: 2
questions: I’m not very familiar with the specific field (engineering design) of this paper. In my understanding, the idea of using objectives and constraints as loss functions is not completely new in the field of 3D generative models. But this paper has extended this idea with many more kinds of constraints and proposed the diversity constraint specifically for the engineering design problem. My only doubt is whether there are indeed no existing works to be compared with. I'd like to increase my rating if the authors can give more explanation on this.
soundness: 2
strengths: - Although there have been a number of existing works using some similar losses to train their network, as mentioned in the related work, this paper presents the GINN framework with a very comprehensive summary and discussion on the common constraints used in the validation experiments. This would help the following works in formulating their own applications.
- Comparing to the physics-informed neural networks or the topology optimization, this paper proposes the diversity constraints for geometry problems. Comparing to other generative models such as boltzmann generators, the proposed diversity constraints help to avoid mode-collapse.
summary: This paper presents the framework of GINN, which formulates the objectives and constraints of geometry problem as the loss function to train the neural networks. More importantly, it proposes a diversity constraint, which avoids the mode-collapse of other generative models and promotes the model to generate diverse solutions for the geometry problem. In the experiment section, it validates the performance of GINN on four problems and additionally conducts an engineering design case study. It is able to find the accurate solution for the famous geometry problems, and produce diverse solutions for the engineering design problem.
weaknesses: - My main concern is about the technical novelty and the evaluation. Although this paper has presented many validation experiments, most of the results only show the performance of the GINN and some ablation settings, without comparing to other existing methods. In Section 4 it claims that there’s no established baselines, problems, and metrics for the data-free shape-generative modeling. Does it mean that there is no related work trying to solve the engineering design problem presented in Section 4.3??
- I understand that there are very much information to be presented in the paper. But it is a bit difficult to capture the key information. For example, the “topology” “smoothness” “surface sampling” are the defined metrics for each constraint? It’s better to have “constrained optimization”, “metrics”, “models” in bold font, and list all the metrics under the heading. The same problem exists in Section 4.3, there are too many headings to understand the structure of the writing.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: N / A
soundness: 2
strengths: The paper proposes an interesting idea that is worthy of further exploration. The research proposes the idea of a framework, but it does not demonstrate a working instantiation of the idea, so the research is only in its beginning stages. I think the concept is potentially very promising, but there are also predictable and significant obstacles that must be overcome. Design by optimization is a longstanding topic in many fields, but there are also many problems. Most notably, there aren't many or even any good examples of where optimization alone can give rise to interesting designs. Most of the time, this requires a good initialization that is already a design or the combination of user input (design) and optimization. For example, in architectural design you typically need an initial surface and you can design a pattern on the surface (e.g. a paneling). In furniture design, you also typically need to restrict the design space to a meaningful subset, e.g. by providing procedural rules or templates. At the moment, the method is an extension of an idea that does not have a working instantiation.
summary: The paper proposes geometry-informed neural networks. The idea is to train a generative model not from data, but using objective function and constraints. Basically, the generative model is trained by a specification similar to an optimization problem.
weaknesses: The major weakness of the paper is the lack of meaningful designs. Without interesting design examples, the paper is not meaningful. None of the designs shown in the paper are interesting and they cannot be recognized as mechanical, biological, architectural, ... objects. These are abstract designs like abstract art, and it is not meaningful to create art by optimization and then infer how this would transfer to engineering. I would suggest a three-step approach to tackling this problem:
1) The project should identify an example where a single interesting design can be created by optimization. This example should not be abstract but specific to an engineering problem and be recognizable as an intentional and meaningful design. This example can be generated by optimization alone. It doesn't matter if the design is from architecture, mechanical engineering, biology, geology, ... but it should be meaningful. If you want to go for something more discrete, I would recommend furniture or CAD designs. This may not work well with your framework, so I could imagine that free-form architecture could be a better application area, e.g. "Geodesic patterns", developable surfaces, self-supporting surfaces, or quad meshes.
2) The project should expand from this single design to generate a set of diverse designs by combining optimization with a diversity constraint.
3) The project should example from a set of designs generated by optimization to combining optimization with generative modeling.

The current submission does not have a demonstration of either 1, 2, or 3. Competing work (not cited) has at least somewhat of a demonstration of points 1 and 2 (e.g., "Fit and Diverse: Set Evolution for Inspiring 3D Shape Galleries"), but it would be desirable to have even better examples. 


It is possible to accept the paper for conceptual novelty, but I am not in favor of such a philosophy. A paper should introduce a conceptual novelty and at the same time introduce a working realization, not only the conceptual novelty. The conceptual novelty by itself should not be enough for publication. I conjecture that the reason why there aren't many other papers on this topic is because people could not find meaningful and working instantiations of this concept. There is an obvious approach: first generate a set of objects by optimization (e.g. furniture) and then train a generative model on this set. I am not aware of such a successful approach and a paper in this space should possibly demonstrate that it can beat such a baseline..

Meta-review: The paper introduces geometry-informed neural networks (GINNs) for optimizing 3D shapes given user-specified design requirements and constraints. The authors specifically incorporate the diversity constraint to get many different shapes and prevent mode collapse.  The authors show results on the realistic problem of designing a a jet-engine lifting bracket. The reviewers note this work can have  large number of potential applications. Due to scarce amount of data in generative design, being able to design shapes without having training is a desirable property. However, reviewers agree that a single experiment on real-world shapes (a jet-engine lifting bracket) was not sufficient to show generality of the approach. I suggest the paper to be rejected for ICLR.

Decision: Reject