Paper · 2020-10-09 · stat.ML, cs.AI, cs.CV, cs.LG
Augmenting Physical Models with Deep Networks for Complex Dynamics Forecasting
APHYNITY splits an ODE or PDE into a physics term with unknown parameters and a neural term, keeping the neural term as small as possible while trajectories still fit. It trains with an adaptively updated multiplier. On reaction-diffusion, damped-wave and pendulum data, incomplete physics plus the neural term reaches author-reported log MSEs close to complete models.
Neural ODEInformed machine learningResidual learningphysics-informed-learninghybrid-modelingdynamics-forecastingparameter-identificationneural-ode
arXivPDFCodeMarkdown18 min read
AI-compiled by claude-haiku-5-5 on 2026-11-12, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.
In plain words
Many systems, such as a swinging pendulum, a wave or a chemical reaction spreading over a surface, follow equations that we know only partly. Our textbook model may leave out friction, a missing reaction term or a damping effect. Pure machine learning can forecast such a system but often fails outside the conditions it was trained on, and a rough physics model is usually wrong in ways that spoil the physical parameters we want to read off it.
APHYNITY combines the two. The known physics stays in the model as a term with a few adjustable parameters, and a neural network adds a second term for whatever the physics cannot explain. The training rule is chosen so that the physics explains as much of the data as it can, and the network is pushed to model only the leftover part. The network is kept as small as possible, which keeps the physical parameters meaningful and helps the model extrapolate.
Training works on whole trajectories: the model is simulated forward from the starting state, and the simulated path is compared with the recorded one.
TL;DR
APHYNITY is a way to train a physics model plus a neural correction so that the correction only covers what the physics misses. The decomposition is unique under mild conditions, and the physical parameters are identified more accurately than with the physics model alone. The paper's results are on three simulated systems, with author-reported numbers. The released code covers only the three incomplete- and complete-physics setups, not every baseline in the paper.
Problem
Forecasting a dynamical system needs an equation for how its state changes over time. A physics model with incomplete terms, such as a frictionless pendulum for a pendulum with damping, leaves a residual that does not vanish §1 fig. 1. Purely data-driven models, such as Neural ODEs, need much data and often do not extrapolate well §1 §4.2. Earlier gray-box and residual approaches either fit the physics and the correction in two separate stages or give no guarantee that the split is well defined §2.
The authors state three goals: forecast accurately, identify the physical parameters correctly, and keep the decomposition interpretable. They assume that the observed trajectories come from an unknown ODE or PDE whose right-hand side belongs to a known family of physics models, with the physical parameters unknown §3.
Method
Setting §3. The system is an autonomous ODE, dX/dt = F(X), over a finite time interval eq. 1. The state X is either a vector (the pendulum) or a field over a spatial domain (the reaction-diffusion and wave systems) §3. The data are trajectories, and the right-hand side F is unknown, but F is assumed to lie in a normed vector space §3.
Decomposition §3.1. The authors write F = F_p + F_a, where F_p is the physical part, which belongs to a known family F_p, and F_a is a data-driven augmentation §3.1. The physical parameters, such as a wave speed, are unknown and are estimated from data together with the network §3.1.
Optimisation problem §3.1 eq. 2. Among all decompositions that reproduce the observed dynamics, choose the one whose augmentation has the smallest norm. The decomposition is then unique when F_p is a Chebyshev set, and the physical part is the metric projection of the true F onto F_p §3.1 (Proposition 1 gives existence for proximinal sets, Proposition 2 uniqueness for Chebyshev sets). The authors' experiments use closed convex families, which are Chebyshev §4.1. Appendix B proves that the constrained problem is equivalent to projecting the data-defined field onto F_p app. B.
Trajectory-based constraint §3.2 eq. 3. Estimating dX/dt by finite differences needs fine sampling and amplifies noise, so the authors constrain integrated trajectories instead. The objective is the norm of F_a, subject to the simulated trajectory, started from the observed first state, matching each observed sample §3.2 eq. 3. The simulation uses a differentiable ODE solver §3.2 app. E. Appendix D argues, with a Grönwall-type bound, that supervising derivatives makes the error grow exponentially in time app. D.
Relaxation and adaptive multiplier §3.3 eq. 4 alg. 1. The constraint is replaced by a Lagrangian relaxation, the norm of F_a plus λ times the trajectory loss L_traj eq. 4. L_traj is the sum, over trajectories and time steps, of the norm of the gap between observed and simulated states §3.3. The multiplier λ starts at λ0 and grows with the trajectory loss, so the constraint is enforced more strongly as training proceeds §3.3. The loop is summarised in Algorithm 1 alg. 1. The authors say a few inner gradient steps per multiplier update are often enough §3.3.
# Forward model: physics plus augmentation [§3.2] [eq. 3]
def rhs(state, theta_p, theta_a):
# F = F_p + F_a, both evaluated at the same state [§3.1] [eq. 1]
return physics(state, theta_p) + augmentation(state, theta_a)
# Integrate from the first observed state on the sample grid, RK4 [§4.1]
def simulate(x0, times, theta_p, theta_a):
return rk4_solve(lambda s: rhs(s, theta_p, theta_a), x0, times)
# Trajectory mismatch, summed over trajectories and time steps [§3.3]
def l_traj(data, times, theta_p, theta_a):
predicted = simulate(data[:, 0], times, theta_p, theta_a)
gap = data - predicted # (N, T, d) with state axes last
return sum(norm(gap)) # norm over state axes, sum over N and T# APHYNITY adaptive constrained optimisation [alg. 1] [§3.3]
# Input: lam_0 >= 0; tau_1 > 0 (step size); tau_2 > 0 (multiplier step)
def aphynity(data, lam_0, tau_1, tau_2, n_epochs, n_iter):
lam = lam_0
for epoch in range(n_epochs):
# Inner gradient steps on the relaxed Lagrangian [§3.3] [eq. 4]
for _ in range(n_iter):
for batch in batches(data):
loss = (
aug_norm(batch, theta_a)
+ lam * l_traj(batch, times, theta_p, theta_a)
)
theta = theta - tau_1 * gradient(loss, theta)
# Multiplier step on the trajectory loss after the inner loop [alg. 1]
# L_traj as defined in [§3.3] sums over all trajectories
lam = lam + tau_2 * l_traj(data, times, theta_p, theta_a)
return theta_p, theta_aNetworks §3.2 app. E. The physical parameters θ_p are low-dimensional, 2 or 3 in the experiments §3.2. For reaction-diffusion and the damped wave, F_a is a three-layer convolutional network with 16 hidden channels app. E.1 app. E.2. For the pendulum, F_a is a multilayer perceptron with three layers of 200 units and ReLU, with a linear output app. E.3. A Neural ODE baseline uses the same network as the entire right-hand side app. E.1 app. E.3.
Physical models §4.1 app. E. Three families are studied. Reaction- diffusion is a two-component FitzHugh-Nagumo-type PDE on a periodic grid §4.1 app. E.1. The damped wave equation has Laplacian and damping terms with wave speed c and damping k §4.1 app. E.2. The damped pendulum has friction α and proper pulsation ω0 §4.1 app. E.3. For each family, the incomplete models leave out some terms or parameters (for example the damping term), and the complete models include them §4.1. The Hamiltonian pendulum model is a conservative alternative §4.1.
Hyperparameters
Values are from the paper's own appendix. "Not stated" means the paper gives no value. Code values are in "Paper vs code".
| Name | Value | Where | Notes |
|---|---|---|---|
| Multiplier init λ0 | 1 (reaction-diffusion); 1 (wave); 1 (pendulum Hamiltonian and Param ODE ω0); 1000 (pendulum Param ODE ω0, α) | app. E.1 app. E.2 app. E.3 | pendulum values from its table |
| Inner steps per epoch N_iter | 1 (reaction-diffusion); 3 (wave); 5 (all pendulum models) | app. E.1 app. E.2 app. E.3 | see alg. 1 |
| Gradient step τ1 | 1e-3 (reaction-diffusion); 1e-4 (wave); 1 (all pendulum models) | app. E.1 app. E.2 app. E.3 | paper calls it a gradient step; code uses Adam, see below |
| Multiplier step τ2 | 1e3 (reaction-diffusion); 1e2 (wave); 0.1 (pendulum Hamiltonian); 10 (pendulum Param ODE ω0); 100 (pendulum Param ODE ω0, α) | app. E.1 app. E.2 app. E.3 | the code uses different values, see "Paper vs code" |
| Integrator | 4th-order Runge-Kutta, fixed step on the sample grid | §4.1 | the data are generated with a different scheme |
| Reaction-diffusion grid | 32 × 32 on [-1, 1]², periodic, 3 × 3 Laplacian | app. E.1 | |
| Reaction-diffusion true parameters | a = 1e-3, b = 5e-3, k = 5e-3 | app. E.1 tab. 1 | |
| Reaction-diffusion data | 1920 sequences: 1600 train/validation, 320 test; 25 predicted steps | app. E.1 | sampling step 0.1 app. E.1 |
| Wave grid | 64 × 64, Neumann boundary, 3 × 3 Laplacian in the model, 5 × 5 in simulation | app. E.2 | |
| Wave true parameters | c = 330, k = 50 | app. E.2 tab. 1 | |
| Wave data | 250 sequences: 200 train, 50 test; sampling step 1e-3 | app. E.2 | |
| Pendulum true parameters | α = 0.2; period T0 = 6 (Table 1 caption) or T0 = 12 (appendix) | tab. 1 app. E.3 | conflict, see Pitfalls |
| Pendulum data | 25 trajectories per split, 40 steps over [0, 20], sampling step 0.5, DOPRI5, Gaussian noise σ = 0.01 | app. E.3 | |
| Pendulum step budget | maximum 5000 steps with early stopping | app. E.3 | |
| Reaction-diffusion and wave network | 3 convolutions, 3 × 3 kernels, 2 → 16 → 16 → 2 channels, ReLU, batch norm without running averages | app. E.1 | the 2-channel output is the derivative |
| Pendulum network | MLP, 3 layers of 200 units, ReLU, linear output | app. E.3 | |
| Batch size, optimiser, learning-rate schedule | not stated | ||
| Physical parameter bounds (a_min, b_min, ...) | not stated (the paper requires positivity only) | §4.1 |
Results
Author-reported, on simulated data where the true parameters are known. Each block compares the data-driven baseline, the incomplete physics model, the same model with APHYNITY, the complete physics model, and its APHYNITY version tab. 1. log MSE is reported as in the paper, with its base not stated. %Err param is the paper's relative parameter error. ‖F_a‖² is the paper's norm of the augmentation. Its normalisation is not defined in the paper §4.2 tab. 1. Bold marks in the source (equivalent best by Student t-test) are omitted.
| Dataset | Method | log MSE | %Err param | ‖F_a‖² |
|---|---|---|---|---|
| Reaction-diffusion | Neural ODE | -3.76 ± 0.02 | n/a | n/a |
| Reaction-diffusion | PredRNN++ | -4.60 ± 0.01 | n/a | n/a |
| Reaction-diffusion | Param PDE (a, b) | -1.26 ± 0.02 | 67.6 | n/a |
| Reaction-diffusion | APHYNITY Param PDE (a, b) | -5.10 ± 0.21 | 2.3 | 67 |
| Reaction-diffusion | Param PDE (a, b, k) | -9.34 ± 0.20 | 0.17 | n/a |
| Reaction-diffusion | APHYNITY Param PDE (a, b, k) | -9.35 ± 0.02 | 0.096 | 1.5e-6 |
| Reaction-diffusion | True PDE | -8.81 ± 0.05 | n/a | n/a |
| Reaction-diffusion | APHYNITY True PDE | -9.17 ± 0.02 | n/a | 1.4e-7 |
| Wave equation | Neural ODE | -2.51 ± 0.29 | n/a | n/a |
| Wave equation | Param PDE (c) | 0.51 ± 0.07 | 10.4 | n/a |
| Wave equation | APHYNITY Param PDE (c) | -4.64 ± 0.25 | 0.31 | 71 |
| Wave equation | Param PDE (c, k) | -4.68 ± 0.55 | 1.38 | n/a |
| Wave equation | APHYNITY Param PDE (c, k) | -6.09 ± 0.28 | 0.70 | 4.54 |
| Wave equation | True PDE | -4.66 ± 0.30 | n/a | n/a |
| Wave equation | APHYNITY True PDE | -5.24 ± 0.45 | n/a | 0.14 |
| Damped pendulum | Neural ODE | -2.84 ± 0.70 | n/a | n/a |
| Damped pendulum | Hamiltonian | -0.35 ± 0.10 | n/a | n/a |
| Damped pendulum | APHYNITY Hamiltonian | -3.97 ± 1.20 | n/a | 623 |
| Damped pendulum | Param ODE (ω0) | -0.14 ± 0.10 | 13.2 | n/a |
| Damped pendulum | Deep Galerkin Method (ω0) | -3.10 ± 0.40 | 22.1 | n/a |
| Damped pendulum | APHYNITY Param ODE (ω0) | -7.86 ± 0.60 | 4.0 | 132 |
| Damped pendulum | Param ODE (ω0, α) | -8.28 ± 0.40 | 0.45 | n/a |
| Damped pendulum | Deep Galerkin Method (ω0, α) | -3.14 ± 0.40 | 7.1 | n/a |
| Damped pendulum | APHYNITY Param ODE (ω0, α) | -8.31 ± 0.30 | 0.39 | 8.5 |
| Damped pendulum | True ODE | -8.58 ± 0.20 | n/a | n/a |
| Damped pendulum | APHYNITY True ODE | -8.44 ± 0.20 | n/a | 2.3 |
Source: tab. 1. The DGM and Hamiltonian rows are the paper's own baselines and are not in the released code.
Headline claims §4.2. On the incomplete models, APHYNITY improves the log MSE by a wide margin over the physics alone and over the Neural ODE in all three families, and comes close to the true equation §4.2. For the parameter errors, the paper reports 2.3% (reaction-diffusion), 0.3% (wave) and 4% (pendulum) for APHYNITY on incomplete models, against 67.6%, 10.4% and above 13% without augmentation §4.2.
Ablation against vanilla augmentation app. F.1. The vanilla scheme learns F = F_p + F_a without the decomposition criterion. Results (author-reported):
| Dataset | Method | log MSE | %Err param | ‖F_a‖² |
|---|---|---|---|---|
| Reaction-diffusion | Param PDE (a, b) with vanilla augmentation | -4.56 ± 0.52 | 8.4 | (7.5 ± 1.4)e1 |
| Reaction-diffusion | APHYNITY Param PDE (a, b) | -5.10 ± 0.21 | 2.3 | (6.7 ± 0.4)e1 |
| Reaction-diffusion | Param PDE (a, b, k) with vanilla augmentation | -8.04 ± 0.03 | 25.4 | (1.5 ± 0.2)e-2 |
| Reaction-diffusion | APHYNITY Param PDE (a, b, k) | -9.35 ± 0.02 | 0.096 | (1.5 ± 0.4)e-6 |
| Reaction-diffusion | True PDE with vanilla augmentation | -8.12 ± 0.05 | n/a | (6.1 ± 2.3)e-4 |
| Reaction-diffusion | APHYNITY True PDE | -9.17 ± 0.02 | n/a | (1.4 ± 0.8)e-7 |
| Wave equation | Param PDE (c) with vanilla augmentation | -3.90 ± 0.27 | 0.51 | 88.66 |
| Wave equation | APHYNITY Param PDE (c) | -4.64 ± 0.25 | 0.31 | 71.0 |
| Wave equation | Param PDE (c, k) with vanilla augmentation | -5.96 ± 0.10 | 0.71 | 25.1 |
| Wave equation | APHYNITY Param PDE (c, k) | -6.09 ± 0.28 | 0.70 | 4.54 |
| Damped pendulum | Hamiltonian with vanilla augmentation | -0.35 ± 0.1 | n/a | 837 ± 117 |
| Damped pendulum | APHYNITY Hamiltonian | -3.97 ± 1.2 | n/a | 623 ± 68 |
| Damped pendulum | Param ODE (ω0) with vanilla augmentation | -7.02 ± 1.7 | 4.5 | 148 ± 49 |
| Damped pendulum | APHYNITY Param ODE (ω0) | -7.86 ± 0.6 | 4.0 | 132 ± 11 |
| Damped pendulum | Param ODE (ω0, α) with vanilla augmentation | -7.60 ± 0.6 | 4.65 | 35.5 ± 6.2 |
| Damped pendulum | APHYNITY Param ODE (ω0, α) | -8.31 ± 0.3 | 0.39 | 8.5 ± 2.0 |
| Damped pendulum | Augmented True ODE with vanilla augmentation | -8.40 ± 0.2 | n/a | 3.4 ± 0.8 |
| Damped pendulum | APHYNITY True ODE | -8.44 ± 0.2 | n/a | 2.3 ± 0.4 |
Source: app. F.1.
Training-scheme ablation app. F.2. Two variants are compared with the full scheme: supervision on finite-difference derivatives, and the same objective without the adaptive multiplier. Selected values: reaction-diffusion Param PDE (a, b) gives log MSE -4.42 (derivatives), -4.55 (non-adaptive) and -5.10 (APHYNITY); the damped wave Param PDE (c) gives -1.16, -2.57 and -4.64; the pendulum Param ODE (ω0, α) gives -2.61, -7.69 and -8.31 app. F.2. The authors read this as support for the trajectory-based, adaptive scheme.
Additional experiments app. G. With per-sequence parameters, the reaction-diffusion APHYNITY model reaches log MSE -4.32 against -1.32 for Param PDE (a, b), with the error on a falling from 55.6% to 11.8% and on b from 54.1% to 18.7% app. G.1. For the wave with varying c, APHYNITY Param PDE (c) reaches -4.51 with a 3.2% error on c, against -1.32 and 23.9% without augmentation app. G.2. For the pendulum with varying T0 and α, APHYNITY Param ODE (ω0, α) reaches -6.22 against -5.71 without augmentation, and N-Beats reaches -4.57 app. G.3. These extra runs use a recurrent parameter encoder, which is not in the released code.
Paper vs code
Checked against the official repository, MIT-licensed (commit 03d1f9618b344635030deb687e24745d58b4e51c), at the code paths below.
- Hyperparameters differ from the paper. The code uses one configuration per dataset and one for all pendulum models. Reaction-diffusion: λ0 = 1, τ1 = 1e-3, τ2 = 1e-3, N_iter = 1 train_aphynity.py. Wave: λ0 = 1, τ1 = 1e-4, τ2 = 1e-3, N_iter = 3 train_aphynity.py. Pendulum: λ0 = 1, τ1 = 1e-3, τ2 = 1, N_iter = 5 train_aphynity.py. The paper gives τ2 = 1e3 app. E.1, 1e2 app. E.2 and 0.1, 10, 100 by pendulum model app. E.3, and λ0 = 1000 for Param ODE (ω0, α) app. E.3. The paper's and code's τ2 values disagree by several orders of magnitude.
- Optimiser. The paper's update is a gradient step with size τ1 alg. 1. The code uses Adam with learning rate τ1 and default betas train_aphynity.py.
- When λ is updated. The paper updates λ once per epoch, after the N_iter inner loops alg. 1. The code updates λ after every mini-batch, using the loss from the last inner step, computed before that step's update experiments.py.
- Trajectory loss. The paper's L_traj is a sum of norms §3.3. The code uses PyTorch's MSELoss, which averages over all elements and includes the t = 0 state, which is matched exactly [code: experiments.py#L173, experiments.py#L192] forecasters.py.
- Augmentation penalty. The paper's penalty is the L2 norm of F_a over the training data §3.2 app. F.1. The code, for reaction-diffusion and wave, takes the squared channel norm at each point, then averages over batch, time and space experiments.py. For the pendulum it uses the squared ratio of the channel norm to the state norm, plus a small epsilon, which is not in the paper experiments.py experiments.py.
- Solver. The paper's appendix says the solver uses the adjoint method
app. E. The code imports the adjoint solver but calls the plain
odeint, which backpropagates through the solver steps [code: forecasters.py#L2] forecasters.py. The step method is RK4 forecasters.py. - Model selection on the test set. The paper refers to a validation set and early stopping app. E. The code has no validation split. It runs up to 50000 epochs and keeps the checkpoint with the lowest test loss train_aphynity.py experiments.py.
- Parameter parametrisation. Reaction-diffusion a, b, k are sigmoid(x) × 1e-2, initialised from x = -2 networks.py networks.py networks.py. The paper calls them plain positive trainable parameters §3.2. The wave c is 100 × c_org, with c_org initialised at 3.6 (c = 360), and k is unconstrained with initial value 45 networks.py networks.py. The pendulum stores ω0², not ω0, and α, both unconstrained and initialised at 0.2 and 0.1 networks.py networks.py.
- Pendulum parameter error. The relative error in the code is computed on ω0², not ω0, and reported as a fraction, not a percentage experiments.py pendulum.py.
- Pendulum period. The default data uses (2π/6)², so T0 = 6 [code: datasets/pendulum.py#L12]. This matches the Table 1 caption and conflicts with the appendix's T0 = 12 tab. 1 app. E.3.
- Pendulum data. The integrator is DOP853 pendulum.py, where the paper says DOPRI5 app. E.3. The code adds no observation noise, while the paper states σ = 0.01 app. E.3. Initial conditions are random points on a circle of radius uniform in [1.3, 2.3] pendulum.py, which the paper does not state. There are 25 train and 25 test trajectories and no validation split [code: datasets/init.py#L94-L110].
- Pendulum augmentation. The MLP is initialised with orthogonal weights of gain 0.2 train_aphynity.py. This is not in the paper.
- Reaction-diffusion data. The time grid runs from 0 to 3 in steps of 0.1, so 30 states, starting at t = 0 from uniform random fields in [0, 1] [code: datasets/init.py#L9-L22] rd.py rd.py. The paper starts at t = -0.5, has horizon 2.5 and 25 predicted steps app. E.1. The code also simulates with scipy's RK45, not explicit finite differences rd.py app. E.1.
- Wave data. The code simulates one trajectory per split and takes sliding 25-step windows from it, with 225 time steps for training wave.py wave.py wave.py [code: datasets/init.py#L52-L70]. The paper describes 250 independent sequences, each from a Gaussian initial state, over 300 steps app. E.2. The code centres each Gaussian at a random integer point in [20, 40) wave.py, where the paper fixes it at (32, 32) app. E.2. The code divides by the sampled spread, not its square, and uses a minus sign in the exponent wave.py wave.py.
- Wave boundary. The simulation and the model set the Laplacian to zero on the outer cells wave.py networks.py. This is not the Neumann condition the paper states app. E.2.
- Wave model. The model's Laplacian has no 1/dx² factor, because dx = 1 wave.py networks.py.
- Batch normalisation. The ConvNet uses batch norm without running averages networks.py networks.py. This matches the paper app. E.1, but at test time the statistics still come from the batch, so results depend on batch composition.
- Network. The MLP has two hidden layers of 200 units plus a linear output networks.py. The paper's "3 layers of 200 neurons" can be read either way app. E.3. The last ConvNet layer has a bias, while the first two do not networks.py networks.py.
- Missing from the release. The repository has no Hamiltonian model, no Deep
Galerkin Method, no PredRNN++, no N-Beats, no recurrent parameter encoder and
no varying-parameter setting. The
--phy noneoption, which would give the Neural ODE baseline, has no branch in any dataset setup, so it appears to fail as written train_aphynity.py train_aphynity.py train_aphynity.py. I did not run it. - Released defaults. The data batch size is 64 for reaction-diffusion and wave, and 25 for the pendulum [code: datasets/init.py#L9] [code: datasets/init.py#L52] [code: datasets/init.py#L94].
Pitfalls
- Pendulum period is inconsistent. Table 1 says T0 = 6 and the appendix says T0 = 12 tab. 1 app. E.3. The released code uses T0 = 6 pendulum.py. Decide which one you are reproducing before comparing numbers.
- The τ2 values are inconsistent. The paper's τ2 values are 1e3, 1e2 and 0.1–100 app. E; the code uses 1e-3, 1e-3 and 1 train_aphynity.py train_aphynity.py train_aphynity.py. The multiplier update scales with τ2, so the trajectory of λ depends on which set was used. The paper's hyperparameters alone do not say which set produced its reported runs.
- The λ scale depends on normalisation. The paper's L_traj is a sum of norms, and its augmentation penalty is an L2 norm over the domain. The code uses averages over batch, time and grid. Any choice of λ0 and τ2 therefore transfers only if you use the same normalisation.
- Test loss drives checkpoint selection in the code. The released code keeps the checkpoint with the lowest test loss experiments.py. If the paper's numbers come from this code, they are selected on the test set. Use a separate validation split if you need unbiased numbers.
- The ‖F_a‖² column has no stated definition. The table header is ‖F_a‖², and the paper's norm on the data is defined through a sum of squared norms §4.1. The code's penalty is a per-point average experiments.py. Expect the reported values to be hard to match exactly.
- log MSE is not defined. The paper's base for the logarithm is not stated. The code prints the raw MSE experiments.py. Compare numbers only after confirming the base.
- Parameter reparametrisation changes the effective learning rate. The sigmoid scaling of the reaction-diffusion parameters bounds them to (0, 0.01) networks.py. Gradient steps on the raw logits behave differently from steps on a, b, k directly. The paper does not mention this.
- Wave windows overlap in the released code. Train and test windows come from single trajectories and overlap heavily wave.py. Any wave result from this code is a single-trajectory result, not a result over many independent sequences as the paper describes app. E.2.
- Boundary handling differs from the stated condition. The paper's Neumann condition is not what the code implements. Both the simulator and the model set the Laplacian to zero on the outer cells, so boundary cells get no spatial coupling wave.py networks.py.
- The paper's own text disagrees with its table. The wave comparison in §4.2 quotes -5.92 for APHYNITY against -5.24 for the true ODE §4.2, but Table 1 has -6.09 for APHYNITY Param PDE (c, k) and -5.24 for APHYNITY True PDE, and no -5.92. The ablation paragraph calls the model "Param ODE (a, b)", which should read Param PDE (a, b) §4.2.
- Figure 4(c) repeats 4(b)'s file. The "true diffusion" panel uses the same image file as the APHYNITY estimate, so the figure cannot be trusted as a visual comparison fig. 4.
- Test-time predictions use batch statistics. Because the ConvNet's batch norm does not track running averages, test predictions depend on the batch in which each sample sits networks.py.
- The integration scheme differs between data and model. Data are generated with a different scheme from the model's RK4, which the paper says is deliberate §4.1. The residual error this leaves is why the "true" rows are not zero.
- The derivative-supervision argument is a bound, not a measurement. The exponential error growth app. D is a bound with a constant that depends on the bound of the spatial derivatives of F. The paper does not measure it.
Lineage
- Builds on: neural ODEs, which the paper uses as its data-driven baseline §1 §4.1, and the gray-box and hybrid modelling line of earlier work §2. The paper adds the decomposition criterion and the adaptive multiplier.
- Compared against: Hybrid neural-network corrections, PhICNet-style additive noise models and vanilla additive augmentation §2 app. F.1. Other references in the paper include the Deep Galerkin Method §4.1 and the Hamiltonian neural network §4.1.
- Superseded by: not stated in the content of this card.
Source and license
Adapted from “Augmenting Physical Models with Deep Networks for Complex Dynamics Forecasting” by Yuan Yin, Vincent Le Guen, Jérémie Dona, Emmanuel de Bézenac, Ibrahim Ayed, Nicolas Thome, Patrick Gallinari (arXiv:2010.04456), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors. Code citations refer to https://github.com/yuan-yin/APHYNITY at commit 03d1f9618b34 (MIT). Any quoted code is shown under that license.