Learning Controllable Adaptive Simulation for Multi-resolution Physics
Authors: Tailin Wu
Takashi Maruyama
Qingqing Zhao
Gordon Wetzstein
Jure Leskovec
Venue: ICLR 2023 notable top 25% (2023)
Keywords: adaptive
multi-scale
error vs. computation
controllable

Abstract: Simulating the time evolution of physical systems is pivotal in many scientific and engineering problems. An open challenge in simulating such systems is their multi-resolution dynamics: a small fraction of the system is extremely dynamic, and requires very fine-grained resolution, while a majority of the system is changing slowly and can be modeled by coarser spatial scales. Typical learning-based surrogate models use a uniform spatial scale, which needs to resolve to the finest required scale and can waste a huge compute to achieve required accuracy. In this work, we introduce Learning controllable Adaptive simulation for Multi-resolution Physics (LAMP) as the first full deep learning-based surrogate model that jointly learns the evolution model and optimizes appropriate spatial resolutions that devote more compute to the highly dynamic regions. LAMP consists of a Graph Neural Network (GNN) for learning the forward evolution, and a GNN-based actor-critic for learning the policy of spatial refinement and coarsening. We introduce learning techniques that optimizes LAMP with weighted sum of error and computational cost as objective, allowing LAMP to adapt to varying relative importance of error vs. computation tradeoff at inference time. We evaluate our method in a 1D benchmark of nonlinear PDEs and a challenging 2D mesh-based simulation. We demonstrate that our LAMP outperforms state-of-the-art deep learning surrogate models, and can adaptively trade-off computation to improve long-term prediction error: it achieves an average of 33.7% error reduction for 1D nonlinear PDEs, and outperforms  MeshGraphNets + classical Adaptive Mesh Refinement (AMR) in 2D mesh-based simulations. Project website with data and code can be found at: http://snap.stanford.edu/lamp.

Published as a conference paper at ICLR 2023
LEARNING CONTROLLABLE ADAPTIVE SIMULATION FOR MULTI-RESOLUTION PHYSICS
Tailin Takashi Maruyama' 122,, Qingqing Zhao'r, Gordon Wetzstein Jure Leskovec' Stanford University. "NEC Corporation
tailinecs. stanford, edu, 4 49takashi@@n seneee com, cyanzhad@stanford.ccoo gordonwz@stanfordd edu, jureê wt stanford.edu
ABSTRACT
Simulating the time evolution of physical systems is pivotal in many scientific and engineering problems. An open challenge in simulating such systems is their multi-resolution dynamics: a small fraction of the system is extremely dynamic, and requires very fine-grained resolution, while a majority of the system is chang- ing slowly and can be modeled by coarser spatial scales. Typical learning- beaniig-basedd based surrogate models use a uniform spatial scale, which needs to resolve to the finest required scale and waste a huge compute to achieve required accuracy. In this work, we introduce Learning controllable Adaptive simulation for Multi- resolution Physies (LAMP) as the first full deep learning- learning-based surrogate model that jointly learns the evolution model and optimizes appropriate spatial resolu- tions that devote more compute the highly dynamic regions. LAMP consists of a Graph Neural Network (GNN) for learning the forward evolution, and a GNN- based actor-critic for learning the policy of spatial refinement and coarsening. We introduce learning techniques that optimizes LAMP with weighted sum of error and computational cost as objective, allowing LAMP to adapt to varying relative importance of error computation tradeoff at inference time. We evaluate method in a 1D benchmark of nonlinear PDEs and a challenging 2D mesh-based simulation. We demonstrate that LAMP outperforms state-of-the-art deep learning surrogate models, and can adaptively trade-off computation to improve long-term prediction error: it achieves an average of 33.7% error reduction for ID nonlinear PDEs, and outperforms MeshGraphNets + classical Adaptive Mesh Refinement (AMR) in 2D mesh-based simulations. Project website with data and code can be found at: http:/ snap. stanford...o..o edu/ladndddnanm
INTRODUCTION
Simulating the time evolution of physical system is of vital importance in science and engineering
[Lynch 2008 Carpanese 2021 Sircombe et al. 2006 Courant et al. 1967 Lelievre & Stoltz, 2016). Usually, the physical system has multi-resolute nature: a small fraction of the system is highly dynamic, and requires very fine-grained resolution to simulate accurately, while majority of the system is changing slowly. Examples include hazard prediction in weather forecasting (Majumdar et al. 2021), disruptive instabilities in the plasma fluid in nuclear fusion (Kates-Harbeck et al. 2019) , air dynamics near the boundary for jet engine design (Athanasopoulos et 20.99) and more familiar examples such as wrinkles in a cloth (Pfaff et al. (222)) and fluid near the boundary for flow through the cylinder (Vlachas et al. (022). Due to the typical huge size of such systems, it is pivotal that those systems are simulated not only accurately, but also with as small of computational cost as possible. A uniform spatial resolution that pays similar attention to regions with vastly different dynamics, will waste significant compute on slow-changing regions while may be insufficient for highly dynamic regions.
To accelerate physical simulations, deep learning bDLe) surrogate models have recently emerged as promising alternative to complement (Um et al.) (020) or replace (Li et al. 2021) classical solvers. They reduce computation and accelerate the simulation with larger spatial (Um)
"qqual contribution.

---

Published as a conference paper at ICLR 2023
Forward Iteration
M
M
M
Kre Keo
polley
remesh
f8
fevo
M
M
M
Full Rollout
Forward
Forward
Rollout without Remeshing
revo
Ja
M
M
M
Reward
= AError + &Computation
Figure I: LAMP schematic. The forward iteration (upper box) first uses the policy foolicy to decide the number K and K of edges as well as which edges among the full mesh to be refined or coarsened, and then executes remeshing and interpolation. The evolution model fo is applied to the updated mesh N to predict the state M the next time step. We use the reduction of both Error and Computation (mesh size), compared to multi-step rollout without remeshing, reward to learn the policy. For more details, see Section 3.2
ctt al. 2020, Kochkov et al.] 202 1) or temporal resolution (Li et al. 2021). or via latent represen- tations SSnnhezz-Gnzzaee surrogate models typically assume a uniform or fixed spatial resolution, without learning how to best assign computation the most needed spatial region. Thus, they may be insufficient address the aforementioned multi-resolution challenge. Although adaptive methods, such as Adaptive Mesh Refinement (AMR) (Soner al., 2003 Cerveny al. 2019) exist for classical solvers, they share similar challenge (e.g., slow) as classical solvers. A deep dearningbbased surrogate models, that is able to learn both the evolution and learn to assign computation the needed region, is needed.
al. 2020, Wu et al. 2022). However, current deep learning-based
In this work, we introduce Learning controllable Adaptive simulation for Multi-resolution Physics (LAMP) as the first fully DL-basedd surrogate model that jointly learns the evolution model and optimizes appropriate spatial resolutions that devote more compute to the highly dynamic regions. Our key insight is that by explicitly setting the error and computation as the combined objective to optimize, the model can learn to adaptively decide the best local spatial resolution to evolve the system. To achieve this goal, LAMP consists of a Graph Neural Network (GNN)-based evolution model for learning the forward evolution. and GNN- based actor-critic for learning the policy of discrete actions of local refinement and coarsening of the spatial mesh conditioned on the local state and coefficient that weights the relative importance of error computation. The policy (actor) outputs both the number of refinement and coarsening actions, and which edges to refine or coarsen, while the critic evaluates the expected reward of the current policy. The full system trained with an alternating fashion, iterating between training the evolution model with supervised loss, and training the actor-critic via reinforcement learning (RL). Taken together, single instance of evolution model and actor-critic jointly optimizes reduction of error and computation for the physical simulation, and can operate across the relative importance of the two metrics inference time.
We evaluate our model on 1D benchmark of nonlinear PDEs (which tests generalization across PDEs of the same family), and a challenging 2D mesh-based simulation of paper folding. In ID, we show that our model outperforms state-of-the-art deep learning-based surrogate models in terms of long-term evolution error by 33.7%. and can adaptively tradeoff computation to improve long-term prediction error. On 2D mesh-based simulation, our model outperforms state-of-the-art Mesh- GraphNets + classical Adaptive Mesh Refinement (AMR) in 2D mesh-based simulations.
PROBLEM SETTING AND RELATED WORK
We consider the numerical simulation of a physical system, following the notation introduced in PPffff et al. 2021). The system's state at time & is discretized into the mesh-based state M
2

---

Published as a conference paper at ICLR 2023
0,1,2,... ..., where E' is the mesh edges and V is the states at the nodes at time t. Each node i E V contains the mesh-space coordinate it and dynamic features q:- Note that this representation of the physical system is very general. It includes Eulerian systems (Wu et al. 2022) where the mesh is fixed and the field di on the nodes are changing, and Lagrangian systems (Sanchez-Gonzalee et al., 2020, Pfaff al. 202T) where the mesh coordinate in physical space is also dynamically moving (for this case, an additional world coordinate 2; is accompanying the mesh coordinate uz). During prediction, a simulator f (classical learned) autoregressively predicts system's 's state M at the next time step based on its previous prediction M at previous time step:
M++1 f(M t 2,
(1)
where M7 = MM is the initial state. During the prediction, both the dynamic features V at the mesh nodes, and the mesh topology E can be changing. The error is typically computed by comparing the prediction and ground-truth after long-term prediction: error := E(M', .M') for a metric (e.g., MSE, RMSE), and the computation cost (in terms of floating point operations, or FLOPs) typically scales with the size of the mesh (e.g.. the number of nodes). The task is to evolve the system long- term into the future, with low error and constraint on the computational cost.
Most classical solvers use a fixed mesh E' whose topology does not vary with time. For example, the mesh E = F can be 2D or 3D regular grid, or irregular mesh that is pre-generated at the beginning of the simulation (Geuzaine & Remacle (009). Classical Adaptive Mesh Refinement (AMR) (Narain al.) 2012) addresses the multi-resolution challenge by adaptively refine coarsen the mesh resolution, with heuristics based on local state variation. Since they are based on classical solvers, they may not benefit from the many advantages that deep learning brings (GPU acceleration, less stringent spatial and temporal resolution requirement, explicit forward, etc.). In contrast, our LAMP a deep-learning based surrogate model, and can benefit from the many advantages (e.g.. speedup) offered by the deep learning framework. Furthermore, since it directly optimize for linear combination of error and computation, it has the potential to directly optimize to a better error vs. computation tradcoff, nearer to the true Pareto frontier.
Deep-learning based surrogate models, although having achieved speedup compared to classical solvers, still typically operate on fixed grid or mesh (Li et al. 202T, Sanchez et al.] 2020 Wu jet al. 2022] Zhao et al. 2022, Han et al., 2022). and have yet to exploit the multi- typical in physical simulations. One important exception is MeshGraphNets (Pfaff et al. (021), which both learns how to evolve the state V and uses supervised learning to learn the spatial adaptation that changes E.. However, since it uses supervised learning where the ground-truth mesh is provided from the classical solver with AMR, it cannot exceed the performance of AMR in terms of error vs. computation tradeoff, and has interact with the classical solver in inference time to perform the adaptive mesh refinement. In contrast, our LAMP directly optimizes for the objective, which uses reinforcement learning for learning the policy of refinement and coarsening, and has the potential to surpass classical AMR and achieve a better eгror vs. computation tradeoff. Moreover, a single trained LAMP can adapt to the full range of relative importance / of error vs. computation at inference time, thus can be more versatile than MeshGraphNets with a fixed strategy. Another pioneering work by Yang et al. (202I) learns the adaptive remeshing using RL. It has notable differences with our work. Firstly, their method is evaluated for the specific finite element method (FEM), and cannot be directly applied for more general simulations, e.g., cloth simulations in our experiment. Furthermore, our method is the first method that jointly learns the remeshing and evolution. Secondly, while the goal of Yang et al.) (2021) is to reduce error, ours is to learn controllable tradeoff between reducing error and reducing computational cost. Thirdly, the actions of Yang et al. (202T) are refinement on the faces of the rectangular meshes, while our actions are refinement and coarsening on the edges of triangular meshes. Fourthly, LAMP does not require the classical solver in the loop, thus significantly reducing the training time.
nature
METHOD
In this section, we detail our LAMP method. We first introduce its architecture in Sec. 3.1 Then we introduce its learning method (Sec. 3.2), including learning objective and training, and technique to let it learn to adapt to varying importance of error and computation. The high-level schematic of our LAMP is shown in Fig.
3

---

Published as a conference paper at ICLR 2023
3.1 MODEL ARCHITECTURE
The model architecture of LAMP consists of two components: an actor-critic which updates the mesh topology, and an evolution model which evolves the states defined on the mesh. We will detail them one by one.
The actor-critic consists of a policy network fo pooliey (with parameter yp) which predicts the probability of performing the spatial coarsening or refining actions, and value network fralue which evaluates the long-term expected reward of the policy network:
Actor-critic.
P(A = a' M = M3, B) = (a |M B) = fgolicy (M')
(2)
8 1
value (M', ())
(3)
where at is the (refining and coarsening) action performed on the edges E* that will become E++1, The policy network f outputs the probability of performing such action and can sample from this probability. of estimates the "value" of the current policy starting from current state M (for more information, see Sec. 3.2 below). The explicit dependence on 3 (as the 3 in Eq. allows the policy and value network to condition on the varying importance of error and computation. Given the predicted mesh Ex+1 and the current node features V on the current mesh E interpolation interr is performed which obtains the node features on the new mesh (see Appendix B for details):
F ii (V', Et+1 .E')
Now the new intermediate state M1
is defined the new mesh E++1
Evolution model. The second component is an evolution model f which takes as input the intermediate state M defined on g++1, and outputs the prediction of node features pe+ for time ++1. 1:
F++
(M")
(5)
Note that in this stage, the mesh topology +++ is kept constant, and the evolution model fø (with parameter 0) learns to predict the state based on the current mesh.
Taken together, Eqs.
5 evolve the system state from M at time to state - (ir++1, Et+1) at t + 1. During inference, they are executed autoregressively following Eq. to predict the system's 's future states A/', t 1, 2, .... given an initial state M
GNN architecture. One requirement for the evolution model f policy network fgoliey and value network fralue is that they can operate on changing mesh topology E Graph Neural Networks (GNNs) are an ideal choice that meets this requirement. Since we represent the system's 's state as mesh adopt MeshGraph (Praff al., 2021) as the base architecture for the above three models. Specifically, we encode V as node features for the graph, and encode the mesh topology Ex edges and world edges as two types of edges, and the edge features depend on the relative positions in the mesh coordinates and world coordinates. Based on the graph, a processor network that consists of N layers of message passing are performed to locally exchange and aggregate the information:
Z z(c)m+1 MLP (() (F. 2(1)nn 2
z((um+1 MLP (v) / (Z (1) Σ
Z z(em+1).
where z(1)m is the latent node vector on node i at layer n, and z/00 is the latent edge vectors on the th layer on the edge from node i to node j. We have 2 = V and ((()NN 4-+ are input and predicted node features time / and ( + 1, respectively, in Eq. (5). Figure provides an illustration of the architecture. We use an independent processor for the evolution model, and share the processor for the policy and value networks. After the processor, the latent vectors concatenated with 3 to feed into downstream decoders. For the evolution model for decoder is operated on the latent state and outputs the prediction f- on the nodes. For the value network, an value MLP is operated on all nodes, and a global pooling is performed to compute the overall estimated value. For the policy network, we design the action decoder as follows.
4

---

Published as a conference paper at ICLR 2023
Action representation. To predict the action for policy network and its probability, first need to design the action space. Note that compared to typical reinforcement learning problems, here the action space is extremely high- nigh-dimensional and complicated: (1) each edge of the mesh may have the option of choosing refinement or coarsening. If there are thousands of edges Nedge, then the possible actions will be on the order of Vate (2) Not all actions are valid, and many combinations of actions are invalid. For example, two edges on the same face of the mesh cannot be refined at the same time, nor can they be both coarsened. To address this high-dimensionality action problem, we introduce the following design of action space, where for both refinement and coarsening, the policy network first samples integers AT, K= E {0, ...KK..maayy }, and then independently samples A edges to perform refinement and K edges perform coarsening with proper filtering. The full sampled action is a' = (K ef, "....C K ef, .62 ....). where hT h E (0, 10..,. K...., J. and E E k = 1,2,
c x
The log- cog-probability for the sampled action a' is given by:
K
log P. (a M = log P (K*) +
Pl (efl + log (
+
lo (M))
3.2 LEARNING
The ultimate goal of the learning for LAMP is to optimize the objective Eq. as follows:
I = (1 3) Error + 3 Commutttion
(8)
for wide range of B. To achieve this, first pre-train the evolution model without remeshing to obtain a reasonable evolution model, then break down the above objective into an alternative learning of two phases (Appendix [B:]]: learning the evolution model with objective 7 that minimizes long- term evolution error, and learning the policy with objective I policy that optimizes both the long-term evolution error and computational cost.
Learning evolution. In this phase, the evolution model f is optimized to reduce the multi-step evolution error for the evolution model. As before, we denote M 0, 1,2, 8 = 1. as the state of the system at time + s simulated by the ground-trune solver with very fine-grained mesh, and denote M t 0, 0, following the current policy, up to a horizon of S steps into the future. We further denote N/ 0, 1,,,..., = 0, 1.5. as the prediction by the current evolution model on the fine-grained mesh, where its mesh is provided as ground-trun mesh E++ at each time step. Then the loss is given by:
= 0, .. as the prediction by the current LAMP
1 = [
(Sooliyy
:19
pevo, Nr4 + I. TT M
golicy EMM M
(10)
Essentially, we optimize two parts of the evolution loss: (1) I [fBolicy f5 A79 which is the evolution loss by following policy network foaliay and evolution model fø starting at initial state of M for S steps. (here af policy is the coefficient for the s-step loss with loss function f). This makes sure that evolution model f adapts to the current policy gpolicy that designates proper computation. (2) The second part of the loss, [I, fam; " is the evolution loss by using the ground-truth mesh and evolved by the evolution model f3"0, starting at initial state of fine-grained mesh A and evolve for steps. This encourages the evolution model to learn to utilize more computation to achieve better prediction error, if the mesh is provided by the ground-trui -trut mesh.
Learning the policy. In this phase, the policy network pooliey learns to update the spatial resolution (refinement or coarsening of mesh) at each location, to improve both the computation and the pre- diction error. Since the spatial refinement and coarsening are both discrete action, and the metric of computation is typically non-differentiable, we use Reinforcement Learning (RL) to learn the policy. Specifically, we model it as a Markov Decision Process (MDP), where the environment state is the system's state M', the actions are the local refinement or coarsening at each edge of E*, and we design the reward as the improvement on both the error and computation, between following the current policy's is action, and an counterfactual scenario where the agent follows an identity policy T
5

---

Published as a conference paper at ICLR 2023
that does not update the mesh topology, starting the initial state Mr. Concretely, the reward is r² = (1 (1- -3 Arroo + 3 AComputation
(11)
AError L5 [I, f M - L [ ffaliey
:o fevo, MM]
(12)
AComputation = Cs( f8 A7' - Cs( .100 N
(13)
Here Cs(+] is a surrogate metric that quantifies "Computation" based on the predicted mesh topology B++1, E E.. up to S steps into the future. In this paper we use the number of nodes as the surrogate metric for measuring the computation, since typically for the GNNs, the computation (in terms of FLOPs) scales linearly with the number of nodes (since each node has a bounded number of edges on the mesh, the number of edges thus scales linearly with number of nodes, will message passing and node updates).
To optimize the reward r', employ the standard REINFORCE used in (Sutton et al. Hafner et al. 2021) update the policy network fouliey with the following objective:
1999
Lit E, (a' M', 3)sg(r* - - 3)) r (ap, P)]]
(14)
Here H[-] is the entropy, which encourages the action to have higher entropy to increase exploration, where 1) here is hyperparameter. The sg(-) is graddent. Essentially, the first term in loss L encourages to increase the log-probability of actions that have a higher "aadvantage", where the advantage is defined as the difference between the current reward rf that follows the current action a' taken, and the expected reward (value) f ,3) that follows the current policy starting from the current state M We can also think of it accurately the expected reward of the current policy, and an actor (policy) is trying to exceed that expectation. To train the value network, we use MSE loss:
actor-critic where the critic tries evaluate
Lyglue = E, [(fgalue (M', - -))
(15)
Learning adapt varying B. In the overall objective (Eq. 8) the 3 stipulates the relative importance between Error and Computation. 3 = means we only focus on minimizing Error, without constraint on Computation. 8
means we only focus on minimizing computation, without considering the evolution error. In practice, we typically wish to improve both, with a
E (0, 1) that puts more emphasis on one metric but still considers the other metric. To allow LAMP to be able to operate at varying 3 at inference time, during the learning of policy, we sample uniformly within range B C [0. 1] (e.g., B can (0, 1] or [0. 0.5)). for different examples within minibatch, and also train the policy and value network jointly, where the total loss Dolicy is the
weighted sum of the two policy and value losses:
p
E8~B L agtor + value
L Value
(16)
where a value is a hyperparameter, which we set as 0.5. In this way, the policy can learn generic way of spatial coarsening and refinement, conditioned on B. For example, for smaller 3 that focuses more on improving error, the policy network may learn to refine more on dynamic regions and coarsen less, sacrificing computation to improve prediction error.
4 EXPERIMENTS
In the experiments, we set out to answer the following questions on our proposed LAMP:
Can LAMP learn to coarsen and refine the mesh, focusing more computation on the more dynamic regions to improve prediction accuracy?
Can LAMP improve the Pareto frontier of Error vs. Computation, compared to state-of- the-art deep learning surrogate models?
Can LAMP learn to condition the 3 to change is behavior, and perform varying amount of refinement and coarsening depending on the /3?
We evaluate our LAMP on two challenging datasets: (1) ID benchmark nonlinear PDEs which tests generalization of PDEs in the same family (Brandstetter et al. 2022); (2) a mesh- based pa- per simulation generated by the AreSim solver (Narain al. 2012). Both datasets possess multi- resolution characteristics where some parts of the system is highly dynamic, while other parts are changing more slowly.

---

Published as a conference paper at ICLR 2023
4.1
ID NONLINEAR FAMILY OF PDES
Ours, B = 0.1
Ours, B = 0.2
Ours, B = 0.7 0.7
Uniform
(+34)
(+211)
(+2)
550
1-3.3
(+3)
(-8)
(-10)
Figure 2: Example rollout result of our LAMP on ID nonlinear PDEs. The rollout is performed over 200 time steps, where different color denotes the system's 's state at different time. On each state, we also plot the corresponding mesh as black dots. The upper green and lower blue band shows the added and removed nodes of the mesh, comparing the end mesh and initial mesh. We see that with smaller B (e.g., 8 = 0.1) that emphasizes more on "Error", it refines more on highly-dynamic regions (near shock front) and coarsens less. With a larger / (e.g., 3 = 0.7) that focuses more on reducing computation, it almost doesn't 't refine, and choose to coarsen on more static regions.
Data and Experiments. In this section, we test LAMP's ability to balance error vs. computation tested on unseen equations with different parameters in a given family. We use the ID benchmark in Brandstetter et al. (2022), whose PDEs are given by
[a:u a, :00.u + [)=z))] (t,z) x(t,z)
(17)
u(0, x) = 8(0,,,, 8(1,z) = Σ
Aysin(wey + 2 Φ5)
(18)
j=1
The parameter for the PDE is given by p (a. 3, 7). The term ō is forcing term (Bar-Sinai et al.
2019) with J = 5, L = 16 and coefficients A, and W/ sampled uniformly from A, ~ U1-0.5, 0.5]. wy UI-0.4.0.41 E, 23, oj ~ [0 2T). We uniformly discretize the space to n2 200 in (0, 16) and uniformly discretize time to n2 = 250 points in [0, Space and time are further downsampled to resolutions of nz) E {(250, 100), (250, 50), (250, 25)} initial resolution. We use the E2 scenario in the benchmark, which tests the model's ability to generalize to novel parameters of PDE with the same family. Specifically, we have that the parameter p (1, 0) where 1) ~ [0, 0.2].
As our LAMP autoregressively simulate the system, it can refine coarsen the mesh at appropriate locations by the policy network foolicy before evolving to the next state with the evolution model 15 We evaluate the models with the metric of Computation and long-term evolution Error. For the computation, we use the average number of vertices throughout the full trajectory as a surrogate metric, since the number of floating point operations typically scales linearly with the number of vertices in the mesh. For long-term cvolution error, we use the cumulative MSE over 200 steps of rollout, starting with initial state from time steps 25 to 49, We compare LAMP with strong baselines of deep learning-baad based surrogate models, including CNNs, Fourier Neural Operators (FNO) (Li et al. 2) and MP-PDE (Brandstetter et al. 2022) which is faate-of-the-aa deep learning- based surrogate models for this task. Our base neural architecture is based on MeshGraphNets (Pfaff et al.) 2021) which is a state-of-the-art GNN-based model for mesh-based simulations. We compare an ablation of our model that does not perform remeshing (LAMP no remeshing), and a full version of our model. For all models, we autoregressively roll out predict the states for a full trajectory length of 200, using the first 25 steps as initial steps. We perform three groups of experiments, starting at initial number vertices of 25, 50 and 100 that is downsampled from the 100-vertice mesh, respectively. The three baselines all do not perform remeshing, and our full model has the ability to perform remeshing that coarsen or refine the edges at each time step. We record the accumulated MSE as measure for error, and average number of vertices over the full rollout trajectory as metric for computational cost. Note that for all models, the MSE is computed on the full ground-truth mesh with 100 vertices, where the values of prediction the ground-trus truth. This prevents the model to "cheat" by reducing the number of vertices and only predict well on those vertices. Additional details of the experiments are given in Appendix B.2
linearly interpolated onto the location of
7

---

Published as a conference paper at ICLR 2023
Table 1: Result (error and computational cost) for ID family of nonlinear PDEs, for total rollout trajectory of 200 time steps, providing the first 25 steps input. LAMP significantly reduces the long-term prediction error compared baselines, especially for smaller number of initial vertices (error reduction of 71.5% for 25 initial vertices, and 23.5% for 50 initial vertices), when evaluating on ground-truth mesh that has 100 vertices. This shows that LAMP able to improve prediction error by selecting where to focus computation especially with more stringent computational constraint. Note that we limit the maximum #vertices to be 100 for all models.
Model
Initial vertices
Average vertices
Error (MSE)
CNN
25
25.0
4.75
FNO
25.0
4.85
MP-PDE
25
25.0
3.69
LAMP (no remeshing)
25.0
6.39
LAMP (ours)
25
37.6
1.05
CNN
50.0
1.10
FNO
50
50.0
1.79
MP-PDE
50.0
0.98
LAMP (no remeshing)
50
50.0
2.15
LAMP (ours)
53.2
0.75
CNN
100
100.0
0.81
FNO
100
100.0
1.39
MP-PDE
100
100.0
0.88
LAMP (no remeshing)
100
100.0
0.75
LAMP (ours)
100
100.0
0.76
Results. Table shows the results. We that LAMP outperforms all baselines by large margin, achieving an eπror reduction of 71.5%, 23.5% and 6.2% (average of 33.7%) on initial #nodes of 25, 50 and 100, respectively, compared with the best perform- ing baseline of CNN, FNO and MP-PDE. Importantly, we see that compared with an abla- tion with no remeshing, our full LAMP is able significantly reduce error (by 83.6% er- for reduction for 25 initial vertices scenario, and 65.1% for 50 vertices scenario), with only modest increase of average number of vertices (by 50.4% and 6.4% increase, respectively). This shows the ability of LAMP to adaptively trade compu- tation to improve long-term prediction error.
To investigate whether LAMP is able to focus computation on the most dynamic region, we visualize example trajec- tory of LAMP, as shown in Fig. 2 and Fig. in Appendix C.I Starting with 50 vertices, we test our model on differ- B, where smaller 3 focuses
p=02
$-0.
gra.3
5-0.4
improving error. We see that with smaller 3 (e.g., B = 0.1), LAMP is able add more nodes (25 nodes) the most dynamic region, and only coarsen few (removing 3 nodes in total). With a larger 3 that focuses more on reducing computation, we that LAMP refines less and coarsen more, and only coarsen on the more slowly changing region. Additionally, we vi- sualize the error (y-axis) vs. number of vertices for varying for two different models over test trajectories in Fig. 3 We that with increasing B, LAMP is able to reduce the vertices more, with only slight increase of error. Fur- thermore, LAMP significantly improves the Pareto frontier. In summary, the above results show that LAMP able to focus computation dynamic regions, and able adapt different 8 at inference time.
5-0
p-0
2-0.
the ramesning
30
40
50
60 A Vertices
70
80
90
100
Figure 3: Error (MSE) vs. average number of vertices with varying 8, for two LAMP models trained with initial number of vertices of 25 (marked by solid stars) and 50 (solid circles), and baselines (hollow markers). We see LAMP improves the Pareto frontier.
4.2 2D MESH-BASED SIMULATION
Here we evaluate our LAMP's ability on a more challenging setting with paper folding simulation. The paper in this simulation square-shaped and its boundary edge length is 1. During the simula-
8

---

Published as a conference paper at ICLR 2023
Initial state
LAMP remeshing)
MeshGraphNets GT remeshing
MeshGraphNets +
LAMP (ours)
Ground truth
heuristic remeshing
Figure 4: Example result of 2D mesh-based paper simulation. We observed that LAMP is adding more resolution the high-curvature region to resolve the details and coarsen the middle flat region. Figure a) is at 0, and figure b), c), d), e), f) are LAMP (no remeshing), MeshGraphNets with ground-truth mesh, MeshGraphNets with heuristic remeshing, LAMP (ours), and the ground-truth results at 20. Additional visualization could be found in Figure
Table Computation vs. Error for 2D mesh-based paper simulation for different methods. With the proposed learned remeshing framework, LAMP able to achieve better roll-out error with slight increase average number of vertices. Reported number is the MSE over 20 learned-simulatorr steps roll-out, starting initial states at steps 10, 30, and 50, averaged over 50 test trajectories.
Model
Initial vertices
Average # vertices
Error (MSE)
MeshGraphNets + GT remeshing MeshGraphNets + heuristics remeshing
102.9
115.9
5.91e-4
102.9
191.9
6.38e-4
LAMP (no remeshing)
102.9
102.9
6.13e-4
LAMP (ours)
102.9
123.1
5,80e-4
tion, 4 corners of the paper will receive different magnitude of force. When generating ground-truth trajectories by the AreSim solver (Narain et al., 2012). set the minimum and maximal length of edges to be 0.01 and 0.2. We evaluate the models with the metric of Computation and long-ten term evolution error. Similar the Section 4.1 we use the average number of nodes throughout the full trajectory as a surrogate metric for complexity. We also compare with two baselines. The first baseline is MeshGraphNets with ground-truth (GT) remeshing, where the remeshing is provided by the ArcSim's 's Adaptive Anisotropic Remeshing component. This is used in (Pfaff et al. 2021 and provides lower error than learned remeshing. The second baseline is MeshGraphNets + heuristics remeshing, where the heuristics refines the edge based on the local curvature (Appendix B.4).
As shown in Table 2 our model able add more resolution to the high curvature region, and achieve better roll-out accuracy than the ablation without remeshing and baselines. we see that our LAMP outperforms both baselines and the no-remeshing ablation. Specifically, LAMP outper- forms the strong baseline of "MeshGraapNNets GT remeshing". This shows that LAMP can fur- ther improve upon MeshGraphNets with ground-truth remeshing to learn a better remeshing policy, allowing the evolution model to evolve the system in a more faithful way. Furthermore, the "Mesh- GraphNets + heuristic remeshing" baseline has a larger error, showing that this intuitive baseline is suboptimal. Finally, LAMP outperforms its ablation without remeshing, showing the necessity of remeshing which can significantly reduce the prediction error. Additional details of the experiments given in Appendix B.3 In Fig. 4 and Fig. g in Appendix C.2
that LAMP learns to add more mesh onto the more dynamic regions near to the Tolding part (with high curvature), showing LAMP's ability to assign computation the most needed region.
CONCLUSION
In this work, we have introduced LAMP, the first fully deep learning-based surrogate model that jointly learns the evolution of physical system and optimizes assigning the computation to the most dynamic regions. In ID and 2D datasets, we show that our method able to adaptively perform refinement coarsening actions, which improves long-ten tengtermmat prediction error than strong baselines of deep saaming-based surrogate models. We hope our method provides a useful tool for more efficient and accurate simulation of physical systems.

---

Published as a conference paper at ICLR 2023
6 ACKNOWLEDGEMENT
We thank lan Fischer and Xiang Fu for discussions and for providing feedback on our manuscript. We also gratefully acknowledge the support of DARPA under Nos. HR00112110039 (TAMI, N66001 1924033 (MCS); ARO under Nos. 1011NF-11-1-0320 (MURI, W911NF-11-1-017] (DURIP); NSF under Nos. OAC-1835598 (CINES), OAC-1934578 (HDR), CCF-1918940 (Ex- peditions), NIH under No. 3U54HG010426-045 (HuBMAP), Stanford Data Science Initiative, Wu Tsai Neurosciences Institute, Amazon, Docomo, GSK, Hitachi, Intel, JPMorgan Chase, Juniper Networks, KDDI, NEC, and Toshiba.
The content solely the responsibility of the authors and does not necessarily represent the official views of the funding entities.
REFERENCES
Michael Athanasopoulos, Hassan Ugail, and Gabriela González Castro. Parametric design of aircraft geometry using partial differential equations. Advances in Engineering Software, 40(7):479-486, 2009.
Yohai Bar-Sinai, Stephan Hoyer, Jason Hickey, and Michael P Brenner. Learning data-driven dis- cretizations for partial differential equations. Proceedings of the National Academy of Sciences, 116(31):15344 2019.
Jean-Paul Berrut and Lloyd N. Trefethen. Barycentric lagrange interpolation. SIAM Rev., 46:501- 517,20 2004.
Johannes Brandstetter, Daniel E. Worrall, and Max Welling. Message passing neural PDE solvers. In International Conference on Learning Representations, 2022. /ttptppps///penreviinn
Francesco Carpanese. Development of free-boundary equilibrium and transport solvers for simula- tion and real-time interpretation of tokamak experiments. Technical report, EPFL, 2021.
Jakub Cerveny, Veselin Dobrev, and Tzanio Kolev. Nonconforming mesh refinement for high-order finite elements. SIAM Journal on Scientific Computing, 41(4):C377-C33 2019.
Richard Courant, Kurt Friedrichs, and Hans Lewy. On the partial difference equations of mathemat- ical physics, IBM journal of Research and Development, 11(2):215-234, 1967.
Stefan Elfwing, Eiji Uchibe, and Kenji Doya. Sigmoid linear units for neural network function approximation in reinforcement learning. Neural Networks, 107:3-11, 2018.
Christophe Geuzaine and Jean-François Remacle. Gmsh: A 3-d finite element mesh generator with built-in pre- and post-processing facilities. International Journal for Numerical Methods in Engineering, 79(1) 1) 1309-1331, 2009.
Danijar Hafner, Timothy P Lillicrap, Mohammad Norouzi, and Jimmy Ba. Mastering atari with discrete world models. In International Conference Learning Representations, 2021. URL https: https://opennev/ eww net www.eeee/eorummiddtteeoo.o foorum?id=00abbaee
Xu Han, Han Gao, Tobias Pfaff, Jian-Xun Wang, and Liping Liu. Predicting physics in mesh- reduced space with temporal attention. In International Conference on Learning Representations, 2022.
Julian Kates Hares-H Alexey Svyatkovskiy, and William Tang. Predicting disruptive instabilities in controlled fusion plasmas through deep learning. Nature, 568(7753):526 2019.
Dmitrii Kochkov, Jamie A Smith, Ayya Alieva, Qing Wang, Michael P Brenner, and Stephan Hoyer. Machine saaming--cceleratee computational fluid dynamics. Proceedings of the National Academy of Sciences, 118(21). 2021.
Tony Lelievre and Gabriel Stoltz. Partial differential equations and stochastic methods in molecular dynamics. Acta Numerica, 25:681-888 2016.
10

---

Published as a conference paper at ICLR 2023
Zongyi Li, Nikola Borislavov Kovachki, Kamyar Azizzadenesheli, Burigede liu, Kaushik Bhat- tacharya, Andrew Stuart, and Anima Anandkumar, Fourier neural operator for parametric partial differential equations. In International Conference on Learning Representations, 2021. URL
pettps://openreeee ew net forum?
Peter Lynch. The origins of computer weather prediction and climate modeling. Journal of compu- tational physics. 227(7):3431-3444 2008.
Sharanya Majumdar, Juanzhen Sun, Brian Golding, Paul Joe, Jimy Dudhia, Olivier Caumont, Krushna Chandra Gouda, Peter Steinle, Béatrice Vincendon, Jianjie Wang, et al. Multiscale forecasting of high-impact weather: current status and future challenges. Bulletin of the American Meteorological Sociery, 102(3):E635-EGG 2021.
Rahul Narain, Armin Samii, and James F O'brien. Adaptive anisotropic remeshing for cloth simu- lation. ACM transactions on graphics (TOG), 3166):1-10, 2012.
Tobias Pfaff, Meire Fortunato, Alvaro Sanchez-Gonzalez, and Peter W. Battaglia. Learning mesh- based simulation with graph networks. In International Conference on Learning Representations, 2021.
Alvaro Sanchez, Dmitrii Kochkov, Jamie Alexander Smith, Michael Brenner, Peter Battaglia, and Tobias Joachim Pfaff. Learning latent field dynamics of PDEs. Advances in Neural Information Processing Systems, 2020.
Alvaro Sanchez-Coonalez,, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovee, and Peter Battaglia. Learning to simulate complex physics with graph networks. In International Confer- ence on Machine Learning, pp. 8459-8468. PMLR, 2020.
NJ Sircombe, TD Arber, and RO Dendy. Kinetic effects in laser-plasma coupling: Vlasov theory and computations. In Journal de Physique IV (Proceedings), volume 133, pp. 277-281. EDP sciences, 2006.
Halil Mete Soner, Wolfgang Bangerth, Rolf Rannacher, Hans Foellmer, and LCG Rogers. Adaptive finite element methods for differential equations. Springer Science & Business Media, 2003.
Richard Sutton, David McAllester, Satinder Singh, and Yishay Mansour. Policy gradient meth- ods for reinforcement learning with function approximation. Advances in neural information processing systems, 12, 1999.
Kiwon Um, Robert Brand, Yun Raymond Fei, Philipp Holl, and Nils Thuerey, Solver-in-the-lopp: Learning from differentiable physics to interact with iterative pde-solvers. Advances in Neural Information Processing Systems, 33:6111 1-1222, 2020.
Pantelis R Vlachas, Georgios Arampatzis, Caroline Uhler, and Petros Koumoutsakos. Multiscale simulations of complex systems by learning their effective dynamics. Nature Machine Intelli- gence, 4(4):359-366, 2022.
Tailin Wu, Takashi Maruyama, and Jure Leskovec. Learning to accelerate partial differential equa- tions via latent global evolution. Advances neural information processing systems, 36, 2022.
Jiachen Yang, Tarik Dzanic, Brenden Petersen, Jun Kudo. Ketan Mittal, Vladimir Tomov, Jean- Sylvain Camier, Tuo Zhao, Hongyuan Zha, Tzanio Kolev, et al. Reinforcement learning for adaptive mesh refinement. arXiv preprint arXiv:2103.01342, 2021.
Qingqing Zhao, David B. Lindell, and Gordon Wetzstein. Learning to solve pde-constrained inverse problems with graph networks. International Conference on Machine Learning. 2022.
11

---

Published as a conference paper at ICLR 2023
Appendix
A MODEL ARCHITECTURE
Here we detail the architecture of LAMP, complementary Sec. 3.1 This architecture is used throughout all experiment, with just few hyperparameter (e.g., latent dimension, message passing steps) depending on the dimension (1D, 2D) of the problem.
A.1 ARCHITECTURE
In this subsection, we first detail the base architecture that is common among the evolution model f0 the policy network poolicy and value network f fraluc, Then descrite their respective aspects, and explain the benefits of our action representation.
Base architecture. We use MeshGraphNets Ptaff al. (2021) our base architecture, for the evolution model f the policy network foolicy and value network fyalue All three models have an encoder and a processor. For the encoder, we encode both node features and edge features, uplift to latent dimension using MIPs, z.j. 7 For the processor, it consists of N message passing layers. For each message-passing layer, we first update the edge features using current edge features, and connected node features, Z,y ((c)++1 MLP (E z(")m, (("))), then we update the node features
using current node feature and connected edge features, Z, (0)++1 MLP(" (z!"),, Ej Zig I. Depending on the models and their intended functions, different models have different modules for predicting the output, described as follows.
Evolution model. For the evolution model, the output is each node, and uses the last latent vector on the node, feeds into decoder, to predict the output 1 z(2)N (See Eq. the next time step &
Policy network and value network. Both folliey and fralue shares the same processor f pmmesssor which has message-passing layers. The final node feature is appended with 3 for the controllabil- ity. The spalicy takes the encoded graph as input and consist of two parts a global mean pooling is used to obtain the global latent representation of the whole graph, which is then feed into MLP(K) followed by action specific linear layer to predict the probability distribution for different number of actions should be performed; an action specific MLP(a) is applied on each edge to predict the probability of certain action (i.e., split, coarse) to be applied this edge. The fvalue takes the same encoded graph as input, and perform a global mean pooling to obtain the global latent features for the graph, which is then feed through linear layer predict the accuracy reward, and another linear layer to predict the computation reward, the final predicted value is, v loss + B compute.
A.2 ARCHITECTURAL HYPERPARAMETER USED IN ID AND 2D EXPERIMENTS
Here detail the architectures used in the 1D and 2D experiment. A summary of the hyperparam- eters is also provided in Table 3
A.2.1 ID NONLINEAR PDES
For ID experiment, our evolution model f has N message-passing layers in the processor and latent dimension of 64. It uses the SiLU activation (Elfwing et al. 2018). The shared processor for poliicy and pralue has N = 3 message-passinee layers and latent dimension of 64.
A.2.2 2D BESH-BASED SIMULATION
For fem we set message passing layers for MeshGraphNets (Pfaff et al. 2021 to be 8. We also model our message passing function with MLP having 56 units followed by SiLU activation (Elfwing et al. 2018). Here, we share the same message passing function across all the 8 layers be- cause found in our experiments that sharing the same message passing function achieved better
12

---

Published as a conference paper at ICLR 2023
performance than having independent MLP for each of the layers. The shared processor for spolicy and fvalue has N = 3 message- paassaggg- layers and latent dimension of 64.
B EXPERIMENT DETAILS
In this section, we provide experiment details for 1D and 2D datasets. Firstly, we explain the rea- soning behind several design choices of LAMP and their benefits. Then we provide the training procedure summary and hyperparameter table in Appendix B.1] followed by specific training details for ID (Appendix [ and 2D (Appendix B.3) Finally, we detail the baselines Appendix [B44]
Use of r' as value target. Different from typical RL learning scenario (computer games or roboties) where the episode always has an end and the reward bounded, here in physical simulations, there are two distinct characteristics as follows. (I) The rollout can be performed infinite time steps into the future, (2) as the rollout continues, at some point the error between predicted state and ground- truth state will diverge, so the error is not bounded. Based these two characteristics, a value target based on the error for infinite horizon (e.g., the one used in Dreamer v2 (Hafner et al.) 2021) does not make sense, since the error will not be bounded. In experiment, phenomena, which both the value target and value prediction continue to increase indefinitely. Thus, we use the average reward in the S step rollout as the value target, which measures the error and computation improvement within the rollout window we care about and proves to be much more stable.
also observe similar
Benefit of our action space definition. we have provided the description of action representation in Section our definition of action space in Section 3.I Compared an independent sampling on each edge, the above design of action space has the following benefits:
The action space reduces from 2 to Nedge" Ku where Nedge is the number of edges. In the case of Nedge 1000 and mmma 10 < Nedge. the difference in action space dimensionality is significant, e.g., 2000 10000 vs. 1000 1000 Therefore, it is easier to credit assign the reward to appropriate action, with a smaller space of action.
Compared with each edge performing action independently, now only K < Kmmax actions of refinement or coarsening can be performed. Therefore, it will need to focus on a few actions that can best improve the objective.
The sampling of K will also make the policy more "controllable", since now the K is explicitly dependent on the 3, and learning how many refinement or coarsening action to take depending on 3 is much easier than figuring out which concrete independent actions to take.
B.1 TRAINING PROCEDURE SUMMARY
Here provide the training procedure for learning the evolution model and the policy. There two stages of training. The first stage is pre-training the evolution model alone without remeshing, and the second stage alternatively learning the policy with RL and finetuning the evolution model. The detailed hyperparameter table for ID and 2D experiments is provided in Table 3 our models on an NVIDIA A100 80GB GPU.
We train all
Pre-training. In the pre- pre-tranning stage, the evolution model is trained without remeshing, and the loss is computed by rolling out the evolution model for S steps, and the loss given by loss (1-step loss) x 1 (2-step loss) x 0.1 + + (S-step loss) x 0.1 (the number S is provided in Table 3.. We use smaller weight for later steps, so that the training is more stable (since at the beginning of training, the evolution model can have large error, having too much weight later steps could result in large eиrог and make the training less stable). The pre-training lasts for certain number of epochs (see Table before proceeding to the next stage.
Joint training of policy and evolution model. In this stage, the actor-critic and the evolution model trained in an alternative fashion. Specifically, in the policy-leaming phase, the evolution model is frozen, and the actor-critic learned via reinforcement learning (see "learning the policy" part of Sec. 3.2h for Joolicy steps, and in the evolution-leaming phase, the actor-critic is frozen, and the
13

---

Published as a conference paper at ICLR 2023
evolution model is learned according the "learning evolution" part of Sec. These two phases proceed alternatively.
3.2 for Jem steps.
The reasoning behind using alternating training strategy for actor-critic and evolution is follows. When learning the actor-critic, the return for the RL the expected reward based on the current pol- icy and evolution model. If at the same time the evolution model is also optimized together, then the reward function will always be changing, which will likely make learning the policy harder. There- fore, we adopt the alternating training strategy, which is also widely used in many other applications, such as in GAN training.
In the following subsections, detail the action space and specific settings for ID and 2D.
Table 3: Hyperparameters used for model architecture and training.
Hyperparameter name
1D dataset
2D dataset
Hyperpurameters for model architecture:
Temporal bundling steps
25
f Latent size
64
56
f Activation function
SiLU
SiLU
revo; Encoder MLP number of layers
4
:
Processor number of message-passing layers
8
policy, Latent size
64
56
Buliyy, Activation function
ELU
ELU
Bolicy, Encoder MI.P number of layers
2
policy, Processor number message- -assgggg--aiigggggg layers
3
1 ppalcy, (LP( MLP number of layers
2
pullic, MLP(k), Activation function
ELU
ELU
/olley, MLP((a); MLP number of layers
3
f policy, MLP(a); Activation function
ELU
ELU
Hyperparameters for training:
sampling range B Loss function
0, 0,0.5
(O)
MSE
L2
as for s = 2, ... (Eq.
policy
10
[1,1,
(1111
d for 1,2,... (Eq. 10)
11,1,1,..
(1.1.1
Number of epochs for pre-training evolution model
50
100
Number of rollout steps S to for multi-step loss during pre-training
1
Number of epochs for joint training of actor-critic and evolution model
30
30
jpolicy, # of steps for updating the actor-critic during joint training
200
200
Jove # of steps for updating the evolution model during joint training
100
100
Batch size
128
64
Evolution model learning rate for pre- gre-training
10-3
10-3
Evolution model learning rate during policy learning
10-4
10 10-4
Value network learning rate
10
10 10-4
Policy network learning rate
10
5 X 10-4
Optimizer
Adam
Adam
Coefficient value loss
0.5
0.5
Kmax, Maximum number of actions for coarsen refine
20
20
Maximum gradient norm
20
Optimizer scheduler
cosine
cosine
Input noise amplitude
10-2
S: Horizon
Weight decay
0
y.: Entropy coefficient
10 10-2
2 x 10-2
14

---

Published as a conference paper at ICLR 2023
B.2 ID NONLINEAR PDES
The action space for ID problem is composed of split and coarsen actions. The coarse action is initially defined on all edges, which then sampled based on the predicted number of coarsening actions, and probability of each edge to be coarsened. Among those sampled edges, if two edges share a common vertex, only the rightmost one will be coarsened.
During pre-training, to let the evolution model adapt to the varying size of the mesh, we perform random vertex dropout, where we randomly sample 10% the minibatch to perform dropout, and if a minibatch is selected for node dropout, for each example, randomly drop 0-30% of the nodes in the mesh
Here the interpolation giuterp (in Eq. uses barycentric interpolation (Berrut & Trefethen 2004 where during refinement, the value of the node feature for the newly added node is linear combi- nation of its neighbors' node features, depending the coordinates of the newly-added node and the neighboring nodes.
B.3 2D MESHI-BASED SIMULATION
In this subsection, we provide details on definition of remeshing actions, invalid remeshing action, how to generate 2d mesh data based on oarain et al. (2012) well as how to pre-train the evolution model on generated data, and the interpolation method to remedy inconsistency between vertex configurations of different meshes.
Action space. There are three kinds of remeshing operations defined in the 2D mesh simulation: split, flip, and coarsen. The action space for RL is defined the product of sets of splitting and coarsening operations (the flipping is automatically performed). Elements of each set indicate edges in mesh and the policy function chooses up Kmmax of the elements edges split coarsen. The reason why the flip action is not an action of RL is because we flip all edges satisfying some condition (will be explained in the following). The rest of this paragraph provides details respec- tive remeshing actions. Split action in 2D) case can be performed on any edges that are shared with two triangular faces in a mesh and also the boundary edges of the mesh. The split action results in 4 triangles (Fig. Bap. Flip operation is also performed on edges shared with two faces, but also requires some additional condition, that is when sum of angles vertices located at opposite side of edges is greater than и: see also Fig Fig[5b] In our remeshing function, all edges satisfying the condition are flipped, which is the reason why flip operation not a component of the action space for RL. Finally, coarsening action has relatively strong conditions. One condition is that one of the source or target nodes a coarsened edge needs to be degree and another condition is that all the faces connected to the node of degree 4 needs have acute angles except angles around the node. See also Fig. 5c We filter the sampled actions from folliay based on aforementioned conditions get sets of valid edges to split and coarse.
to,eh,ze,ed Z0,4f.4g.Ah <z
La <
(a) Split action.
(b) Flip action.
(c) Coarsen action.
Figure 5: Illustration of split, flip and coarsen actions. The actions are performed edges.
Invalid remeshing. described Section 3.1 two edges on the same face of mesh cannot be refined at the same time, nor can they be both coarsened. This is because by doing so we may have an invalid mesh with some non-triangular faces such as quadrilaterals. We can give such an example also Fig. 6 for reference. Suppose that we have triangular face ABC and we split edges AB and AC. When we denote the midpoints of AB and AC by and E, we have new edges DC and EB. If we denote the intersection of DC and EB by F, will have quadrilateral ADFE, which violates the requirement that all faces must triangles. order to avoid this situation, remeshing and coarsening action only be performed up edge of every face.
as follows;
15

---

Published as a conference paper at ICLR 2023
A
B
C
B
C
Figure 6: Invalid split action on edges. Splitting two edges in same triangular face the same time gives a quadrilateral.
T=0
T=10
T=20
T=30
T=40
Figure 7: Part of trajectories generated with different configurations, As the time goes, finer trian- gular faces are added to high-curvature regions in meshes.
Generating data. To generate ground-trute touth data, use a 2D triangular mesh-based AMR simula- tor Narain et al. (2112). This simulator adopts adaptive anisotropic kernel method to automatically conform to the geometric and dynamic detail of the simulated cloth: see also Fig. 7 our ex- periment, each trajectory consists of 325 meshes (excluding initial mesh.) Each mesh consists of vertices and faces and every vertex equipped with its 2D coordinates as well as 3D world coordi- nates. Time frame between two consecutive meshes are set to be 0.04. The edge length was set to range between 0.01 and 0.2. Note that decision on respective remeshing actions is made based on the 2D coordinates.
For training and test dataset, we generate 1050 configurations specifying direction and magnitude of forces applied to 4 corners of meshes, and generate 1000 trajectories for training data and use 50 trajectories as test data based on the generated configurations. When training our evolution model, downsample data by half of the original data; we use every other meshes starting from initial mesh in each trajectory. The reason of downsampling is that we observed that cumulative RMSE over rollout with model trained with full trajectories blew up after iteration exceeded 160 steps.
Noted that all dataset are pre-generated and will be loaded during the training, so that no ground- truth solver is needed during the training of LAMP.
Pre-training of evolution model. We model our evolution function f with MeshGraphNets (Pfaff al. 202I). The input of the model adopts graph representation where vertex is equipped with 3D velocity computed from mesh information at both current and past time steps, and feature for an edge consists of relative distance and its magnitude of boundary vertices of the edge. Since mesh topology varies during the forward iteration, we perform barycentric interpolation on the mesh at past time step to get interpolated vertex coordinates corresponding to vertices at current time step.
When evaluating our model, we use rollout RMSF, taking the mean for all spatial coordinates, all mesh nodes, all steps each trajectory, and all 50 trajectories the test dataset. The rollout RMSE achieved 4.45 10-2 with our best parameter setting. We found that adding noise helped to improve its performance; we added the noise with scale 0.01 to vertex coordinates.
Interpolation. Since may have different mesh topology at each time step in trajectory, it is not possible to simply compare node features at one time step with those at another time steps or even at the same time step if the mesh to compare is in different trajectory. When compare node features on different meshes, we perform barycentric interpolation (Berrut & Trefethen) 2004).. For velocity in 2D simulation used as the input of the evolution model, interpolate mesh time step
16

---

Published as a conference paper at ICLR 2023
t - into mesh and take the difference between them. To compute the rollout enror metries, we always interpolate the predicted mesh to the ground-trum mesh at each step, and compute the metries in the ground-truie truth mesh.
B.4 BASELINES
Here we provide additional details on the baselines used in 2D mesh- based simulation. All the baselines use pre-trained evolution function fg as part of the respective forward models. In the following, we mainly give details functions responsible for choosing edges to split and coarsen which correspond the policy function foolicy in LAMP's forward model.
MeshGraphNets + heuristic remeshing. At each step, instead of having foaliey infer probability on edges to split and coarsen, we compute local curvature on edges of the mesh and use the curvature filter out edges to split. Here, the local curvature on an edge defined as the angle made by two unweighted normal vectors on boundary nodes of the edge (the normal vector on nodes is defined as mean normal vectors on faces surrounding the nodes). When we filter out edges in the mesh, we first choose edges with curvature exceeding pre-defined threshold, which is set to be 0.1 in the experiment. We next check that after splitting, the edges are not shorter than a pre-defined minimum length, which is set to be 0.04, to avoid having exceedingly small faces. Edges violating either of these criteria are not chosen as edges to split.
MeshGraphNets + GT remeshing. In this baseline, meshes provided by the classical solver as the mesh configuration of predicted meshes. Specifically, after having f predict mesh at the next time step, interpolate the predicted mesh into the ground-truth mesh We generate all the ground-truth meshes with the same initial condition as LAMP's rollout experiment.
the mesh configuration of ground-truth
LAMP (no remeshing). and we just recursively apply fø to evolve meshes. Therefore, mesh topology of all meshes in trajectory is isomorphic.
This baseline does not involve any functions responsible for remeshing
C ADDITIONAL RESULT VISUALIZATION
C.I ID NONLINEAR PDES
In this section, we provide additional randomly sampled results for the 1D nonlinear PDE experi- ment, shown in Fig. 8 We see that similar to Fig- 2 our LAMP is able to add more vertices to the locations with more dynamicity, while remove more vertices at more static regions. Moreover, with increasing that emphasizes more on reducing computational cost, LAMP splits less and coarsens more.
C.2 2D MESH BASED SIMULATION
In this section, provide additional randomly sampled results for the 2D mesh-based simulation, as shown in Fig. g We see that our LAMP (fifth column) learns to add more edges to locations with higher curvature, resulting better rollout performance than with no remeshing.
17

---

Published as a conference paper at ICLR 2023
Ours, B 0.1
Ours B 0.2
Ours B 0.7
Uniform
Figure 8: Additional example rollout results with different 3 of our LAMP on ID nonlinear PDEs with initial state on 50 vertices which uniformly downsampled from the 100 vertices. The rollout performed over 200 time steps, where different color denotes the system's state at different time. The upper red dots and lower blue dots shows the added and removed nodes the mesh comparing the end and the initial mesh.
18

---

Published as a conference paper at ICLR 2023
Initial state
LAMP (no remeshing)
MashGraphNets- remeshing
MeshGraphNetts houristic remeshing
LAMP (ours)
Ground truth
Figure 9: Additional example rollout results for 2D paper folding, at t = 20. We see that our LAMP (fifth column) learns to add more edges to locations with higher curvature, and learns coarsen the flat region (third and fourth row of "LAMP (ours)", where we see coarsening in the middle of meshes), resulting in better rollout performance than with remeshing and other baselines.
19


Reviews:
[{"review_id": "zAoBgYWXYc", "reviewer": "Reviewer_vMEa", "summary": "", "questions": "", "limitations": "", "rating": 8, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "This paper proposes uses an actor-critic for adapting the simulation mesh, specifically to add or collapse edges. The approach explicitly makes a trade-off between error and computational cost, allowing to tune it at test time.", "summary_of_the_review": "Overall, learning how to modify the mesh in an unsupervised way using RL makes a lot of sense. It allows to 1) increase the simulation accuracy by adding vertices to the part of the cloth with high curvature 2) save computation time by removing vertices from the mesh with low curvature 3) unlike the previous MeshGraphNet approach, LAMP does not require to have the re-meshing sizing field from the ground-truth simulator, which is hard to obtain. \n\nHowever, it will be helpful to have more insight in the choice of K^max and how the required number of coarsening/refinement steps is needed for different mesh sizes. It is also concerning that the approach adds only 3-4 vertices on average and does not add new vertices to the mesh with 100 nodes. Also, Figure 4 shows that the approach does not add the edges to the parts of the cloth with the highest curvature. It would be great to get author’s insights on why the might be the case. ~I am giving borderline accept, but willing to increase to accept if the authors demonstrate the ability to scale to meshes with >100 nodes and clarify why so few vertices need  to be added to the mesh.~\n\nEDIT: the authors addressed all my concerns about scalability, provided more examples and explanation how the edges are refined/coarsened and added a relevant baseline with the MeshGraphNet. The updated version of the paper is convincing and provides value to the learning simulation community. I have increased the score to 8 (accept).\n", "strength_and_weaknesses": "\n**Strengths**\n\nThe main advantage of the proposed approach is being to trained the re-meshing procedure in an unsupervised way, while the previous approach requires explicit supervision on the sizing field provided by the simulator or estimated (assuming that the GT simulations include re-meshing). The unsupervised approach can be particularly advantageous on the real data, where the information about ground-truth re-meshing is not available.\n\n**Weaknesses**\n\n1. Choice of K^max and evaluation on larger experiments.  If my understanding is correct, the model performs up to K^max actions of refinement and coarsening at each step of the simulation. Intuitively, K^max should be higher on the more fine mesh, as we might need to modify more edges. How was K^max chosen?\n\n    The current paper evaluated the simulations only up to 100 nodes, while the previous MeshGraphNet paper demonstrated the results on up to ~5000 nodes. Do the authors think that the approach can scale to this number of nodes. How do you expect the choice of K^max to change, if we increase the number of nodes to 5000? Given that the action space is N_edge^K, do the authors think that it would be feasible to train the method with such a large action space?\n\n\n2. The choice of baselines and comparison to the MeshGraphNet+remeshing\nI am surprised with the choice of the baselines. The cloth mesh can be naturally represented as a graph, but the paper provides only one \none graph-net baseline (LAMP with not re-meshing). Using the CNN as a baseline enforces that the initial mesh should be represented as a grid, which is quite limiting.\n\n    Also, the paper does not provide the comparison to the previous MeshGraphNet method *with re-meshing*, as it is the only other method that uses re-meshing. It is not an entirely fair comparison, as MeshGraphNets use supervision on re-meshing, but it would be useful to compare which parts of the mesh are modified, and how many edges are added/collapsed between the two approaches.  \n\n**A few questions**\n\n1. It seems that the re-meshing process only adds 3-4 vertices on average (Table 1). I am surprised that it results in such a big change in MSE for 30 and 50 initial edges. Can the authors explain why this might be the case? Also, do you have a sense of how many edges were actually changed through re-meshing? For example, it is possible that some edges were added/collapsed, but the average number of vertices stayed the same.\n\n2. Figure 4: LAMP seems to add new edges to a different regions than the ground-truth. Specifically, GT adds more edges on the cloth bending with the highest curvature, while LAMP adds the edges closer to the centre of the cloth. Can the authors provide the intuition why this might be the case and, perhaps, how to remedy this?\n\n3. The RL-based approaches tend to require a lot of training episodes, especially if several edges are modified at each time step. How many episodes are roughly needed to train the policy and the value function. Also, is the model trained together with f_evo? Do you have a sense how the required number of episodes changes with the choice of K^max?\n", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "4: All of the claims and statements are well-supported and correct.", "technical_novelty_and_significance": "4: The contributions are significant, and do not exist in prior works.", "empirical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work."}, "extra_text": {}}, {"review_id": "diMRLEixBi", "reviewer": "Reviewer_WPia", "summary": "", "questions": "", "limitations": "", "rating": 5, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "The paper proposes to jointly learn the dynamics as well as a remeshing scheme for simulation based on discretized (triangular mesh) space. To consider both the simulation accuracy and the computational cost, this problem is formulated as a multi-objective optimization. Two sets of graph neural networks are used for learning the forward evolution and the remeshing policy, respectively. Experiments show that the relative importance of simulation error vs. computational cost can be adjusted by choosing different weight values during the training.", "summary_of_the_review": "In summary, I think this paper is tackling an important problem in an interesting way. However, the experiments are not sufficient to really validate the advantage of their method. I hope the users can add more test cases and compare their method with MeshGraphNet. The composition of this paper can also be improved.", "strength_and_weaknesses": "Strength\nThis method models the adaptive mesh simulation as a multi-objective optimize and provides users with a convenient way to modify the relative importance of computational cost and simulation fidelity.\n\nMoreover, the way they handle remeshing and treat the computational cost as a objective function is interesting. It could probably be generalized to other relative tasks other than simulation, e.g. inverse rendering with adaptive remsheing.\n\nWeakness\nFirst, the keyword `multi-scale` in the title seems not very appropriate to me. Even though this method can adaptively change the resolution in some local areas, all the dynamics are governed by the same evolution network. There are no multiscale or hierarchical structures as I can see. Moreover, according to the experiment results, the number of vertices does not change a lot (33->37.6, 50->53.2, 100->100.0, and 81.0->97.9). It is rather refinements than multi-scale physics.\n\nThe biggest concern for me is the experiment part. MeshGraphNet is its backbone and it also should be an important baseline, since MeshGraphNet itself can perform remeshing. However, it is not compared against MeshGraphNet. \n\nMoreover, the paper also mentioned that it wants to verify ‘Can LAMP improve the Pareto frontier of Error vs. Computation, compared to state-of-the-art deep learning surrogate models’. But I did not find this experiment. Figure 3 is not referred to in the main text. I did not understand what does this figure mean. If possible, I’d like to see whether the Pareto frontier of this method can cover the performance of MeshGraphNet.\n", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.", "technical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.", "empirical_novelty_and_significance": "2: The contributions are only marginally significant or novel."}, "extra_text": {}}, {"review_id": "Ixr4annrjRZ", "reviewer": "Reviewer_tR71", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "The paper learns a policy to automatically re-mesh the current mesh used in physics simulation, so that delicate regions where rich dynamics happens can leverage more computational power. It uses reinforcement learning to train the policy end-to-end, with the reward being a combination of simulation accuracy and speed. The resulting method, called LAMP, is evaluated on simple 1D PDE and 2D mesh-based paper simulation. ", "summary_of_the_review": "Overall due to these important limitations, I cannot recommend acceptance.  \n\n======\n\nUPDATE: the authors have made substantial efforts and addressed most of my concerns. I really appreciate. Thanks! \n\nAs a result, I raised the score to 6 and will not object acceptance of this paper in ICLR. ", "strength_and_weaknesses": "Strength\n1. The paper is well-written on the high-level and easy to follow. \n2. The idea is straightforward and clearly presented. \n\nWeakness\n1. The paper missed important literatures to compare against. \n2. To further verify the approach, more thorough experiments need to be performed.  \n3. Some important details are missing, which could prevent audience unfamiliar with the literature from fully understanding this paper. \n\n", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.", "technical_novelty_and_significance": "2: The contributions are only marginally significant or novel.", "empirical_novelty_and_significance": "2: The contributions are only marginally significant or novel."}, "extra_text": {}}, {"review_id": "9WjB62yDBK", "reviewer": "Reviewer_mWzR", "summary": "", "questions": "", "limitations": "", "rating": 8, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "Authors propose a novel methodology based on Graph Neural Networks (and reinforcement learning) to predict the evolution of a process of interest. The primary context in which the proposed `LAMP`  (Learning Controllable Adaptive simulation for Multi-scale Physics) model is applied is to forecast the evolution of systems governed by PDEs and on a real-world task of predicting the evolution of deformation of paper with forces acting on it.  Overall, the main novelty of the proposed model is that the model is able to not only forecast the evolution of states of the process of interest, but is also able to adaptively yield fine-grained / coarse-grained predictions as needed based on the inferences made by a learnable adaptive-mesh-refinement policy network (also part of the LAMP pipeline).  The results demonstrate that LAMP yields results superior to powerful state-of-the-art PDE forecasting models. \n\nAfter the authors' responses especially about the ablation study, I am relatively more convinced about the effectiveness about the proposed method and that the proposed method is indeed able to address an important problem of developing ML based surrogates of scientific simulations while also being able to perform adaptive meshing on the domain.", "summary_of_the_review": "The proposed LAMP model is novel as it is able to effectively develop a graph neural network based model for forecasting evolution of non-linear PDE based domains along with adaptive-mesh-refinement as proposed by a learned RL policy (jointly learned with the evolution learning component of the LAMP pipeline).", "strength_and_weaknesses": "## Strengths: \n\nThe paper proposes a novel (LAMP) model which jointly learns to predict the evolution of a process of interest (using graph-neural network based architecture) as well as learns to adaptively refine / coarsen various parts of the network topology (I.e., mesh) of the domain being forecast. The proposed loss functions combining  RL policy learning task and domain evolution learning task are novel and indicated to be effective from the presented results. \n \n\nThe results demonstrate the power of the LAMP model over other state-of-the-art models for forecasting PDE trajectories including the benefit of mesh-refinement which is one of the novel proposals made by the current work. Further, the mesh refinement (measured in Table 1, as Avg. # vertices) does not seem to significantly increase the number of nodes (I.e., the refinement policy seems to be applied systematically without leading to an explosion of the problem complexity). \n \n\nThe problem formulation, especially as a balance between the number of FLOPs (computational cost of refinement / coarsening resulting form the RL policy actions) and long-term prediction error is novel and effective. \n \n\nThe paper is (mostly) clearly written and well organized but for a clear description of the experimental setup. \n\n## Weaknesses: \n\nMy major problem with the paper is the lack of a cohesive / complete discussion of the experimental setup. The proposed modeling pipeline (RL + forecasting using graph neural networks where each of the forecasting and RL based losses further have multiple tasks optimized therein) has a non-trivial organization and many hyperparamteres / steps that are not described in detail. E.g., Eq. 4 the $g^{\\mathrm{interp}}(\\cdot)$ function does not find detailed mention in the discussion. \n \n\nThe paper does not compare with MeshGraphNets [1], which is the base model the paper employs to design its framework. Without this, it is hard to contextualize the degree of improvement of the prediction performance of the proposed framework. Although the current paper makes other contributions (I.e., adaptive-mesh-refinement based on learned policy) it is still important to understand how the evolution performance in the LAMP model fares w.r.t MeshGraphNets which is a closely related model. \n \n\nFurther, without access to the source code, it is non-trivial to fully comprehend the effectiveness of the proposed pipeline with so many moving parts.   \n \n\n## Questions for Authors: \n\n1. How are $\\alpha_s^{\\mathrm{policy}}$, $\\alpha_s^{\\mathbb{I}}$ parameters (Eq. 10) set / learned? \n \n\n2. How sensitive is the proposed model to values of $\\beta$, $\\alpha_s^{\\mathrm{policy}}$, $\\alpha_s^{\\mathbb{I}}$? \n \n\n3. What type of interpolation function is used for $g^{\\mathrm{interp}}(\\cdot)$ ? How many types of interpolations were tried, and which was the most effective? Also, how does the computational cost of $g^{\\mathrm{interp}}(\\cdot)$ figure into the cost of the overall learning model? \n \n\n4. What is the reasoning behind the selection of an alternating strategy to train the evolution and policy losses? \n \n\n5. According to Eq. 9, the $L^{\\mathrm{evo}}_S$ term is comprised of a fine-grained mesh based forecasting loss (second term) and a forecasting loss based on the mesh generated by the RL policy. What would be the effect of decaying the second term I.e., fine-grained mesh based forecasting over the course of model training as this might have significant effects on decrease in computation time of training for large differences between fine-grained / coarse-grained meshes? \n \n \n## References\n1. Pfaff T, Fortunato M, Sanchez-Gonzalez A, Battaglia PW. Learning mesh-based simulation with graph networks. arXiv preprint arXiv:2010.03409. 2020 Oct 7.", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.", "technical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.", "empirical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work."}, "extra_text": {}}]

Author rebuttal:

Decision: Accept: notable-top-25%