Learning to Solve PDE-constrained Inverse Problems with Graph Networks
Abstract
Learned graph neural networks (GNNs) have recently been established as fast and accurate alternatives for principled solvers in simulating the dynamics of physical systems.
In many application domains across science and engineering, however, we are not only interested in a forward simulation but also in solving inverse problems with constraints defined by a partial differential equation (PDE).
Here we explore GNNs to solve such PDEconstrained inverse problems.
We demonstrate that GNNs combined with autodecoder-style priors are well-suited for these tasks, achieving more accurate estimates of initial conditions or physical parameters than other learned approaches when applied to the wave equation or Navier–Stokes equations.
We also demonstrate computational speedups of up to 90 × using GNNs compared to principled solvers.
1. Introduction
Understanding and modeling the dynamics of physical systems is crucial across science and engineering.
Among the most popular approaches to solving partial differential equations (PDEs) are mesh-based finite element simulations, which are widely used in electromagnetism (Pardo et al., 2007), aerodynamics (Economon et al., 2016; Ramamurti & Sandberg, 2001), weather prediction (Bauer et al., 2015), and geophysics (Schwarzbach et al., 2011).
Learning-based methods for mesh-based simulations have recently made much progress (Pfaff et al., 2021), offering faster runtimes than principled solvers, better adaptivity to the simulation domain compared to grid-based convolutional neural network (CNNs) (Th¨urey et al., 2020;
Wandel et al., 2021) and generalization across simulations.
State-of-the-art learningbased mesh simulators operate on adaptive meshes using graph networks (Pfaff et al., 2021).
While this approach to
Gordon
Wetzstein < gordon.wetzstein@stanford.edu > .
2nd AI4Science Workshop at the 39 th International Conference on
Machine Learning (ICML), 2022.
Copyright 2022 by the author(s).
Learned Prior
Learned Forward
Model
Predicted dynamics a) Pipeline b) Inverse Problem Results
Predicted dynamics
N a v i e r
S t o k e s
E q u a t
i o n s
W a v e
E q u a t
i o n
GT dynamics Observations
GNN t i m e t
i m e x x y y t i m e 𝒖 𝒙 (𝒙 𝒊 ) 𝒖 𝒚 (𝒙 𝒊 ) has been successful in simulating the dynamics of physical systems, it remains unclear how to leverage these network architectures to efficiently solve PDE-constrained inverse problems of the form in Eq.
[Equation]
where u t ∈ C N is the state of the simulation modeled at
N nodes of the mesh at time t = 1 . . .
T ; the operator H : C N → C M models the measurement process of the real or complex-valued state using a set of M sensors, giving rise to the observations y t ∈ C M ; M θ : C N → C N is an operator representing the PDE constraints that govern the temporal dynamics of the system with θ ∈ R P parameterizing M at time t .
In the context of inverse problems, we seek the initial state u 0 or the parameters θ given a set of observations y t =1 ...T .
These problem are often ill-posed and considerably more difficult than learning the forward simulation.
Here we explore efficient approaches that leverage recently proposed graph networks to solve PDE-constrained inverse problems.
For this purpose, we consider learning-based approaches to the simulation, where M is modeled by a graph network GNN : C N → C N .
Moreover, we formulate priors for both initial state u
= G u ( z u ) and the parameters θ =
G θ ( z θ ) that constrain these quantities to be fully defined in a lower-dimensional subspace by the latent codes z u ∈ R L u , L u < N , and z θ ∈ R L θ ,
L θ < P .
The fact that the graph network GNN , and finite element methods in general, operate on irregular meshes motivates us to explore emerging coordinate network architectures (Park et al., 2019; Tancik et al., 2020; Sitzmann et al., 2020) as suitable priors.
Coordinate networks operate on the continuous simulation domain and map coordinates to a quantity of interest, such as the initial condition or the parameters of a specific problem.
To our knowledge, this is the first approach to combining continuous coordinate networks with graph networks for learning to solve PDE-constrained inverse problems.
The summary of the proposed approach is shown in
Figure 1.
We demonstrate that this architecture affords faster runtimes and better quality for fewer observations than the principled solvers we tested, while offering the same benefits of improved accuracy over grid-based CNNs to inverse problems that graph networks offer for forward simulations (Figure 1).
2. Related Work
Machine learning methods have emerged as a powerful tool for modeling the dynamics of physical systems.
Compared to conventional methods (see e.g., Quarteroni & Valli (2008)), physics-based machine learning techniques may offer improved computational performance, ease of implementation, and learning priors from data to solve ill-posed physics-based inverse problems.
Previous techniques span a spectrum of being entirely data-driven (i.e., modeling dynamics with a feedforward pass through a network)
(Bhatnagar et al., 2019; Li et al., 2021;
Tompson et al., 2017; Lu et al., 2021; Lino et al., 2021;
Pfaff et al., 2021; SanchezGonzalez et al., 2020; Seo et al., 2020) to hybrid approaches that either directly incorporate conventional solvers (Um et al., 2020; Belbute-Peres et al., 2020; Bar-Sinai et al., 2019; Kochkov et al., 2021) or adapt similar optimization schemes or constraints (Karniadakis et al., 2021; Wang &
Perdikaris, 2021; Sirignano & Spiliopoulos, 2018; Raissi et al., 2019; Wang et al., 2021; Wandel et al., 2021).
Many of the aforementioned methods operate on regular grids, for example using convolutional neural networks (CNNs).
A major disadvantage of this approach is its inability to allocate resolution adaptively throughout the simulation domain.
Learning-based finite element methods (FEMs) (Xue et al., 2020) and graph neural networks (GNNs) (Kipf & Welling, 2017; Hamilton et al., 2017;
Veliˇckovi´c et al., 2018; Wu et al., 2020; Scarselli et al., 2008) have been shown to be a powerful method for simulation on irregular grids with adaptive resolution.
GNNs process data structured into a graph of nodes and edges, and have been demonstrated for modeling complex physical dynamics with particle- or mesh-based simulation (Lino et al., 2021; Seo et al., 2020; Li et al., 2020b;a).
Our approach is inspired by recent GNN architectures for modeling timeresolved dynamics (Pfaff et al., 2021; Sanchez-Gonzalez et al., 2020) that generalize to unseen initial conditions and solution domains.
Whereas these approaches focus on learning the forward simulation given a set of initial or boundary conditions, ours aims at solving ill-posed PDE-constrained inverse problems that require a learned simulation model as part of the framework.
Machine learning techniques have recently also been adapted for solving ill-posed physics-based inverse problems.
These problems often involve recovering solutions to PDEs (Raissi et al., 2020) or physical quantities, such as the density, viscosity, or other material parameters (Mosser et al., 2020;
He & Wang, 2021; Fan et al., 2020), from a sparse set of measurements.
Other methods can superresolve PDE solutions from estimated solutions at coarse resolution (Esmaeilzadeh et al., 2020) or recover initial conditions from PDE solutions observed at coarse resolution later in time (Li et al., 2020b; Frerix et al., 2021).
Yet another class of techniques are tailored to the inverse design problem, which aims to optimize material properties such that the PDE solution satisfies certain useful properties, e.g., for the design of nanophotonic elements (Molesky et al., 2018).
Our approach is most similar to other methods that infer material properties or initial conditions from sparse measurements of the PDE solution over time.
Similar to some of these methods (Mosser et al., 2020; Jiang & Fan, 2019; Hand et al., 2018), we use a generative model to learn a prior over the solution space of material parameters or initial conditions; however, our framework is the first to learn to map a latent code to material parameters or initial conditions compatible with a GNN forward model.
This allows our model to solve physics-based inverse problems on irregular grids with adaptive resolution, leading to improved computational efficiency and accuracy.
[Figure]
Sparse Observations
Predictions
Iterative rollout argmin ! ’
ℒ ( Observations , Predictions ) "
SGD 𝑧 !"!
# 𝑥 !
𝑧 $ 𝑥 !
Simulation Parameters (velocity)
Initial Condition (wavefield)
[Figure]
Observation Objective
GNN
GNN
3. Method
We approach the task of solving physics-constrained inverse problems by first pre-training a GNN as a fast forward model that outputs solutions to partial differential equations given the initial states and boundary conditions.
The physics-constrained inverse problems we aim to solve involve recovering initial conditions or other parameters that govern the evolution of the PDE.
Since recovering these quantities is an ill-posed problem, we also learn a prior over the space of solutions using a deep generative model.
Here, a network maps latent codes to a space of material parameters or initial conditions on the graph that comprise plausible solutions to the inverse problems.
At test time, the GNN is a fully-differentiable forward simulator, and the latent code of the generative model is optimized to minimize the difference between the predicted and the observed dynamics on the graph.
A detailed pipeline of our approach for solving inverse problem for the wave equation (Section 4) is shown in Figure 2.
3.1. GNN-based Simulator
GNNs have previously been found to perform well in simulating PDE models (Pfaff et al., 2021; Sanchez-Gonzalez et al., 2020).
The excellent performance can be attributed to their adaptive resolution and ability to generalize by modeling complicated local interactions.
Here, we leverage the state-of-art GNN (Pfaff et al., 2021) to learn a fast forward model that outputs solutions to partial differential equations given the initial states and boundary conditions.
The state of the system at time t is described as u t
=
( V, E ) with nodes V and mesh edges E that define the mesh.
We adopt the approach of (Pfaff et al., 2021) to model the temporal dynamics of the system, i.e., M θ , using a GNN with
Encoder-Processor-Decoder architecture followed by an integrator.
We encode the relative displacement vector (i.e., the vector that points from one node to another) and its norm as edge features, e i .
The node features comprise dynamics quantities that describe the state of the PDE and a one-hot vector, v i , indicating the type of the nodes (domain boundaries, inlet, outlet, etc.).
In the forward pass, the encoding step uses an edge encoder multilayer perceptron (MLP) and node encoder MLP to encode edge features and node features into latent vectors.
The processing step consists of several message passing layers with residual connections.
This step takes as input the set of node embeddings v i , and edge embeddings e ij , and outputs an updated embedding v i and e ij .
The equations that define the layers of the message passing steps are given by the following.
[Equation]
In the final decoding step, an MLP is used to transform the latent node features v i to the output p i , which we integrate at each time step to update the dynamic quantities u t +1 =
u t + p t .
3.2. Learning Inverse Problems and Priors
The inverse problems we wish to solve are of the form outlined in Equation 1 with the dynamics being learned by the
GNN described above.
Solving for the initial condition or parameters may be ill-posed, so we restrict the solutions to lie in a lower-dimensional subspace of the autodecoder-type priors G u or G θ .
When working on regular grids, these priors could easily be implemented as CNN-based generative model, but it is not clear how to model such priors for irregular meshes.
To this end, we leverage recently proposed coordinate networks with ReLU activation functions, which use a conditioning-by-concatenation approach to generalize across signals: [Equation] ReLU
[Equation]
where
ϕ i : R M i (cid:55)→ R N i is the i th layer of the MLP consisting of the affine transform defined by the weight matrix
W i ∈
R N i × M i and the biases b i ∈ R N i .
The input to the first layer concatenates the coordinate x with a scenespecific latent code vector z u/θ .
This coordinate network, implemented by an MLP, maps continuous coordinates on the simulation domain to a quantity of interest.
Thus, it can be evaluated on a regular grid or, more importantly, on the irregular locations of the graph nodes our GNN operates on.
We learn G u/θ in a pre-processing step, using training data relevant for a specific physical problem.
We optimize the network parameter, denoted by ψ G , and the latent code, z , with respect to the individual training sample, indexed by i , to maximize the joint log posterior of all training samples:
[Equation]
At test time, the pre-trained GNN modeling the dynamics and the pre-trained coordinate networks as the prior are fixed, and the latent code vectors z u/θ are optimized for a given set of sparse observations using a standard Adam solver (Kingma & Ba, 2014).
4. Experiments
We demonstrate our approach on the wave equation and the Navier–Stokes equations for modeling acoustics or fluid dynamics.
Our method leverages a learned simulator using a Graph Neural Network and a learned prior for fast and accurate recovery of the unknown parameters.
The U-Net (CNN) solver baseline is comparable to existing approaches in the literature for forward simulation (Th¨urey [Figure]
et al., 2020; Wandel et al., 2021;
Holl et al., 2019; Bhatnagar et al., 2019;
Tompson et al., 2017); since we focus on solving physics-constrained inverse problems, we extend this approach accordingly and incorporate our learned prior.
We also evaluate the effect of the learned prior.
We find that our approach gives a favorable tradeoff between accuracy and speed, enabling accurate recovery of the unknown parameters while being up to nearly two orders of magnitude faster than the classical FEM solver.
4.1. Two-Dimensional Scalar Wave Equation
The wave equation, Eq.
(6), is a second-order partial differential equation that describes the dynamics of acoustic or electromagnetic wave propagation.
[Equation]
Here, u is the field amplitude and c is the velocity parameter that spatially characterizes the speed of the wave propagation inside the medium.
The wave equation can be solved given initial conditions, u ′ 0 and u init , and the boundary conditions.
In our experiments, the domain is chosen to be Ω ∈ [0 , 1] 2 with an obstacle at the center.
The Dirichlet boundary conditions are used at all boundaries, u | ∂ Ω = 0 .
The initial field velocity is set to be 0, and the initial field distribution is denoted by u init .
The PDE-constrained inverse problem we are aiming to solve is to recover unknown parameters u init or c from sparse measurements of u in space and time.
Formally, it can be described as minimize
[Equation]
Here, we minimize the mean squared error (MSE) between the predicted field ( u pred t ) and the ground truth observed field ( u gt t ), summed over different observation time steps, t .
We address two different tasks, (1) recovering the initial condition, u init , and (2) full-waveform inversion (Virieux &
Operto, 2009) in which we recover the velocity parameter, c .
These optimized quantities are parameterized by the prior network G u init /c .
Finally, the measurement sampling operator is given by H , and M c is the forward model that solves the wave equation, Eq.
(6), to produce the field at the next time step.
Learned Forward Simulation
In our approach, M c is given by a GNN, which learns the wave equation forward model on irregular meshes.
As a baseline, we train a U-Net (CNN) forward model based on (Th¨urey et al., 2020).
Similar to (Pfaff et al., 2021), we train the GNN and U-Net (CNN) by directly supervising on a dataset of “ground truth” wave equation solutions generated with an open source FEM solver (FEniCS (Logg et al., 2012)).
The FEM solver uses a fine irregular mesh with many more nodes ( ≈ 2800) than the GNN ( ≈ 600) on average across the dataset.
The training dataset is composed of 1100 simulated time-series trajectories using 37 separate meshes.
We evaluate on 40 held-out trajectories acrossdifferent meshes.
We find that the FEM solver requires a timestep that is 5 × smaller than the GNN solver to achieve stable results.
At this setting, the FEM solver simulated on a fine irregular mesh is roughly 8 × slower than the GNN; running the FEM solver on the same grid as the GNN is 2.5 × slower than the GNN with accuracy roughly 80 × worse in terms of MSE.
To compare the accuracy of different learned forward simulators, we plot the accumulated relative error, unrolled for 50 time steps and averaged over 96 trajectories in Fig.
The GNN-based simulator provides a robust solution.
We evaluate two different cases for the U-Net (CNN).
In one case, we restrict the number of grid nodes to be roughly the same as the GNN (25 × 25).
Since the small number of nodes must be regularly and coarsely spaced, this provides poor performance.
Second, we set the grid resolution of the U-Net (CNN) such that the spacing between grid points matches the minimum spacing in the GNN mesh.
This requires 7 × more nodes than the GNN ( 64 × 64 ), but the performance is still relatively worse than the GNN.
Initial State Recovery For the initial state recover task, we solve Eq.
(7) where u init ( x ) =
G u init ( z, x ) is the unknown parameter and initial velocity is given to be 0.
For both this problem and full-waveform inversion, the prior is pretrained on a dataset of 10,000 values of u init (or c ), generated by sampling a Gaussian random field and tapering the solution to zero near the boundaries to satisfy the Dirichlet boundary condition. [Table]
We solve the inverse problems by optimizing the value of z using the ADAM optimizer (Kingma & Ba, 2014) for all experiments until convergence, or a maximum ofiterations.
In the case where we optimize without the prior, we directly optimize the unknown parameters, u init or c .
Table (1) reports a quantitative comparison of different solvers with and without the prior, and a qualitative comparison is shown in Fig.
Here we unroll the GNN for 30 GNN time steps and take measurements every 2 GNN steps from 2 to 30 time steps.
At every measurement, we have sensors placed at 20 randomly sampled nodes from the coarse irregular mesh.
For baseline comparisons with other form of meshes (regular for U-Net (CNN) and fine irregular mesh for FEM solver), we use nearest neighbor sampling to find the corresponding sensor location.
From the table we observe that with or without the prior, our approach provides a favorable trade-off between the accuracy and the speed.
While the U-Net (CNN) is the fastest forward simulator, the GNN solver outperforms the U-Net (CNN) solver in terms of accuracy at resolution 25 × 25 and performs slightly better than the U-Net (CNN) at resolution 64 × 64 .
We attribute this to the stronger performance of the GNN forward model, as shown in Fig. 3.
Given that the FEM solver operating on the finest mesh gives the most accurate forward model, it gives the best MSE in the inverse problem.
However, it is at least 8 × slower than the learned simulator approaches.
For all cases, using a learned prior significantly improves the final accuracy.
By optimizing the latent code, we constrain the solution space to the manifold learned by G u init /c and avoid bad local optima that lie far outside the dataset distribution.
Full Waveform Inversion Full-waveform inversion (FWI) is a common problem in seismology (Virieux et al., 2017) and involves recovering the density of structures in the propagation medium.
We are motivated by recent work that uses variants of a CNN as a prior (Mosser et al., 2020;
Wu & McMechan, 2019) or forward operator (Yang et al., 2021) for seismic inversion.
As we are primarily interested in a comparison between learned methods on regular and irregular meshes, we adopt the U-Net (CNN) baseline as a representative method that can be unrolled per timestep and integrated into our framework.
Since the prior is agnostic to the particular grid setup, we use the same prior across all models.
For the FWI problem, we minimize Eq.
(7) where c ( x ) =
G c ( z, x ) is the unknown parameter.
FWI is a highly nonlinear inverse problem, and the final optimization result depends heavily on the initial state and may easily fall into local minima.
In order to improve the optimization, different forms of progressive training schemes have been used.
For example, one can progressively fit the data in time by introducing a damping function as in (Chen et al., 2015).
In frequency-domain full-waveform inversion, one can first optimize low-frequencies to avoid local minima (Aghamiry et al., 2019; Brenders & Pratt, 2007).
In our approach, we adopt a progressive training scheme in time where we gradually increase the total number of observed time steps as the optimization proceeds.
For the FWI task, we unroll the
GNN for 30 GNN time steps and take measurements every 2 GNN steps.
At the beginning of the optimization, we only have observations at time step T = { 2∆ t } , and we include one extra time step’s measurement every 120 optimization iterations until T = { 2∆ t, 4∆ t, · · · , 30∆ t } .
Table (1) reports a quantitative comparison of the performance of different solvers used with or without the prior.
We observe similar trends as in the initial state recovery task, where using a learned prior significantly improves the final accuracy.
For this task, the proposed GNN solver gives the lowest MSE compared to the baselines.
Figure 5 shows qualitative comparisons between the different learned simulators and demonstrates that the proposed approach with the GNN forward model leads to a better recovery of the density distribution.
4.2. Two-Dimensional Incompressible Navier–Stokes Equation
The two-dimensional incompressible Navier–Stokes Equations are non-linear partial differential equations modeling the dynamics of fluids.
Taking a fluid density of ρ = 1 . 0 , the fluid is characterized by
[Equation]
Here, ν = 0 .
001 is the kinematic viscosity, u represents the velocity of the fluid in the x and y directions, and p represents the pressure.
These incompressible Navier–Stokes equations can be solved given the initial condition u and boundary conditions for the given domain.
For our experiments, we use an irregular domain Ω ∈ [0 , 1 . 6] × [0 , 0 . 4] with a cylinder of random radius at a random position near the flow inlet.
No-slip boundary conditions are defined at the lower and upper edge, as well as at the boundary of the cylinder as shown in Eq.
On the left edge, a constant inflow profile is prescribed, Eq.
(11); on the right edge, do-nothing boundary condition is used, Eq.
[Equation]
We carry out flow assimilation on the velocity field u given sparse velocity measurements in space and time.
Formally, we have minimize {
[Equation]
(cid:88)
[Equation]
∥
[Equation]
s.t
[Equation]
(13) where H is the measurement sampling operator, and M is the forward model that solves the incompressible Navier–
Stokes Equations.
Our assimilation trajectories are random flow clips of length
T = 10 time intervals from the test dataset.
We take measurements every 2 time intervals for a total of 5 measurement snapshots where each time intervals are equivalent to 1 learned solver timesteps, or 12.5 FEM solver timesteps.
At every measurements, we have 50 sensors measuring the velocity field, [ u x , u y ] , as shown in Fig. 6.
[Table]
# nodes
MSE
Runtime (s)
FEM (Irr. C.) 3.92e3.87e U
[Table]
Net ( [Table] [Table] 5.78e1.11eU-Net (Reg.
[Table]
2.55e1.65eGNN (Irr.
[Table]
9.73e1.10e Learned Forward Simulation As described in Sec. 3, our method uses a GNN as a fast and accurate learned simulator operating on irregular meshes.
Similar to the 2D scalar wave equation experiment, we train as baselines a U-Net (CNN) for an input resolution of 54 × 54 , which matches the average number of nodes of the irregular grid used by the GNN ( ≈ 2732 nodes).
We also train a U-Net (CNN) at 128 × 128 resolution, which contains roughly 6 × more nodes compared to the coarse irregular grid (Irr. C.) used by the GNN.
All learned simulators are trained in a supervised manner on a dataset obtained using an open source FEM solver (Logg et al., 2012).
Our dataset consists oftraining trajectories on 55 meshes, and 50 test trajectories on 5 meshes.
The unrolled MSE is shown in Table (2).
We observe a similar trend as in the wave equation example: the
GNN gives the best accuracy among learned solvers and is approximately 35 × faster than the FEM solver.
Fluid Data Assimilation We train our prior G u on 34000 fluid snapshots from the training trajectories, where
G u ( z, x ) = u ( x ) =
[ u x ( x ) , u y ( x )] .
Similarly to the wave equation experiment, we solve the optimization problem given in Eq.
(13) using the ADAM optimizer (Kingma &
Ba, 2014).
Different from the wave equation experiments we add a fine-tuning stage to the optimization where we update the parameters of the generative prior G u , which helps to improve the generalization performance in this problem.
Similar techniques have been widely used in GAN inversion problems (Daras et al., 2020; Roich et al., 2021).
Figureshows the averaged observation objective with optimiza- 𝑢 ! 𝑢 " t i m e s t e p s x y t i m e s t
e p s x y
[Figure]
Fluid Data Assimilation
MSE
[Table]
Runtime
[Table]
FEM (Irr. C.)
[Table]
U-Net (Reg. C.)
[Table]
.02e
[Table]
[Table]
U-Net (Reg.
F.)
[Table]
tion steps for different forward model and with or without fine-tuning procedure.
After beginning the fine-tuning procedure we notice a spike in the objective function, but the optimization ultimately converges to much lower residuals than without the fine-tuning procedure.
In Table (3), we qualitatively compare the data assimilation performance for different forward models with the learned prior, and qualitative comparisons can be found in Fig.
We report the average MSE over all time steps of u x and u y as our evaluation metric.
We observe similar trends as in the wave equation experiment: the learned GNN forward model with the learned prior achieves better accuracy compared to the coarse U-Net (CNN) model, which has a similar number of nodes.
While the FEM solver gives the best fluid reconstruction, it is 50 × slower than the GNN.
U-Net (Reg.
F.) uses 5 × more nodes than the GNN, but achieves similar performance. [Figure]
5. Discussions
In this paper we present a general framework for solving
PDE-constrained inverse problems with a GNN-based forward solver and an autodecoder-style learned prior.
Both the
GNN-based learned simulator and the learned prior operate on irregular meshes with adaptive resolution, enabling representing and processing signals with fewer nodes compared to the regular grids used by convolutional networks.
Our experiments on the wave equation and Navier–Stokes equations demonstrate that the proposed framework achieves improved performance compared to a conventional U-Net (CNN) operating on grids with the same number of nodes as the GNN.
Moreover, our approach is up to 90 × faster compared to conventional FEM solvers.
We also mention a few limitations of the proposed approach.
The current implementation is limited in the number of timesteps that can be modeled in the inverse problem due to memory required to unroll the solvers.
Also, the method requires the forward model to be trained from scratch for changes to the underlying equations (e.g., significant changes to the boundary conditions or dynamics).
Still, techniques like gradient checkpointing (Griewank, 1992) may be helpful to mitigate the memory constraints of the unrolled optimization, and generalizing learned physics solvers across problem settings is an promising direction for future work.
Overall, our approach works to integrate GNNs and learned priors for solving physics-constrained inverse problems.
Our approach may be useful for solving ill-posed problems across a range of tasks related to physics-based simulation and modeling.
GNNs are an attractive architecture for efficient modeling across multi-resolution domains and may yield even greater improvements compared to conventional
CNNs, especially for larger domains or in 3D problem settings.
6. Acknowledgements
This project was supported in part by a PECASE by the
ARO and Stanford HAI.