betaFeedback

WorksComputer Science

Efficient Closure Learning in Dynamical Systems: A Comparison of Data-Assimilated and Embedded Approaches

Abstract

Increased computing power has transformed computational science and improved predictive capabilities for complex systems, but many phenomena still exceed current simulation capabilities or require rapid evaluations for fast design iterations. Closure models address this challenge by approximating unresolved effects in reduced or incomplete dynamical systems. Data-driven closures offer a flexible mechanism for improving model accuracy and applicability, but approaches that embed the closure within a computational model for construction and training phases can be computationally expensive and cause numerical instabilities in the computational model during training. To avoid the challenges posed by embedded approaches, staged approaches to closure-model learning have been developed. The first stage uses data assimilation to infer state and closure trajectories from observations. The second stage trains a machine learning closure model offline using the assimilated data, thereby avoiding repeated simulator calls during training. In this work, we investigate the cost and accuracy tradeoffs between embedded and staged data-driven closure modeling approaches for a synthetic epidemiological SIQR model with a nonlinear state-dependent quarantine closure. The results illustrate a practical accuracy-efficiency trade-off: for this exemplar, embedded training provides the strongest average accuracy, while the staged approach yields comparable qualitative behavior with a moderate increase in error, substantially fewer model evaluations, and improved optimization robustness.

Introduction

Increased computational power has enabled high-fidelity simulation across a wide range of scientific and engineering applications, but significant challenges remain in constructing accurate and complete mathematical models. A central issue is the closure problem, in which unknown quantities appear in the governing equations and must be modeled in order to close the system. These unknown quantities may arise from unresolved scales, incomplete physics, or coarse-grained representations. Prominent examples of closure problems include Reynolds stresses in Reynolds-averaged Navier–Stokes equations, subgrid-scale stresses in large eddy simulations, and constitutive relations in continuum mechanics [1, 2, 3].

Traditional approaches to constructing closure models rely on dimensional analysis, asymptotic reasoning, scaling arguments, and empirical calibration [4, 2, 3, 5]. These methods have produced robust and widely used models that perform well within specific calibration regimes. However, they often result in relatively simple algebraic or low-dimensional functional forms, which can limit expressiveness and adaptability. Consequently, such closures may struggle to generalize across regimes or capture complex nonlinear interactions in many physical and biological systems [6].

These limitations motivate more flexible data-driven approaches to closure modeling. Recent advances in machine learning, together with increasing availability of high-fidelity simulation and experimental data, have enabled the construction of closure models based on expressive function approximators such as neural networks [7, 8, 9, 10, 11, 12, 13, 14]. Such approaches can capture nonlinear dependencies and latent structures that are difficult to encode using traditional closure modeling paradigms. However, significant challenges remain when neural closures are trained while embedded directly within the governing equations. Each loss or validation evaluation requires a forward model solve, and training may require differentiating through the numerical solver. Embedded training can also be numerically fragile: as the neural-network parameters evolve, the learned closure may alter the system dynamics in ways that make the initial-value problem difficult to solve, for example by inducing stiffness, nonphysical states, or extremely small stable time steps. These challenges become more pronounced when multiple training trajectories or parameter scenarios are used to improve generalizability, because each scenario requires an additional model solve during optimization.

To address these challenges, staged approaches to data-driven closure modeling have been developed [15, 16, 17, 18, 19]. The central idea is to decouple closure inference from closure-function training. In the first stage, data assimilation is used to infer closure-consistent state and closure trajectories from observations by augmenting the physical state with a latent closure variable. In the second stage, a regression or machine-learning model is trained offline to map resolved states to the inferred closure values. After training, the learned closure can be embedded into the governing equations for prediction. This workflow avoids repeated forward simulations during neural-network optimization and does not require the simulator to be differentiable.

Despite the practical appeal of staged closure learning, the accuracy–cost trade-offs relative to embedded neural-closure training are not yet fully understood. This paper therefore presents a systematic comparison of these tradeoffs in the context of a synthetic compartment-based epidemiological model, where an unknown closure represents a state-dependent transition rate from infectious to quarantined populations. Because the study is synthetic, the true closure is known and can be used for diagnostic evaluation, although the methods themselves use only noisy observations of population state variables. For this study, we find that the embedded approach achieves lower average held-out calibration error and lower average calibration closure error, but requires 9×9 \times greater model evaluations for training than the staged approach.

The remainder of the paper is organized as follows. Section 2 reviews the closure-learning problem, embedded neural closure modeling, and the data-assimilation tools used for staged closure inference. Section 3 defines the comparison protocol between embedded and staged approaches, including data usage, neural-network optimization, performance metrics, computational-cost accounting, and robustness measures. Section 4 presents the synthetic SIQR numerical study and compares the two methods in terms of held-out calibration accuracy, diagnostic closure error, training-stage model evaluations, failed neural-network starts, and validation-scenario generalization. Section 5 summarizes the main findings and discusses future directions.

Background

The closure problem

Many systems of interest can be represented as dynamical systems whose resolved state x(t)∈Rnxx(t) \in\mathbb{R}^{n_x} evolves according to

dx(t)dt=R(x(t),ξ(x(t))),(1)\frac{d x(t)}{d t} = R(x(t), \xi(x(t))), \tag*{(1)}

where RR denotes the known resolved dynamics and ξ\xi denotes an unknown closure. The closure may represent unresolved physics, model-form error, coarse-graining effects, missing source terms, or unresolved couplings. The closure problem arises because the governing equations cannot be evaluated without specifying ξ\xi. In many applications, the functional form of ξ\xi is unavailable or only approximately known.

The goal of data-driven closure learning is to construct a parameterized approximation ξθ\xi_\theta from observations of the resolved state or other derived quantities of interest. Once learned, the closure model is embedded into the dynamical system to produce the closed predictive model

dx(t)dt=R(x(t),ξθ(x(t))).(2)\frac{d x(t)}{d t} = R(x(t), \xi_\theta(x(t))). \tag*{(2)}

Suppose observations are available at times {ti}i=0Nt−1\{t_i\}_{i=0}^{N_t-1}. A linear observation model can be defined as

di=Hx(ti)+ϵi,ϵi∼iidN(0,Γ),(3)d_i = Hx(t_i) + \epsilon_i,\qquad\epsilon_i \overset{\mathrm{iid}}{\sim} \mathcal{N}(0,\Gamma), \tag*{(3)}

where HH maps the resolved state to the observed quantities and Γ\Gamma is the observation-error covariance. For any given training procedure, a subset of all observation times may be employed (e.g., for test-train-validation split). In the following discussion we denote a subset of observation-time indices as I\mathcal{I}, and we specify which indices are used for different training procedures in detail in Section 3.

Embedded training

Embedded training places the parametric closure model directly inside the governing equations during optimization. For a neural-network closure ξθ\xi_\theta, the embedded model is

dx(t;θ)dt=R(x(t;θ),ξθ(x(t;θ))),(4)\frac{dx(t;\theta)}{dt} = R\left(x(t;\theta),\xi_\theta\left(x(t;\theta)\right)\right), \tag*{(4)}

where x(t;θ)x(t;\theta) denotes the model trajectory obtained with closure parameters θ\theta. For Gaussian observation errors, embedded training minimizes the negative log-likelihood of the training observations. Up to additive constants independent of θ\theta, this objective is

Lemb(θ)=12∑i∈I(di−Hx(ti;θ))TΓ−1(di−Hx(ti;θ)).(5)\mathcal{L}_{\mathrm{emb}}(\theta) = \frac{1}{2}\sum_{i\in\mathcal{I}}\left(d_i-Hx(t_i;\theta)\right)^{\mathsf{T}}\Gamma^{-1}\left(d_i-Hx(t_i;\theta)\right). \tag*{(5)}

This approach is closely related to universal differential equations, which augment mechanistic models with trainable function approximators [20]. A key advantage of embedded training is that the closure is optimized according to its direct effect on the observable state trajectory. However, each loss or validation evaluation requires a forward solve of the dynamical system. Gradient-based optimization may also require differentiating through the numerical time integrator. These costs become more pronounced when the data includes multiple scenarios (e.g., multiple initial conditions), because each scenario requires a unique model solve. Embedded training can also be numerically fragile because intermediate neural-network parameters may alter the dynamics in ways that make the initial-value problem difficult to solve. For example, the learned closure may induce stiffness, nonphysical states, exploding trajectories, or extremely small time steps to maintain numerical stability.

Staged training

Staged training separates closure inference from closure-function training. The first stage uses data assimilation to infer a time-dependent closure trajectory that is consistent with the observations. The second stage trains a regression model offline to map resolved states to the inferred closure values. After this supervised training step, the learned closure is embedded into the governing equations for prediction. Thus, staged training invokes the expensive computational model during data assimilation, but avoids repeated model calls during neural-network optimization. It also does not require the computational model to be differentiable with respect to closure-model parameters.

Step 1: Data assimilation by state augmentation, EnKF, and smoothing

The staged approach considered here estimates the latent closure by augmenting the physical state with the closure variable. Define the augmented state as

z(t)=[x(t)ξ(t)].(6)z(t) = \begin{bmatrix} x(t) \\ \xi(t) \end{bmatrix}. \tag*{(6)}

The physical state evolves according to the known model evaluated with a time-dependent closure, while the closure is assigned artificial stochastic dynamics:

dx(t)dt=R(x(t),ξ(t)),(7)\frac{dx(t)}{dt} = R\left(x(t),\xi(t)\right), \tag*{(7)}
dξ(t)=σξ dW(t).(8)d\xi(t) = \sigma_{\xi}\,dW(t). \tag*{(8)}

Here W(t)W(t) is a Wiener process and σξ\sigma_{\xi} controls the closure process-noise magnitude. The stochastic closure dynamics are not intended to be a mechanistic model for the closure. Instead, they provide flexibility for the data-assimilation procedure to attribute model-data mismatch to an unresolved closure process.

The observation model for the augmented state is

di=Hz(ti)+ϵi,ϵi∼iidN(0,Γ).(9)d_i = \mathcal{H}z(t_i) + \epsilon_i,\qquad\epsilon_i \mathrel{\overset{\mathrm{iid}}{\sim}} \mathcal{N}(0,\Gamma). \tag*{(9)}

If only the physical state is observed, then H=[H  0]\mathcal{H} = [H\ \ 0].

We use an ensemble Kalman filter (EnKF) [21] to sequentially update an ensemble representation of the augmented state. At each observation time, the ensemble is first propagated through the augmented dynamics in (7)–(8). The forecast ensemble is then corrected using the discrepancy between the predicted and observed data. Because the closure variable is part of the augmented state, this update adjusts both the resolved physical variables and the latent closure through their ensemble-estimated correlations with the observations. The closure process-noise scale σξ\sigma_{\xi} can be fixed or estimated from the observations used in the assimilation window. In this work, σξ\sigma_{\xi} is selected by maximizing an EnKF innovation likelihood, following the innovation-based covariance-parameter estimation approach of [22].

Filtering estimates at time tit_i use observations only up to that time. For closure learning, however, it is useful for the inferred closure labels to reflect information from the full assimilated time window. We therefore apply a fixed-interval ensemble smoother [23]. The smoother retrospectively updates stored ensembles at previous output times using later observation innovations and ensemble-estimated temporal correlations. After all observations in the assimilation window have been processed, the resulting smoothed ensemble provides closure-consistent estimates of both the resolved state and the latent closure.

Step 2: Offline closure training

The full smoothed ensemble contains more information than its mean. In particular, the ensemble spread provides an estimate of uncertainty in both the resolved state and the inferred closure. This uncertainty could be propagated into the learned closure model by training an uncertainty-aware regressor on the ensemble rather than only on the ensemble mean. For example, the ensemble at each time could be used to define a local likelihood for Bayesian neural-network training, or multiple closure networks could be trained on ensemble-derived samples to form an ensemble closure model. Such approaches would allow uncertainty in the data-assimilated closure estimates to be carried into the final autonomous predictions. In this work, however, we use only the smoothed ensemble mean. This deterministic reduction is chosen to maintain a direct comparison with the deterministic embedded neural-network closure.

The data-assimilated closure-training pairs are

DDA={(xˉis,ξˉis):i∈I},(10)\mathcal{D}_{\mathrm{DA}} = \left\{(\bar{x}_i^{s},\bar{\xi}_i^{s}) : i \in\mathcal{I}\right\}, \tag*{(10)}

where xˉis\bar{x}_i^{s} and ξˉis\bar{\xi}_i^{s} denote the smoothed ensemble means of the resolved state and inferred closure, respectively. A neural network ξθ\xi_{\theta} is then trained offline to approximate the map from resolved state to inferred closure:

θ∗=argmin⁡θ 12∑i∈I∣ξθ(xˉis)−ξˉis∣2.(11)\theta^{*} = \underset{\theta}{\operatorname{argmin}}\ \frac{1}{2}\sum_{i\in\mathcal{I}}\left|\xi_{\theta}(\bar{x}_i^{s})-\bar{\xi}_i^{s}\right|^{2}. \tag*{(11)}

After training, the learned closure is inserted into the original dynamical model for new predictions:

dx(t)dt=R(x(t),ξθ∗(x(t))).(12)\frac{d x(t)}{d t} = R(x(t),\xi_{\theta^{*}}(x(t))). \tag*{(12)}

Comparison Methodology

This section defines the experimental protocol used to compare embedded closure training with staged data-assimilated closure training. The general mathematical approach for both methods is given in § 2. Here, we specify how the observation data are split, how each method uses those data, how neural-network training is performed, and how accuracy, cost, and robustness are measured.

Data usage and held-out evaluation

Both methods are evaluated using the same noisy observations and the same randomized train, validation, and test time-index split. The observation-time indices are partitioned into Itrain\mathcal{I}_{\mathrm{train}}, Ival\mathcal{I}_{\mathrm{val}}, and Itest\mathcal{I}_{\mathrm{test}}. The split fractions are 60%, 20%, and 20%, respectively. The test indices are held out from all training, data assimilation, hyperparameter selection, early stopping, and model-selection procedures.

For embedded training, the neural closure is trained directly against the noisy observations indexed by Itrain\mathcal{I}_{\mathrm{train}}. The validation observations indexed by Ival\mathcal{I}_{\mathrm{val}} are used for early stopping, random-start selection, and derivative-based local refinement accept-or-reject decisions. The test observations indexed by Itest\mathcal{I}_{\mathrm{test}} are used only for final evaluation.

For staged training, data assimilation is performed once using the union of the original training and validation observations. Thus, the assimilation index set is

Iassim=Itrain∪Ival.(13)\mathcal{I}_{\mathrm{assim}} = \mathcal{I}_{\mathrm{train}} \cup\mathcal{I}_{\mathrm{val}}. \tag*{(13)}

The original test observations are never assimilated. The closure process-noise parameter σξ\sigma_{\xi} is estimated using only observations indexed by Iassim\mathcal{I}_{\mathrm{assim}}. After the EnKF and smoother are run, pseudo-training pairs are selected at the original training times and pseudo-validation pairs are selected at the original validation times:

Dpseudo-train={(xˉis,ξˉis):i∈Itrain},(14)\mathcal{D}_{\mathrm{pseudo\text{-}train}} = \left\{(\bar{x}_{i}^{s},\bar{\xi}_{i}^{s}) : i \in\mathcal{I}_{\mathrm{train}}\right\}, \tag*{(14)}
Dpseudo-val={(xˉis,ξˉis):i∈Ival}.(15)\mathcal{D}_{\mathrm{pseudo\text{-}val}} = \left\{(\bar{x}_{i}^{s},\bar{\xi}_{i}^{s}) : i \in\mathcal{I}_{\mathrm{val}}\right\}. \tag*{(15)}

The prefix “pseudo” emphasizes that the supervised learning targets ξˉis\bar{\xi}_{i}^{s} are not directly observed closure values, but are inferred quantities produced by the EnKF and smoother. The staged approach uses the original train–validation index split to organize these inferred pairs, but the pseudo-training and pseudo-validation sets are not independent raw datasets. Because both sets are produced by a single assimilation and smoothing procedure over Iassim\mathcal{I}_{\mathrm{assim}}, they are temporally correlated through the forecast dynamics, ensemble covariances, and retrospective smoothing updates. Thus, pseudo-validation is used only for internal staged neural-network selection, such as early stopping or random-start selection decisions. It is not treated as an independent measure of predictive performance. Final accuracy comparisons are made only on the original held-out observations indexed by Itest\mathcal{I}_{\mathrm{test}}, which are excluded from assimilation, training, validation, and model selection.

Closure-model training objectives

Both approaches use the same parametric closure-model class. They differ in the objective used to construct the closure and in whether the dynamical-system simulator is invoked during closure-model training.

In the embedded approach, the closure is trained according to its effect on the observed state trajectory. For a candidate closure ξθ\xi_{\theta}, the model trajectory x(t;θ)x(t;\theta) is obtained by solving (4). The embedded training objective is the observation-space negative log-likelihood over the training indices, up to additive constants independent of θ\theta:

Lemb(θ)=12∑i∈Itrain(di−Hx(ti;θ))TΓ−1(di−Hx(ti;θ)).(16)\mathcal{L}_{\mathrm{emb}}(\theta) = \frac{1}{2}\sum_{i\in\mathcal{I}_{\mathrm{train}}}\left(d_i-Hx(t_i;\theta)\right)^{\mathrm{T}}\Gamma^{-1}\left(d_i-Hx(t_i;\theta)\right). \tag*{(16)}

Multistart and stopping criteria evaluations use the analogous observation-space loss over Ival\mathcal{I}_{\mathrm{val}}.

In the staged approach, the closure is trained as an offline supervised regression problem using the data-assimilated state–closure pairs. The staged training objective is

Lstaged(θ)=12∑i∈Itrain∣ξθ(xˉis)−ξˉis∣2.(17)\mathcal{L}_{\mathrm{staged}}(\theta) = \frac{1}{2}\sum_{i\in\mathcal{I}_{\mathrm{train}}}\left|\xi_{\theta}(\bar{x}_{i}^{s})-\bar{\xi}_{i}^{s}\right|^{2}. \tag*{(17)}

Multistart and stopping criteria evaluations use the analogous supervised loss over Dpseudo-val\mathcal{D}_{\mathrm{pseudo\text{-}val}}. This supervised training step does not call the dynamical-system simulator. After training, the selected staged closure is embedded into the governing equations for future predictions.

Performance metrics

Both approaches are evaluated on the same held-out test observations. The primary calibration metric is the likelihood-scaled observation space test loss

Ltest=12∑i∈Itest(di−Hxpred(ti))TΓ−1(di−Hxpred(ti)),(18)\mathcal{L}_{\mathrm{test}} = \frac{1}{2}\sum_{i\in\mathcal{I}_{\mathrm{test}}} (d_i - Hx_{\mathrm{pred}}(t_i))^{T}\Gamma^{-1}(d_i - Hx_{\mathrm{pred}}(t_i)), \tag*{(18)}

where xpred(ti)x_{\mathrm{pred}}(t_i) denotes the state trajectory produced by the trained closure model. This metric evaluates predictive agreement with raw observations that were not used during training, data assimilation, validation, or model selection.

Because the numerical study is synthetic, the true closure is known and can be used for diagnostic evaluation. For an index set I\mathcal{I}, the closure error is measured by

RMSE⁡ξ(I)=(1∣I∣∑i∈I∣ξθ(xtrue(ti))−ξtrue(xtrue(ti))∣2)1/2.(19)\operatorname{RMSE}_{\xi}(\mathcal{I}) = \left(\frac{1}{|\mathcal{I}|}\sum_{i\in\mathcal{I}}\left|\xi_{\theta}(x_{\mathrm{true}}(t_i))-\xi_{\mathrm{true}}(x_{\mathrm{true}}(t_i))\right|^{2}\right)^{1/2}. \tag*{(19)}

This closure RMSE is a diagnostic metric and would not be available in a real closure-learning application where ξtrue\xi_{\mathrm{true}} is unknown.

To assess generalization, trained closures are also embedded into systems with parameter values different from those used during calibration. For each of these validation scenarios, state prediction error is measured by

RMSE⁡x=(1Nt∑i=0Nt−1∥xpred(ti)−xtrue(ti)∥22)1/2.(20)\operatorname{RMSE}_{x} = \left(\frac{1}{N_t}\sum_{i=0}^{N_t-1}\left\|x_{\mathrm{pred}}(t_i)-x_{\mathrm{true}}(t_i)\right\|_{2}^{2}\right)^{1/2}. \tag*{(20)}

Closure prediction error in each validation scenario is measured analogously using RMSE⁡ξ\operatorname{RMSE}_{\xi} over the validation trajectory.

Computational cost and robustness accounting

Computational cost is measured by the number of computational model evaluations required to construct each closure model. This accounting is intended to isolate the portion of each workflow that would become expensive for large, legacy, or high-fidelity simulators.

For embedded training, the cost includes all forward solves of the dynamical system used during closure-model optimization and model selection. Each evaluation of the embedded training or validation objective requires a computational model evaluation with the current closure parameters. Thus, embedded cost scales directly with the number of candidate closure models evaluated during training.

For staged training, the cost includes computational model evaluations used during the data-assimilation stage, including any evaluations used to select data-assimilation hyperparameters and the final assimilation and smoothing pass. The subsequent supervised closure-regression step is not included in the total cost because it evaluates only the offline regression objective on the assimilated state–closure pairs. This distinction reflects the central computational difference between the two workflows: embedded training repeatedly calls the simulator during neural-network optimization, whereas staged training shifts simulator use into a preprocessing stage and then performs closure-function training offline.

Robustness is measured by the number of failed candidate training runs. A candidate is counted as failed if it produces a solver failure, nonfinite state, or nonfinite loss. This metric is included because embedded optimization can generate intermediate closures that alter the dynamical system in unstable or nonphysical ways. In contrast, after the data-assimilation stage, the staged neural-network optimization is a supervised regression problem, so unstable intermediate closure models do not impact computational model performance during training.

Replicate analysis

To assess the variability in comparisons of accuracy and cost, we perform replicate trainings herein, where each replicate features a new noisy observation realization, a new random train-validation-test split, and a new seed for multistart neural-network training. Both methods are evaluated on the same held-out test observations per replicate realization. These replicate results are aggregated and presented in the numerical results in § 4.

Numerical study

SIQR epidemiological exemplar

We compare embedded and staged closure training using a synthetic compartmental epidemiological model with susceptible, infectious, quarantined, and removed compartments. The state is

x(t)=[s(t)i(t)q(t)r(t)]T,(21)x(t) = \left[s(t)\quad i(t)\quad q(t)\quad r(t)\right]^{T}, \tag*{(21)}

where each component is a population fraction. The true dynamics are

dsdt=−βsi,(22)\frac{ds}{dt} = -\beta si, \tag*{(22)}
didt=βsi−γi−ξ(s,i)i,(23)\frac{di}{dt} = \beta si - \gamma i - \xi(s,i)i, \tag*{(23)}
dqdt=ξ(s,i)i−δq,(24)\frac{dq}{dt} = \xi(s,i)i - \delta q, \tag*{(24)}
drdt=γi+δq.(25)\frac{dr}{dt} = \gamma i + \delta q. \tag*{(25)}

The unknown closure ξ\xi controls the transition from infectious to quarantined individuals. The true synthetic closure is

ξ(s(t),i(t))=s(t)1/2⋅12[1+tanh⁡(i(t)Npop−3×1050.05Npop)].(26)\xi(s(t),i(t)) = s(t)^{1/2} \cdot\frac{1}{2}\left[1 + \tanh\left(\frac{i(t)N_{\mathrm{pop}} - 3 \times10^{5}}{0.05N_{\mathrm{pop}}}\right)\right]. \tag*{(26)}

This closure represents a smooth, saturating quarantine response. When the infectious population count is low, the transition into quarantine is small. As infections increase, the quarantine rate rises, representing increased testing, self-isolation, or public-health response. The hyperbolic tangent produces a smooth transition near 3×1053 \times10^{5} infectious individuals. The dependence on s(t)1/2s(t)^{1/2} reduces the quarantine response as the susceptible pool is depleted.

For the dataset used in training, the population size is Npop=2×106N_{\mathrm{pop}} = 2 \times10^{6}. The initial counts are 500 infectious individuals, 10 quarantined individuals, 10 removed individuals, and the remainder susceptible. The nondimensional initial condition is therefore

i(0)=500Npop,(27)i(0) = \frac{500}{N_{\mathrm{pop}}}, \tag*{(27)}
q(0)=10Npop,(28)q(0) = \frac{10}{N_{\mathrm{pop}}}, \tag*{(28)}
r(0)=10Npop,(29)r(0) = \frac{10}{N_{\mathrm{pop}}}, \tag*{(29)}
s(0)=1−i(0)−q(0)−r(0).(30)s(0) = 1 - i(0) - q(0) - r(0). \tag*{(30)}

The transition rate parameters in the model are set at β=0.15\beta= 0.15, γ=0.013\gamma= 0.013, and δ=0.01\delta= 0.01. The time evolution of this system is shown in Figure 1.

True system dynamics showing population ratios and closure trajectory

Figure 1. True SIQR system dynamics and closure trajectory used to generate the synthetic observations.

Noisy observations are generated as

di=Hx(ti)+ϵi,ϵi∼N(0,σϵ2I),(31)d_i = Hx(t_i) + \epsilon_i,\qquad\epsilon_i \sim\mathcal{N}(0,\sigma_{\epsilon}^{2}I), \tag*{(31)}

with H=I∈R4H = I \in\mathbb{R}^{4}. The measurement noise is assumed known and is set to σϵ2=10−6\sigma_{\epsilon}^{2} = 10^{-6}.

SIQR embedded closure model

The embedded approach replaces the unknown quarantine closure with a neural network ξθ\xi_\theta. The embedded SIQR dynamics are

dsdt=−βsi,(32)\frac{ds}{dt}=-\beta si, \tag*{(32)}
didt=βsi−γi−ξθ(s,i,q,r)i,(33)\frac{di}{dt}=\beta si-\gamma i-\xi_\theta(s,i,q,r)i, \tag*{(33)}
dqdt=ξθ(s,i,q,r)i−δq,(34)\frac{dq}{dt}=\xi_\theta(s,i,q,r)i-\delta q, \tag*{(34)}
drdt=γi+δq.(35)\frac{dr}{dt}=\gamma i+\delta q. \tag*{(35)}

The positive sign in the quarantined equation reflects that the learned closure transfers individuals from the infectious compartment into the quarantined compartment. The state variable trajectory induced by a given neural network parameter vector θ\theta is denoted by x(t;θ)x(t;\theta). The network is trained against noisy state observations using the embedded trajectory loss described in § 3.2. Training, validation, random-start selection, and local-refinement accept-or-reject decisions follow the comparison protocol in § 3. The specific optimizer, initialization, and solver settings used in this study are given in § 4.2.

SIQR staged data-assimilated closure model

For the staged data-assimilated approach, the SIQR state is augmented with a time-dependent latent closure variable. The augmented state is

z^(t)=[s(t)i(t)q(t)r(t)ξ^(t)]T.(36)\hat{z}(t)=\begin{bmatrix}s(t)&i(t)&q(t)&r(t)&\hat{\xi}(t)\end{bmatrix}^{T}. \tag*{(36)}

The augmented dynamics used during data assimilation are

dsdt=−βsi,(37)\frac{ds}{dt}=-\beta si, \tag*{(37)}
didt=βsi−γi−ξ^(t)i,(38)\frac{di}{dt}=\beta si-\gamma i-\hat{\xi}(t)i, \tag*{(38)}
dqdt=ξ^(t)i−δq,(39)\frac{dq}{dt}=\hat{\xi}(t)i-\delta q, \tag*{(39)}
drdt=γi+δq,(40)\frac{dr}{dt}=\gamma i+\delta q, \tag*{(40)}
dξ^(t)=σξdW(t).(41)d\hat{\xi}(t)=\sigma_{\xi}dW(t). \tag*{(41)}

The EnKF ensemble size is Nens=100N_{\mathrm{ens}} = 100. The closure process noise is applied only to the closure component. The observation covariance is Γ=σε2I4\Gamma= \sigma_{\varepsilon}^{2} I_{4}. The assimilation uses observations indexed by Iassim=Itrain∪Ival\mathcal{I}_{\mathrm{assim}} = \mathcal{I}_{\mathrm{train}} \cup\mathcal{I}_{\mathrm{val}}. The original test observations indexed by Itest\mathcal{I}_{\mathrm{test}} are not assimilated.

The EnKF and fixed-interval smoother produce smoothed ensemble means zˉi=[xˉi,ξˉi]T\bar{z}_{i} = [\bar{x}_{i},\bar{\xi}_{i}]^{\mathsf{T}}. For the SIQR problem, the smoothed physical-state mean is xˉis=[sˉis,iˉis,qˉis,rˉis]T\bar{x}_{i}^{s} = [\bar{s}_{i}^{s},\bar{i}_{i}^{s},\bar{q}_{i}^{s},\bar{r}_{i}^{s}]^{\mathsf{T}}. The staged neural network is trained offline using the supervised loss

Lstaged(θ)=12∑i∈Itrain∣ξθ(sˉis,iˉis,qˉis,rˉis)−ξˉis∣2.(42)\mathcal{L}_{\mathrm{staged}}(\theta) = \frac{1}{2} \sum_{i \in\mathcal{I}_{\mathrm{train}}} \left\lvert\xi_{\theta}(\bar{s}_{i}^{s},\bar{i}_{i}^{s},\bar{q}_{i}^{s},\bar{r}_{i}^{s}) - \bar{\xi}_{i}^{s} \right\rvert^{2}. \tag*{(42)}

The pseudo-validation loss is computed using the same expression over Ival\mathcal{I}_{\mathrm{val}}. After training, the learned staged closure is embedded into the SIQR equations for further predictions:

dsdt=−βsi,(43)\frac{ds}{dt} = -\beta s i, \tag*{(43)}
didt=βsi−γi−ξθ(s,i,q,r)i,(44)\frac{di}{dt} = \beta s i - \gamma i - \xi_{\theta}(s,i,q,r)i, \tag*{(44)}
dqdt=ξθ(s,i,q,r)i−δq,(45)\frac{dq}{dt} = \xi_{\theta}(s,i,q,r)i - \delta q, \tag*{(45)}
drdt=γi+δq.(46)\frac{dr}{dt} = \gamma i + \delta q. \tag*{(46)}

Numerical implementation

The code used to generate the numerical results in this section is available at https://github.com/sandialabs/STAGED_DDCM-Staged_Embedded_Comparison. All numerical experiments are implemented in Python using NumPy, SciPy, and packages in the JAX ecosystem. Synthetic SIQR trajectories and noisy observation data are generated using SciPy’s solve_ivp method with the RK45 timestepper. The true system is solved on the time interval [0,200][0, 200] days. Observations are stored every Δt=0.25\Delta t = 0.25 days, giving 801 observation times including both endpoints.

The embedded and staged closure networks use the same architecture, which was selected through a manual search using the supervised training data from the staged approach. Each network takes the four instantaneous state variables (s,i,q,r)(s,i,q,r) as input and has two hidden layers with two nodes per layer, sigmoid hidden-layer activations, and one scalar output. The output layer is unconstrained. Weights are initialized using Xavier uniform initialization and biases are initialized to zero. Both approaches use 10 random starts.

Neural-network training uses a two-stage derivative-based local optimization procedure. Each random start is first trained with AdamW, an adaptive first-order method [24]. The resulting candidate is then refined using L-BFGS [25] as a quasi-Newton local polishing step. The L-BFGS-refined candidate is accepted only if it improves the relevant validation objective. For embedded training, this validation objective is the raw-observation validation loss. For staged training, this validation objective is the EnKF-derived pseudo-validation loss.

AdamW uses learning rate 10−310^{-3}, weight decay 10−610^{-6}, and gradient clipping with maximum global norm 1. Each AdamW run is allowed at most 2000 iterations. Validation is performed every 100 AdamW iterations with early-stopping patience of 4 validation checks, so training stops after at most 400 AdamW iterations without validation improvement. After AdamW, L-BFGS is run for at most 500 iterations.

Embedded closure simulations are computed using Diffrax with the Dopri5 solver and an adaptive step size controller. The same Diffrax solver settings are used when the trained staged closure is embedded into the SIQR equations for predictions after training. A neural-network start is counted as failed if the ODE solve fails, produces nonfinite states or losses, or returns the large solver-failure penalty used by the training code.

The EnKF and smoother are implemented in custom NumPy code. The EnKF ensemble size is Nens=100N_{\mathrm{ens}} = 100. The augmented SIQR forecast model uses a forward-Euler update with internal step size Δtint=0.25\Delta t_{\mathrm{int}} = 0.25 days. The initial closure value in the augmented state is ξ^(0)=0\hat{\xi}(0) = 0. The closure process noise is applied only to the closure component of the augmented state.

For the staged approach, the EnKF assimilates only the original training and validation observations. The original test observations are never assimilated. The closure process-noise scale σξ\sigma_{\xi} is estimated separately for each replicate using an EnKF likelihood computed from the training and validation observations. For this likelihood optimization, every tenth training-or-validation observation is used. The process-noise optimization uses SciPy’s minimize with the Nelder–Mead method, initial value 2.0×10−52.0 \times10^{-5}, bounds [10−8,0.5][10^{-8}, 0.5], and tolerance 10−510^{-5}. After estimating σξ\sigma_{\xi}, a final EnKF assimilation is performed using all training and validation observations. Smoothing is employed in the staged experiments. The staged neural network is trained using only the EnKF-derived state–closure pairs and does not call the SIQR simulator during supervised optimization.

For each replicate in the study, independent random-number streams are used for observation noise, train–validation–test splitting, EnKF sampling, embedded neural-network initialization, and staged neural-network initialization. Specifically, replicate-dependent seeds are used for observation noise, data splitting, EnKF sampling, embedded training starts, and staged training starts.

Calibration comparison

The study uses 50 independent replicates. Both methods are evaluated on the same held-out test observations for each replicate. The reported test loss is the likelihood-scaled observation-space loss defined in § 3.3. Because the study is synthetic, we also report closure RMSE on the test indices. This closure RMSE is a diagnostic metric and would not be available in a real closure-modeling application.

Figure 2 compares the learned state trajectories from the embedded and staged approaches across replicates. Both methods reproduce the qualitative SIQR dynamics quite well. Figure 3 compares the learned closure trajectories with the true synthetic closure. Again, both methods recover the broad temporal structure of the closure.

Embedded and staged state trajectories across 50 replicates compared with the true SIQR trajectory

Figure 2. Embedded and staged state trajectories across 50 replicates compared with the true SIQR trajectory.

Learned closure trajectories from embedded and staged replicates compared with the true synthetic closure

Figure 3. Learned closure trajectories from embedded and staged replicates compared with the true synthetic closure.

Figure 4 summarizes calibration accuracy across the 50 replicates, where calibration performance is reported using held-out observation-space test loss and synthetic closure RMSE on the calibration test indices. The embedded approach achieves the lower average held-out test loss in this example, with mean test loss 3.92×102±1.35×1023.92 \times10^{2} \pm1.35 \times10^{2}. The staged approach has a larger mean held-out test loss of 1.75×103±1.23×1031.75 \times10^{3} \pm1.23 \times10^{3}. The embedded approach also has a lower average calibration closure RMSE of 1.18×10−3±1.17×10−31.18 \times10^{-3} \pm1.17 \times10^{-3}, compared with 1.70×10−3±7.42×10−41.70 \times10^{-3} \pm7.42 \times10^{-4} for the staged approach. Although the embedded approach is more accurate on average, the staged errors remain within the same order of magnitude for this calibration problem. Thus, the calibration results indicate a measurable but not prohibitive loss in average accuracy for the staged approach.

Calibration held-out test errors

Figure 4. Distribution of calibration errors over the 50 independent replicates for the embedded and staged approaches. Each violin shows the empirical distribution of the replicate-level error metric for one method, with width indicating relative density. Horizontal lines inside each violin indicate the 25th, 50th, and 75th percentiles of the replicate distribution.

The computational-cost and robustness comparison presented in Table 1 favors the staged approach. The embedded approach requires 2.41×104±7.41×1032.41 \times10^{4} \pm7.41 \times10^{3} training-stage model evaluations. The staged approach requires 2.78×103±3.59×1022.78 \times10^{3} \pm3.59 \times10^{2} training-stage model evaluations. This corresponds to an approximately 9×9\times reduction in model evaluations. The robustness comparison also favors the staged approach. The embedded approach has 215 failed neural-network starts across the 50 replicates with 10 multi-starts each, corresponding to a roughly 40% failure rate, whereas the staged approach has no failed starts.

MethodTraining model evaluationsFailed starts
Embedded2.41×104±7.41×1032.41 \times10^{4} \pm7.41 \times10^{3}215
STAGED DDCM2.78×103±3.59×1022.78 \times10^{3} \pm3.59 \times10^{2}0

Table 1. Comparison of embedded and staged closure-training approaches over 50 replicates. Computational cost is measured by training-stage model evaluations, where results are presented as μ±σ\mu\pm\sigma over the 50 replicates. Robustness is measured by the total number of failed neural-network starts.

As shown in Table 2, the staged cost is dominated by process-noise maximum-likelihood estimation. The process-noise MLE requires 2.68×103±3.59×1022.68 \times10^{3} \pm3.59 \times10^{2} model evaluations, while the final EnKF assimilation requires 100 model evaluations. The supervised staged neural-network training is offline and does not invoke the SIQR simulator. This result indicates that further efficiencies may be gained in the process-noise MLE step of the data assimilation process.

ComponentModel evaluations
Process-noise MLE2.68×103±3.59×1022.68 \times10^{3} \pm3.59 \times10^{2}
Final EnKF assimilation1.00×102±01.00 \times10^{2} \pm0
Total STAGED DDCM2.78×103±3.59×1022.78 \times10^{3} \pm3.59 \times10^{2}

Table 2. Training-stage model-evaluation accounting for the staged approach. The total is the sum of model evaluations used for process-noise maximum-likelihood estimation and the final EnKF assimilation. The subsequent supervised neural-network training step does not call the SIQR simulator and is therefore excluded from this simulator-dependent cost.

Validation-scenario generalization comparison

We also evaluate how the learned closures generalize when embedded into SIQR systems with parameter values different from the calibration scenario. The validation scenarios are

Case 1:β=0.30,γ=0.02,δ=0.01,(47)\begin{aligned} \text{Case 1:}\quad&\beta= 0.30,\quad\gamma= 0.02,\quad\delta= 0.01, \tag*{(47)} \end{aligned}
Case 2:β=0.10,γ=0.01,δ=0.01,(48)\begin{aligned} \text{Case 2:}\quad&\beta= 0.10,\quad\gamma= 0.01,\quad\delta= 0.01, \tag*{(48)} \end{aligned}
Case 3:β=0.15,γ=0.10,δ=0.01.(49)\begin{aligned} \text{Case 3:}\quad&\beta= 0.15,\quad\gamma= 0.10,\quad\delta= 0.01. \tag*{(49)} \end{aligned}

These cases and their relation to the calibration scenario are illustrated through a susceptible-infectious phase diagram in Figure 5. Case 1 is a more transmissible scenario with a shorter infectious period. Case 2 remains closer to the calibration trajectory and is closer to an interpolation regime in state space. Case 3 induces stronger extrapolation through a substantially accelerated recovery rate.

Scenario trajectory phase diagrams

Figure 5. Calibration and validation scenario trajectories in the susceptible-infectious projection.

Figure 6 and Figure 7 show state and closure trajectories for the validation scenarios. Both embedded and staged closures perform similarly across scenarios, with the greatest qualitative variability in results for Case 3, which constitutes the greatest extrapolation from the calibration scenario. Qualitative variability seems similar for the other two cases, which are closer to the calibration scenario.

Embedded and staged state trajectories under validation scenarios

Figure 6. Embedded and staged state trajectories under validation scenarios.

Embedded and staged learned closure trajectories under validation scenarios

Figure 7. Embedded and staged learned closure trajectories under validation scenarios.

Figure 8 summarizes validation scenario accuracy across the 50 replicates. The validation metrics are consistent with the calibration results but also show that the staged approach can remain competitive. For Case 1, the embedded approach has mean state RMSE 9.43×10−39.43 \times10^{-3} and mean closure RMSE 5.09×10−35.09 \times10^{-3}. For the same case, the staged approach has mean state RMSE 1.15×10−21.15 \times10^{-2} and mean closure RMSE 5.74×10−35.74 \times10^{-3}. These values are slightly larger for the staged approach but are close in magnitude, and the median errors in Case 1 are favorable to the staged approach. For Case 2, the embedded approach has lower mean and median state and closure errors. For Case 3, both methods become less accurate, and the embedded approach again has lower average errors. Overall, the validation scenarios suggest that staged training can produce useful closures outside the calibration trajectory, but with greater replicate-to-replicate variability than embedded training in this example.

Validation scenario errors for embedded and staged approaches across three cases

Figure 8. Distribution of validation scenario errors over the 50 independent replicates for the embedded and staged approaches. Each violin shows the empirical distribution of the replicate-level error metric for one method, with width indicating relative density. Horizontal lines inside each violin indicate the 25{sup}th, 50{sup}th, and 75{sup}th percentiles of the replicate distribution.

Discussion

Taken together, these results show an accuracy–efficiency tradeoff in the SIQR exemplar. The embedded approach is more accurate on average for this inexpensive low-dimensional system, but the staged approach attains the same qualitative behavior with substantially fewer model evaluations and no failed neural-network starts. The staged approach therefore sacrifices some average accuracy in exchange for lower computational cost and improved optimization robustness.

Whether this sacrifice is worthwhile depends on the computational setting. For inexpensive differentiable models, embedded training may be preferable. For expensive or nondifferentiable models, or for models where numerical instability can be easily induced, the reduced model-evaluation cost and improved robustness of staged training may be more important than the moderate increase in error observed here. Because this comparison is based on one synthetic SIQR example, the numerical values should not be interpreted as universal. Instead, they illustrate the type of accuracy–cost trade-off that can arise when replacing embedded neural-closure training with a staged data-assimilated workflow.

Conclusions

This work compared embedded and staged data-assimilated approaches for learning neural closure models in dynamical systems, focusing on accuracy, computational cost, and optimization robustness. Embedded training optimizes the closure through trajectory-level mismatch, whereas staged training uses data assimilation to infer closure-consistent trajectories before fitting the closure through offline supervised regression.

In the synthetic SIQR example considered here, embedded training produced the lowest average held-out calibration error and the lowest average diagnostic closure error. However, the staged approach produced qualitatively similar trajectories and closure behavior with errors that were often comparable in magnitude. Thus, the results should be interpreted as an accuracy–efficiency tradeoff rather than as a definitive ranking of the two approaches. For this low-dimensional and inexpensive exemplar, the accuracy advantage of embedded training may justify its additional computational cost. For more expensive, nondifferentiable, legacy, or numerically fragile simulators, the reduced model-evaluation cost and improved robustness of staged training may be more important than the moderate increase in error observed in this example.

The computational and robustness differences were substantial. Across 50 independent replicates, staged training required approximately 9×9 \times fewer training-stage model evaluations and eliminated failed neural-network starts. In contrast, embedded training yielded an approximately 40% training failure rate due to numerical challenges caused by intermediate closure model parameter guesses leading to instability, solver failures, etc. Staged training avoids this issue by separating computational model evaluations during data assimilation from offline neural-network optimization.

Both approaches produced generally stable predictions under parameter perturbations. Embedded training generally achieved lower mean state and closure errors, while staged training remained competitive in some scenarios and captured meaningful features of the nonlinear quarantine response. The larger staged mean errors were partly driven by outliers, indicating greater replicate-to-replicate variability. These findings suggest that staged learning can generalize beyond the calibration trajectory, although prediction errors may accumulate when trajectories depart from the calibration manifold.

Future work should extend the comparison to more complex and high-dimensional systems, incorporate uncertainty in the inferred closure, and use multiple calibration scenarios to improve generalization. Further investigation should also account for architecture selection and hyperparameter tuning, particularly the potential to reuse assimilated datasets for offline model development without additional simulator evaluations. These extensions will help establish when the computational and robustness advantages of staged training outweigh the accuracy gains of embedded optimization.

Acknowledgments

Sandia National Laboratories is a multi-mission laboratory managed and operated by National Technology & Engineering Solutions of Sandia, LLC (NTESS), a wholly owned subsidiary of Honeywell International Inc., for the U.S. Department of Energy’s National Nuclear Security Administration (DOE/NNSA) under contract DE-NA0003525. This written work is authored by an employee of NTESS. The employee, not NTESS, owns the right, title and interest in and to the written work and is responsible for its contents. Any subjective views or opinions that might be expressed in the written work do not necessarily represent the views of the U.S. Government. The publisher acknowledges that the U.S. Government retains a non-exclusive, paid-up, irrevocable, world-wide license to publish or reproduce the published form of this written work or allow others to do so, for U.S. Government purposes. The DOE will provide public access to results of federally sponsored research in accordance with the DOE Public Access Plan. This paper describes objective technical results and analysis. Any subjective views or opinions that might be expressed in the paper do not necessarily represent the views of the U.S. Department of Energy or the United States Government. This work was supported by the Laboratory Directed Research and Development program (project 233077) at Sandia National Laboratories, a multimission laboratory managed and operated by National Technology and Engineering Solutions of Sandia LLC, a wholly owned subsidiary of Honeywell International Inc. for the U.S. Department of Energy’s National Nuclear Security Administration under contract DE-NA0003525.

References

  1. [1]Vishal Srivastava and Karthik Duraisamy. Generalizable physics-constrained modeling using learning and inference assisted by feature-space engineering. Physical Review Fluids, 6(12):124602, 2021.arxiv.org/abs/2103.16042
  2. [2]Paul A Durbin. Some recent developments in turbulence closure modeling. Annual Review of Fluid Mechanics, 50:77–103, 2018.DOI
  3. [3]K Hanjalić. Advanced turbulence closure models: a view of current status and future prospects. International Journal of Heat and Fluid Flow, 15(3):178–203, 1994.DOI
  4. [4]Guy L Bergel, David Montes de Oca Zapalain, and Vicente Romero. Neural network ensembles and uncertainty estimation for predictions of inelastic mechanical deformation using a finite element method-neural network approach. Data-Centric Engineering, 4:e23, 2023.DOI
  5. [5]Jaideep Ray, Matthew Barone, Stefan Domino, Tania Banerjee, and Sanjay Ranka. Verification of data-driven models of physical phenomena using interpretable approximation. Technical report, Sandia National Laboratories (SNL-NM), Albuquerque, NM (United States), 2021.DOI
  6. [6]Shaowu Pan and Karthik Duraisamy. Data-driven discovery of closure models. SIAM Journal on Applied Dynamical Systems, 17(4):2381–2413, 2018.DOI
  7. [7]Eric J. Parish and Karthik Duraisamy. A paradigm for data-driven predictive modeling using field inversion and machine learning. Journal of Computational Physics, 305:758–774, January 2016.DOI
  8. [8]Shaowu Pan and Karthik Duraisamy. Data-Driven Discovery of Closure Models. SIAM Journal on Applied Dynamical Systems, 17(4):2381–2413, January 2018.DOI
  9. [9]Abhinav Gupta and Pierre F. J. Lermusiaux. Neural closure models for dynamical systems. Proceedings of the Royal Society A: Mathematical, Physical and Engineering Sciences, 477(2252):20201004, August 2021.DOI
  10. [10]W.A. Porteous, M.T.P. Laiu, and C.D. Hauck. Data-Driven, Structure-Preserving Approximations to Entropy-Based Moment Closures for Kinetic Equations. Communications in Mathematical Sciences, 21(4):885–913, 2023.arxiv.org/abs/2106.08973
  11. [11]Juntao Huang, Yingda Cheng, Andrew J. Christlieb, and Luke F. Roberts. Machine learning moment closure models for the radiative transfer equation I: Directly learning a gradient based closure. Journal of Computational Physics, 453:110941, March 2022.DOI
  12. [12]Stephan Rasp, Michael S. Pritchard, and Pierre Gentine. Deep learning to represent subgrid processes in climate models. Proceedings of the National Academy of Sciences, 115(39):9684–9689, September 2018.DOI
  13. [13]Eric Parish, David S Ching, Nathan E Miller, Steven J Beresh, and Matthew F Barone. Turbulence modeling for compressible flows using discrepancy tensor-basis neural networks and extrapolation detection. In AIAA SciTech 2023 Forum, page 2126, 2023.
  14. [14]Benjamin Sanderse, Panos Stinis, Romit Maulik, and Shady E. Ahmed. Scientific machine learning for closure models in multiscale problems: A review. Foundations of Data Science, 7(1):298–337, March 2025.arxiv.org/abs/2403.02913
  15. [15]Kyle D Neal, Mohammad Khalil, and Teresa Portone. Investigating model form error estimation for sparse data. In Annual Conference of the PHM Society, volume 16, 2024.DOI
  16. [16]Eric Crislip, Mohammad Khalil, Teresa Portone, Oksana Chkrebtii, and Kyle Neal. Closure term estimation in spatiotemporal models of dynamical systems. arXiv preprint arXiv:2511.20869, 2025.arxiv.org/abs/2511.20869
  17. [17]Abhinav Subramanian and Sankaran Mahadevan. Bayesian estimation of discrepancy in dynamics model prediction. Mechanical Systems and Signal Processing, 123:351–368, 2019.DOI
  18. [18]Abhinav Subramanian and Sankaran Mahadevan. Error estimation in coupled multi-physics models. Journal of Computational Physics, 395:19–37, 2019.DOI
  19. [19]Abhinav Subramanian and Sankaran Mahadevan. Model error propagation in coupled multiphysics systems. AIAA Journal, 58(5):2236–2245, 2020.DOI
  20. [20]Christopher Rackauckas, Yingbo Ma, Julius Martensen, Collin Warner, Kirill Zubov, Rohit Supekar, Dominic Skinner, Ali Ramadhan, and Alan Edelman. Universal differential equations for scientific machine learning. arXiv preprint arXiv:2001.04385, 2020.arxiv.org/abs/2001.04385
  21. [21]Geir Evensen. The ensemble kalman filter: Theoretical formulation and practical implementation. Ocean dynamics, 53:343–367, 2003.DOI
  22. [22]Dick P. Dee. On-line estimation of error covariance parameters for atmospheric data assimilation. Monthly weather review, 123(4):1128–1145, 1995.doi.org/10.1175/1520-0493(1995)123<1128:oleoec>2.0.co;2
  23. [23]Geir Evensen and Peter Jan van Leeuwen. An Ensemble Kalman Smoother for Nonlinear Dynamics. Monthly Weather Review, 128(6):1852–1867, June 2000.doi.org/10.1175/1520-0493(2000)128<1852:aeksfn>2.0.co;2
  24. [24]Ilya Loshchilov and Frank Hutter. Decoupled Weight Decay Regularization, 2019.
  25. [25]Dong C. Liu and Jorge Nocedal. On the limited memory BFGS method for large scale optimization. Mathematical Programming, 45(1):503–528, August 1989.

Paper details

vlnc:W_8ump57np
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents