WorksComputer Science
Approximate Adjoint Models for Memory and Compute-Efficient Online Learning of Hybrid Models
Abstract
Differentiable programming enables online calibration of numerical models by minimizing errors accumulated along simulated trajectories. This includes estimating physical parameters and training neural sub-models in hybrid configurations. Gradients are typically computed using adjoint methods, or backpropagation through time (BPTT), whose computational and memory costs grow with the length of the training window. This limits the duration and resolution of hybrid-model training, a major bottleneck for realistic geophysical applications. Approaches like truncated BPTT reduces memory use by discarding sensitivities across truncation boundaries, introducing gradient bias and neglecting long-range dependencies. We propose a class of gradient approximation methods that preserve the adjoint recurrence over the full trajectory while approximating only the pullback operators within it. Exact pullbacks are computed by automatic differentiation at sparse anchor states only. Between anchors, sensitivities propagate either through the identity (Zero-order) or through a reused, frozen pullback (Pullback Reuse). This approximation makes the parameter pullback constant within each chunk, allowing the gradient sum to factorize so that a single evaluation per chunk replaces one per time step. We evaluate both on three systems of increasing complexity, an incomplete Lorenz-63 model, a large-eddy closure for two-dimensional quasi-geostrophic turbulence, and bias correction in a multilayer quasi-geostrophic ocean model. Peak memory falls by up to an order of magnitude and runtime up to fourfold, with Pullback Reuse staying closest to the exact gradient direction. In all three cases, approximate gradients support hybrid-model training at comparable accuracy, showing that effective online learning does not require exact gradients.
Introduction
Numerical simulations of fluid flows require representing the interactions between processes that span a continuum of scales. Direct Numerical Simulations (DNS) resolve them explicitly, on a grid fine enough to capture the smallest dissipative scale, which is tractable only at moderate Reynolds numbers and in idealized configurations [31, 38, 41]. For realistic flows, Computational Fluid Dynamics and its geophysical counterparts instead seek the best fidelity attainable under a fixed computational budget. Common strategies rely on decomposing the flow into a numerically resolved large-scale and an unresolved remainder whose effect on the resolved scale is represented by a sub-model or closure. Reynolds-Averaged Navier-Stokes (RANS) and Large Eddy Simulations (LES) are canonical examples [22, 27, 28, 11, 38].
Physics-based sub-models derive this closure from first principles, as in eddy-viscosity assumptions where the unresolved scales are treated as mainly diffusive [44, 10, 45, 52]; similar heuristics are used for unresolved processes in the ocean and atmosphere [7]. Their continuous form permits theoretical validation and analysis of the well-posedness of the resulting equations, but they remain a significant source of uncertainty. Their free parameters are difficult to tune, and assumptions they encode do not always hold in the regimes where they are applied. Unresolved scales, for instance, do not only dissipate energy but they redistribute it and feed it back to larger scales, which diffusive closures cannot represent [37, 19, 18, 57].
The increasing availability of high-resolution simulations and observations, together with the progress in deep learning, has motivated a growing interest in the use of machine learning and artificial intelligence for numerical modeling. A first line of work replaces the numerical model entirely by a data-driven surrogate, either through reduced-order models evolving a low-dimensional representation of the flow [32, 33 b], or through neural emulators trained to reproduce the dynamics of the full state [36, 21] (Bi et al. 2023). A second approach, known as hybrid modeling, retains the physical dynamical model and adds a learned component to account for unresolved dynamics, correct systematic model biases, or replace uncertain closure schemes. This learned component is typically a deep neural network [39, 34, 9, 26].
Two strategies exist for training the learned component of a hybrid model. Offline or a priori learning, trains the sub-model independently of the dynamical system, as a supervised regression problem against a reference response. This approach remains widely adopted for its conceptual simplicity and low computational cost [56, 8].Because the sub-model never interacts with the physics during training, however, it is sensitive to the distribution shift between the training data and the states encountered during inference, and offline-trained parameterizations may show degraded long-term predictive skill, unphysical behavior, or numerical instabilities once coupled to the dynamical model [9, 26, 55].
Online or a posteriori learning, addresses these limitations by embedding the sub-model within the dynamical system during training. The coupled hybrid system is unrolled over several time steps, the loss is evaluated on the resulting trajectory, and the gradients are propagated through both the dynamical model and the sub-model. This formulation typically relies on differentiable programming where the numerical solver is written in a framework that supports automatic differentiation, so that the sensitivity of the simulated trajectory to the sub-model parameters is available. The sub-model therefore learns on the states the coupled system actually visits, and accounts for the temporal dependencies between them by minimizing the error accumulated along the unrolled hybrid trajectory. Online learning has been shown to improve forecast skill, promote long-term stability, and reduce the volume of training data required [9, 23, 34].
Beyond idealized cases, current work aims to demonstrate online learning on realistic, large-scale problems, with recent examples in atmosphere [20] and ocean [29] modeling. However, training through long simulated trajectories remains computationally expensive and thus the major bottleneck. Exact gradients requires information from intermediate simulation steps to be available during the backward pass, and thus it requires storing every intermediate states before traversing them backwards, making memory grow with both the trajectory length and the dimension of the model state. For systems with many degrees of freedom, this can limit the duration of the training window and the resolution at which the hybrid model can be trained. This constraint may help explain why some previous studies have relied on relatively coarse resolutions and limited domains [20, 29]. Approaches such as checkpointing [12, 46, 6] and truncated backpropagation through time (TBPTT) offer different ways to manage these costs, but involve trade-offs between memory, computation, and gradient accuracy. We discuss these approaches in more detail in § 4.
In this work, we target the computational cost of online learning. We introduce a class of Pullback Approximation methods that reduce the cost of the backward pass while propagating sensitivities across the full trajectory. The paper is organized as follows. Section 2 formalizes the hybrid modeling framework and the online learning problem. Section 3 introduces the proposed gradient approximation methods within a unified framework that also covers backpropagation through time and its truncated variant, Truncated Backpropagation Through Time (TBPTT), which serves as our biased-gradient baseline. Section 4 situates them with respect to other strategies for reducing the cost of exact gradients, and to related work in numerical analysis and deep learning. Section 5 describes the case studies and reports the results, evaluating methods in terms of both model accuracy and computational cost. Section 6 discusses the implications and outlines directions for future work.
Problem statement
Let us consider a hybrid dynamical system governed by the following parameterized ordinary differential equation (ODE):
where denotes the state of the system at time . The right-hand side is composed of two contributions. The first term, , represents the physics-based dynamical model which is derived from first principles or established empirical formulations. The second term, , is a data-driven sub-model designed to account for imperfections or unmodeled dynamics in . This component is typically implemented as a neural network parameterized by a set of trainable parameters .
In practice, the continuous-time system in Eq. (1) is discretized and evolved in time using a numerical time-integration scheme. We therefore introduce a mapping that represents the numerical integrator of the system (1). Given an initial state , and a parameter vector, the system evolves through the recursive application of to generate a rollout trajectory , where denotes the discrete time index.
In online learning, the optimization problem is formulated directly on such trajectories and the objective is to identify that minimizes a loss function evaluated over a specified finite temporally unrolled window. Let denote the number of integration steps over which the hybrid system is recursively unrolled. The state reached after this rollout can be expressed as
In the online learning literature, is commonly referred to as the rollout length or unrolled window [9, 34, 24] (Um et al. 2020). The learning problem can thus be formulated as the minimization of a global loss function , which depends on the sequence of hybrid states
where measures the discrepancy between the predicted trajectory and a target trajectory .
As in any gradient-descent based optimization procedure, training requires computing the sensitivity of the loss with respect to the trainable parameters . This quantity measures how perturbations of the sub-model parameters influence the trajectory-level objective through the coupled hybrid dynamics. In practice, these gradients are typically obtained using Backpropagation Through Time (BPTT), which is reviewed in the following section.
Gradient Approximation Methods for Backpropagation Through Time
Backpropagation Through Time
In BPTT, the total gradient of the loss with respect to the parameters is expressed as in Tallec and Ollivier [47]:
where is the adjoint vector at step , that is the sensitivity of the scalar loss with respect to the intermediate state . By the chain rule, the sequence of adjoint vectors satisfy an inhomogeneous backward recurrence:
In this recurrence, the vector-matrix product is a pullback operation along , where the adjoint vector, a cotangent on the state space is pulled back from step to step by contraction with the Jacobian matrix of evaluated at . The additional source term accounts for the direct dependence of the loss on a given state, independently of the adjoints propagated from later steps.
In differentiable programming, a pullback is constructed by reverse-mode automatic differentiation (AD) at a given linearization state, and each of its evaluations is a vector-Jacobian product (VJP). Two distinct pullbacks appear in the computation. The state-pullback contracts with to propagate the adjoint backward through (5), while the parameter-pullback contracts with to accumulate the parameter gradient in (4). We write and for their respective evaluations.
Because the recurrence in (5) is traversed backward in time, while each pullback is linearized at the corresponding forward state, evaluating it in general requires storing the entire sequence of intermediate forward states, together with the associated reverse-mode information, often referred to as the computation graph or tape. As the rollout length increases, the memory required to store this graph grows linearly, quickly becoming a prohibitive bottleneck ([47, 42]).
Truncated Backpropagation Through Time
Truncated Backpropagation Through Time (TBPTT) reduces the computational and memory cost of BPTT by partitioning the unrolled trajectory into independent temporal windows, where the standard adjoint recurrence (5) is retained only within each window. The memory required for the backward pass is thereby reduced, since the tape then spans a single window rather that the full trajectory. This method was first introduced for training Recurrent Neural Networks (RNNs) ([54]) and was later explored in data assimilation frameworks and hybrid modeling frameworks ([24]). For completeness, and to allow a comparison with the methods proposed below, we describe TBPTT in what follows.
We parameterize the degree of truncation by the window length , expressed in unrolled time steps. For a trajectory of steps, the corresponding number of windows is such that . Applying the truncation to (5) yields
At a truncation boundary the incoming adjoint is discarded and only the local source term is retained, so that no sensitivity crosses from one window to the next.
TBPTT therefore introduces a trade-off between memory usage and gradient fidelity. Increasing widens the backward window and retains richer long-range dependencies, at the cost of higher peak memory. Truncation changes neither the number of pullbacks constructed nor the number of VJPs evaluated over the trajectory; it only reduces how much of the tape must be held at once. However, discarding the incoming sensitivities across truncation boundaries introduces a systematic bias in the resulting gradient ([47, 48, 1, 24, 43]).
Pullback Approximation Methods for Backpropagation Through Time
Rather than discarding sensitivity information at window boundaries as TBPTT does, we propose a new class of gradient approximation methods that preserve the adjoint recurrence (5) over the full trajectory, while locally approximating the pullback operators within instead. The resulting gradients remain biased, but retain the long-range dependency structure of the exact adjoint. We refer to these as Pullback Approximation (PA) methods.
Similarly to TBPTT, PA partitions the trajectory of steps into chunks of length . Each chunk has a single anchor step at its midpoint, whose corresponding state is the linearization point for the whole chunk; exact state and parameter pullbacks are constructed by reverse-mode AD at only, and reused or replaced at every other step of . Under this approximation, the parameter gradient (5) becomes
so that the parameter pullback at step is linearized at the anchor state of its chunk rather than at . The approximate adjoint is obtained from a modified form of the recurrence (5), with indexing the two PA methods introduced below, Zero-order (ZO) and Pullback Reuse (Reuse).
Zero-order approximation
The Zero-order (ZO) approximation replaces the state pullback at non-anchor steps by the identity. This follows from the Taylor expansion of the time-stepping function with step size ,
in which every term beyond the leading one is , so the Jacobian can be approximated as
Assuming that is small enough, the adjoint is then propagated unchanged between anchors, and the recurrence (5) becomes, for every ,
Pullback Reuse
By replacing the state pullback with the identity, ZO discards the local dynamical information carried by the intermediate Jacobians. Pullback Reuse (Reuse) retains it at no additional memory cost, by reusing both, the anchor state and parameter pullbacks across the whole chunk rather than reconstructing them at every step, a strategy long used in implicit nonlinear solvers, discussed in4. This yields, for every ,
The resulting approximation error scales with the variation of the local Jacobian over the chunk, and vanishes as or .
Numerical implementation of the Pullback Approximation methods
The computational efficiency of both PA strategies stems from a factorization of the parameter gradient accumulation. To see this, it is useful to write the global sum (7) chunk by chunk. Since the linearization point is the same for all steps belonging to a given chunk, the sum splits into groups of consecutive terms:
where follows either ZO or Reuse recurrence given in (10) and (11) respectively.
Within each group, the parameter Jacobian no longer depends on the summation index . By linearity of the vector-Jacobian product, it can therefore be pulled out of the sum, so that the -th group reduces to a single product:
where is simply the sum of the approximate adjoints visited inside chunk . The parameter gradient then reads
Eq.(14) translates into an algorithm in which the backward pass follows a double-loop structure: an inner loop that accumulates the adjoint sensitivities within a chunk, and an outer loop that constructs the anchor pullbacks and evaluates (14). It can be summarized as follows:
Outer loop over chunks (anchor linearization and parameter pullback). The chunks are traversed backward, . Reverse-mode AD is invoked once at the anchor state to construct the two pullback operators and . Once the inner loop has completed, is added to the global parameter gradient.
Inner loop over steps (adjoint sensitivity accumulation). The steps of the chunk are traversed backward. At each step, the loss cotangent is incorporated, the state sensitivity is updated according to the chosen approximation, the identity for ZO or the reused operator for Reuse; the resulting is accumulated into .
The corresponding procedure is given in Algorithm 1 and illustrated schematically in Figure 1. Its practical consequence, in terms of computational complexity, is that the number of parameter pullback evaluations no longer scales with the rollout length , but with the number of chunks . Where exact BPTT evaluates one parameter per time step, the PA methods accumulate the sensitivities into through simple vector additions and apply only once per chunk. The gain is even larger for the ZO method, for which the state pullback is also evaluated only once per chunk, at the anchor step.

Figure 1. Schematic illustration of the factorized double-loop backward pass used by the Zero-order and Pullback Reuse approximations. The trajectory of model states is partitioned into chunks of length , each containing a single anchor step. During the inner loop, the local sensitivity combines the propagated state sensitivity with the loss cotangent at step . These step-wise sensitivities are accumulated within each chunk into , which is passed through the parameter VJP once per chunk to update the total parameter gradient .
Algorithm 1: Factorized double-loop backward pass for the Zero-order and Pullback Reuse approximations.
Input: anchor states , terminal sensitivity , loss cotangents
Output: total parameter gradient
1 g ← g_{N+1}, g_θ ← 0;
2 for i = K, …, 1 do
3 (VJPᵘ_i, VJP^θ_i) ← VJP(f, u^{anc}_{n_i}, θ); // construct the anchor pullbacks
4 S_i ← 0; // reset the accumulated chunk sensitivity
5 for n in chunk i, in reverse order do
6 g^m_n ← g + ∂L_N/∂u_n; // inject the loss cotangent
7 S_i ← S_i + g^m_n; // accumulate for the parameter VJP
8 if Zero-order then
9 g ← VJPᵘ_i(g^m_n) if n = n^{anc}_i, else g ← g^m_n; // identity off anchors
10 else
11 g ← VJPᵘ_i(g^m_n); // apply the frozen state VJP
12 end
13 end
14 g_θ ← g_θ + VJP^θ_i(S_i); // apply the parameter VJP once per chunk
15 end
16 return g_θ;
The theoretical computational cost and memory requirements of the proposed algorithms are reported in Table I, alongside those of standard exact BPTT, TBPTT and checkpointing [6]. The table summarizes the requirements of each algorithm, independently of the hardware on which it is run. The number of forward model steps includes both the initial forward pass together with the recomputations required to contruct the anchor pullbacks. The VJP counts distinguish the state and parameter vector–Jacobian products and . The peak memory estimates report the number of model states held simultaneously, together with the number of active AD residuals, that is, the intermediate quantities recorded by automatic differentiation during a single application of the time-stepping map . Overall, Table I shows that the PA methods substantially reduce memory requirements, by retaining a single residual at any time, while also reducing the number of pullback constructions and VJP evaluations during the backward pass.
| Algorithm | Forward model steps | Pullback constructions | VJP evaluations | Peak memory footprint |
| Exact BPTT | states + AD residuals | |||
| TBPTT | states + AD residuals | |||
| Zero-Order | states + 1 AD residual | |||
| Pullback Reuse | states + 1 AD residual | |||
| Checkpointing | states + AD residuals |
Table I. Theoretical complexity of the reverse-mode automatic differentiation algorithms considered in this work. denotes the total number of unrolled time steps, the number of chunks for the Pullback Approximation methods or of windows for TBPTT, the latter of length . A pullback construction corresponds to one taped forward evaluation of at the corresponding linearization state, while a VJP evaluation corresponds to one application of an already constructed pullback. Residuals denote the intermediate quantities recorded by automatic differentiation during a single application of .
Related works
Forward-mode versus reverse-mode differentiation. Parameter sensitivities can be propagated in either direction. Forward mode carries one tangent per parameter direction alongside the state, so nothing is stored and memory stays constant in the rollout length, but its cost grows linearly with the number of parameters, which rules it out for the neural sub-models considered here. Reverse mode runs the trajectory first and propagates the adjoint back through it: the cost becomes largely independent of the parameter count, at the price of retaining the computational graph [42]. For recurrent models, TBPTT [53, 54] and its unbiased variant [47] address the latter by truncating that graph. We instead keep the reverse-mode formulation intact and approximate the operators within it.
Gradient checkpointing. The standard way of reducing the memory footprint of reverse-mode differentiation is checkpointing, in which only a subset of the forward states is retained and the missing segments are recomputed on the fly during the backward pass. The strategy of Chen et al. (2016) stores checkpoints, bringing memory down to for the price of one extra forward pass; optimal schedules for a prescribed memory budget were derived earlier in the numerical-analysis literature [12], and the idea has since been carried over to recurrent architectures [13]. Checkpointing trades memory for computation while leaving the gradient exact: every pullback is still constructed and every VJP still evaluated. Conversely, the methods proposed here reduce both quantities instead, at the price of a gradient that is no longer exact.
Gradient approximation for non-differentiable operations. Replacing a Jacobian by the identity is a long-standing practice in deep learning. The straight-through estimator [3] propagates the incoming gradient unchanged through quantization or other non-differentiable operations, and similar surrogate backward passes are used for discrete sampling [17] and binarized networks [16]. These estimators are biased by construction, yet they remain effective for optimization, which is precisely the behavior we observe for the ZO method. The setting however differs: in deep learning, the identity substitutes a Jacobian that does not exist, whereas here it approximates a Jacobian that exists and is close to the identity for small time steps, so the approximation carries an order of accuracy in rather than purely heuristic justification.
Jacobian reuse Freezing a Jacobian over several iterations is standard practice in numerical analysis. Modified Newton and quasi-Newton methods reuse a factorization computed at an earlier iterate rather than re-evaluating it at every step [5, 2], and implicit time-integration solvers refresh the Jacobian only periodically, balancing the cost of its evaluation against the convergence rate of the inner solve [14, 15]. Pullback Reuse transposes this practice to the backward pass of an unrolled trajectory, reusing the anchor state pullback across a chunk instead of reconstructing it at every step. The consequence of a stale linearization is however not the same in the two settings: an implicit solve is self-correcting, in that a Jacobian evaluated away from the current iterate slows convergence but leaves the converged solution exact, whereas a backward pass has no inner iteration to absorb the error, so a frozen pullback propagates into the parameter gradient as a bias. This is what motivates the gradient-fidelity diagnostics reported in § 5.
Experimental setup, analyses and results
We evaluate the gradient approximation methods on three systems of increasing complexity: the Lorenz-63 system, a two-dimensional large-eddy simulation of quasi-geostrophic turbulence, and a semi-realistic multilayer quasi-geostrophic model of the western Mediterranean Sea. Each case study is presented in turn, with its configuration followed directly by its results.
For each case study we conduct two complementary analyses. The first quantifies how accurately each approximation reproduces the exact gradient, and at what computational cost. Gradient fidelity is measured by the cosine similarity with the exact gradient: since gradient-based optimization is driven by the descent direction rather than by the gradient magnitude, this quantifies how well an approximation preserves the optimization direction. All methods are implemented in JAX; peak memory is estimated from XLA’s post-compilation buffer analysis, and execution time from synchronized runs of the compiled functions.
The second assesses whether the approximate gradients remain sufficiently informative to train hybrid models. The hybrid models are trained by minimizing an online objective function of the form (3), based on the mean squared error of the simulated state variables over a rollout of length . The exact formulation of the online loss for each case study is given in Appendix § 9.
Both analyses are carried out for several degrees of approximation . For TBPTT, is the window length; for the Pullback Approximation methods, is the number of chunks, and hence of anchor points. In both cases a smaller means a more aggressive approximation. The two families are aligned by degree of approximation rather than by partition size.
Lorenz-63
The Lorenz-63 (L63) system is a simplified model of atmospheric convection consisting of three coupled, first-order nonlinear differential equations (18), where the state vector is given by and , and are positive constants. We use the standard values , and , for which the system chaotic and its trajectories converge to the Lorenz attractor [25].
The hybrid setup follows (1). The dynamical model is an incomplete L63 system (19) in which the term has been removed which prevents the model from reproducing the true attractor. A sub-model is then coupled to it (20) to compensate for the missing dynamics. Since the source of model error is unknown in realistic settings, the correction is applied to all three prognostic equations rather than to the modified one.
The sub-model is a fully connected multilayer perceptron with a single hidden layer of 32 units and ReLU activations, mapping the three-dimensional state to a three-dimensional correction added to the model tendency. The reference data are generated with the true system (15a) after a spin-up of 5 L63 time units, so that the trajectory lies on the attractor. We sample points at , corresponding to time units, and use the first 70% for training and the last 20% for testing; the intermediate 10% is discarded to avoid temporal leakage. The training setup is summarized in the Appendix B: tbl:2.
Gradient fidelity and computational cost
Figure 2 summarizes the fidelity and cost of TBPTT, ZO and Reuse relative to exact BPTT, across increasing unrolled trajectory lengths and degrees of approximation . The results reveal a trade-off between the two, with gradient fidelity depending on both quantities.
Figure 2. Gradient fidelity and computational performance comparison of the approximate gradient methods relative to exact BPTT for the hybrid L63 model (incomplete L63 plus sub-model correction. Cosine similarity is computed with respect to the exact gradient, both at initialization (pre-training) and after successful training. Parameter controls the degree of approximation, with smaller values corresponding to a more aggressive approximation.
Before training, all three methods track the exact gradient direction closely, with cosine similarity above 0.8 over the full range tested, and Reuse remains almost perfectly aligned throughout. After training, the agreement breaks down unevenly and TBPTT and ZO degrade rapidly as increases and decreases, while Reuse stays close to 1 over a much wider range.
This contrast can be understood dynamically. Before training, the incomplete model collapses onto a fixed point rather than the true L63 attractor, so the local Jacobians vary little from step to step and even a coarse approximation remains accurate. After training, the hybrid model recovers the full attractor and the trajectory becomes chaotic, so the adjoint is subject to exponential divergence that scales with the rollout length . In that regime, retaining some curvature information within each chunk, as Reuse does through its frozen anchor Jacobian, preserves the descent direction far more reliably than truncating the recurrence (TBPTT) or discarding the local state sensitivity transformation (ZO).
Regarding peak memory and runtime, the memory ratio falls with , since the footprint of exact BPTT grows faster, and rises with , as larger windows (TBPTT) and more anchors (PA) both retain more information in the tape. Runtime separates the methods more clearly. TBPTT repeats the same forward and backward passes as exact BPTT, so no speedup is expected, and none is observed for ; the apparent speedup at is an implementation effect,which we attribute to the compiler fusing backward-pass operations, and thereby avoiding the storing and reloading of intermediate states. Such an effect is only visible when a single step time step costs little against the loop overhead, as for L63, but not for the quasi-geostrophic system of Section 5.2. ZO and Reuse both improve with and are fastest at the fewest anchors. Reuse is consistently ahead of ZO here, despite the latter saving additional VJP evaluations. With three state variables and a compact MLP, a VJP evaluation is cheap, so the conditional branch ZO applies at anchor steps costs more than the operations it avoids, which is no longer true for the larger quasi-geostrophic system in Section 5.2.
Training with approximate gradients
The analyses above characterize the intrinsic properties of the approximations in terms of gradient accuracy and computational efficiency. In this section, we evaluate whether the resulting gradients remain informative enough to optimize a hybrid model. In this context, we train identical models with exact BPTT, TBPTT, ZO and Reuse under identical optimization settings.
Comparable losses do not necessarily imply comparable learned dynamics, particularly for a chaotic system, so we also evaluate the trained models in phase space. Figure 4 shows that all methods, down to the the configurations with the fewest anchors, recover the characteristic two-lobed geometry of the Lorenz attractor, even though individual trajectories diverge. The approximate gradients are therefore sufficient for the optimizer to recover a correction that reproduces the right dynamics, despite following different optimization paths.
Figure 4. Lorenz-63 trajectories generated by the post-training models over 2 Lorenz-63 time units (2,000 time steps). The models were trained for 250 epochs with a training window of unrolled time steps. Results are shown for Exact BPTT, TBPTT, Zero-Order, and Reuse Gradient, with the latter three evaluated at , 4, and 6.
Figure 3. Evolution of the training and test losses over 250 epochs for the exact BPTT, TBPTT, Zero-order, and Pullback Reuse gradient methods with , and . The MLP is trained using a training window of N=12 unrolled timesteps.
Large eddy simulation of quasi-geostrophic turbulence
In this second experiment, we consider Quasi-Geostrophic (QG) dynamics, a workhorse of geophysical fluid dynamics, valid where the flow is hydrostatic and the Coriolis acceleration balances the horizontal pressure gradient.
Over a doubly periodic square domain with a side length , the dimensionless governing equations for vorticity and streamfunction are
where, is the nonlinear advection term:
and is a deterministic forcing
We consider a large eddy simulation (LES) setting in which both fields are filtered with a Gaussian filter ([40]), denoted . Applying the filter to (16a)–(16b) yields
Solving the LES at a coarser resolution than a direct numerical simulation (DNS) of (16a)–(16b) is considerably cheaper, but requires a closure for the subgrid-scale (SGS) term . Here is parameterized by a convolutional neural network (CNN) that takes as inputs both the vorticity and streamfunction fields . Together, the LES solver and the CNN sub-model form a hybrid model of the form introduced in § 2.
The reference DNS trajectory is initialized using a random Gaussian vorticity field on a 1024 x 1024 grid, and spun up for 200,000 steps to reach statistical equilibrium, after which a trajectory of 2,000,000 steps is generated with a timestep . The target dataset is obtained by spatially filtering this trajectory with Gaussian filter of width , coarse-graining to a 64 x 64 LES grid, and sampling at the LES timestep , that is one snapshot every 16 DNS steps. The resulting dataset is split into 50 physical time units for training and 20 for validation.
The CNN is trained over a rollout of steps. In what follows we benchmark the gradient approximation methods against the exact BPTT gradient baseline, to assess their efficacy and stability on this online learning problem.
Gradient fidelity and computational cost
The cosine similarity reported in Figure 5 remains high for all tested methods. TBPTT and ZO degrade gradually as the unrolling length increases, whereas Reuse stays almost perfectly aligned with the exact gradient at every degree of approximation . Suggesting that for QG dynamics, the level of approximation could therefore be pushed further without noticeably degrading the gradient.
Figure 5. Gradient fidelity and computational performance of the approximate gradient methods relative to Exact BPTT, for the double-periodic single-layer hybrid QG model (LES plus CNN closure). Cosine similarity is computed with respect to the exact gradient, both at initialization (pre-training) and after successful training. For TBPTT, denotes the chunk size; for Zero-Order and Reuse, it denotes the number of chunks (anchor points). In all cases, controls the degree of approximation.
The separation in peak memory between TBPTT and the PA methods is much clearer here than for L63. Each model state and its associated residuals are far larger in this higher-dimensional system, since a single application of involves spectral transforms and the intermediate Runge-Kutta stages, so differences in the amount of active backward-pass information show up directly. ZO and Reuse retain a single active residual at a time, whereas TBPTT keep the states and residuals of its entire truncation window, and the measured memory ratio grows with the truncation window with accordingly. Notably, TBPTT at approximately coincides with the PA methods, confirming that the residuals account for essentially all of the memory these methods save.
Runtime separates the methods further. TBPTT provides essentially no speedup over exact BPTT. Truncation reduces what is held in memory at once, but the same sequence of state and parameter pullbacks is still evaluated over the full trajectory, so the memory saving does not translate into time. Reuse is slightly faster at the most aggressive approximation levels () and a slower elsewhere, reflecting two competing effects: the saving from adjoint factorization of § 3.4, and the cost of constructing a pullback at each anchor. Few anchors means few constructions and the factorization dominates; with many anchors the recomputation overhead outweighs it. ZO instead skips the state VJP entirely between anchors, reaching a speedup of to over exact BPTT at the most aggressive . Read alongside the L63 results in § 5.1.1, this confirms that the extra evaluations retained by Reuse dominate once the state dimension is large enough for a VJP to be expensive.
Training with approximate gradients
Figure 6 shows the training and test losses. All methods follow the same convergence pattern, both losses decreasing rapidly toward a common low-loss regime. The optimization paths separate slightly during parts of training, but these differences are small relative to the overall reduction in loss, and convergence does not degrade systematically as decreases. This is consistent with the cosine similarities of Figure 5, where every method stays closely aligned with the exact gradient at all approximation levels. We further evaluate the trained models in free-running long-term simulations.
Figure 6. Evolution of the training and test losses over 20 epochs for the Exact BPTT, TBPTT, Zero-Order, and Reuse Gradient methods with and . The CNN is trained using a window of unrolled timesteps.
Figure 7 shows the post-training evolution of the vorticity field for the models trained with the exact BPTT and the Reuse gradients, together with the No SGS simulation; the other methods behave similarly and are not shown. Without a subgrid-scale closure, the simulation progressively develops spurious small-scale, spatially and incoherent vorticity fluctuations. Both hybrid models instead maintain coherent structures whose spatial scales and vorticity magnitudes match the reference throughout the simulated interval. The two decorrelate progressively, as expected for a chaotic system, but their overall organization and order of magnitude remain comparable to the ground truth. The Reuse gradient is therefore sufficient to maintain a stable correction and to recover the resolved-scale dynamics from sparser gradient information than exact BPTT.
Figure 7. Post-training evolution of the vorticity field at selected times (–) for the Ground Truth, No SGS, Exact, and Reuse () simulations. The CNN was trained for 20 epochs using a window of unrolled time steps.
Bias correction of a multilayer quasi-geostrophic ocean model
To evaluate the proposed methods in a more realistic setting, we take the dynamical core to be a multilayer quasi-geostrophic (GC) ocean model. We use a JAX implementation of MQGeometry [50], a differentiable multilayer QG solver based on the formulation of [49]. Rather than evolving the potential vorticity, MQGeometry recasts the QG equations as a projection of the multilayer rotating shallow water (RSW) equations, with the state expressed in terms of the horizontal velocities and the layer-thickness anomaly, . The system evolves under the full nonlinear RSW operator while the projection onto the geostrophic manifold filters fast ageostrophic motions, . Advection uses high-order upwind-biased WENO reconstructions, whose implicit dissipation removes the need for explicit hyperviscosity. Full details are given in [49 b].
The configuration is a regional western Mediterranean domain spanning – and –, discretized on a grid at approximately 5 km resolution. The water column is represented by three layers of 75 m, 400 m and 2525 m respectively, denoted Surface, Middle and Bottom, and chosen to match the typical stratification of the area [30]. Bathymetry is only used to define the continental boundaries and to exclude regions shallower than 100 m. Surface forcing is prescribed from a monthly mean winds for 2010, converted to wind stress with a constant drag coefficient and interpolated in space and time; bottom stress follows a linear friction law with constant coefficient . Physical and numerical parameters are summarized in Appendix § 10:, Table IV.
| Parameter | Value | Description |
| Domain size | ||
| Grid dimensions | ||
| Spatial resolution | ||
| Number of vertical layers | ||
| Reference layer thickness | ||
| Reduced gravity | ||
| Bottom drag coefficient | ||
| Wind stress magnitude | ||
| Reference density | ||
| Mean Coriolis parameter | ||
| Coriolis gradient | ||
| — | Slip coefficient (lateral boundaries) | |
| Time step | ||
| — | RK3-SSP | Time-integration scheme |
Table IV. Physical and numerical parameters for the Western Mediterranean configuration of the multilayer quasi-geostrophic model.
The structural bias is introduced by amplifying the bottom drag coefficient by a factor of five. Bottom drag enters the bottom-layer momentum tendencies as a linear damping of the horizontal velocities, and its effect propagates upward through coupling between baroclinic modes, so that relatively small changes in produce significant differences in kinetic energy and circulation. We restore the correct dynamics in two ways, by calibrating directly and by correcting the QG tendencies with a neural network.
In the first strategy, is treated as a learnable scalar and calibrated by gradient descent on . No sub-model is involved, so this is not a hybrid setup, but it remains an online problem and provides a transparent baseline for the convergence and fidelity of the proposed methods. In the second strategy, a sub-model is coupled to the biased model following (1) and learns to correct its tendencies. Since the source of model error is unknown in realistic settings, the correction is applied to all prognostic equations and all three vertical layers rather than to the bottom-layer momentum alone. The sub-model is a compact CNN with two convolutional layers of 64 and 32 feature maps, both with kernels followed by ReLU activations, and a final convolution mapping to the output channels.
The true dynamics are spun up from rest over twenty years, with the domain-averaged kinetic energy monitored until equilibrium. The final spin-up state initializes a five-year ground-truth simulation, saved every two hours, of which 70% is used for training and 20% for testing, the intermediate 10% being discarded to avoid temporal leakage. Training uses a rollout of steps. The remaining hyperparameters are given in Appendix § 10; Table V.
| Parameter | calibration | Sub-model training |
| Numerical solver | RK3-SSP | RK3-SSP |
| Loss function | Normalized MSE, Eq. (27) | Normalized MSE, Eq. (27) |
| Optimizer | Adam | Adam |
| Rollout length | ||
| Trainable parameters | (1 scalar) | CNN weights (1456) |
| Learning rate | (constant) | (cosine schedule) |
| Batch size | ||
| Optimization budget | 250 iterations | 15 epochs |
Table V. Training setup and hyperparameters for the two experiments on the Western Mediterranean configuration of the multilayer quasi-geostrophic model.
Parameter calibration
Figure 8 shows the training loss and the evolution of the learned bottom drag coefficient . All methods move rapidly away from the biased initial value toward the ground truth. The approximate methods fluctuate more from one iteration to the next, with occasional jumps in the loss, but converge to the correct within a comparable number of iterations. This extends the L63 result to a more complex dynamical system, with the optimization problem kept deliberately simple by the use single trainable parameter. The approximate gradients therefore carry enough information to calibrate a physical parameter.
Figure 8. Training loss (left) and evolution of the learned bottom-drag coefficient (right) over 250 optimization iterations, for the exact BPTT, TBPTT, Zero-Order, and Pullback Reuse methods with , 4, 6. Horizontal lines in the right panel mark the ground truth and biased values of . All methods use a rollout of steps.
Neural-network tendency correction
Figure 9 shows the training and test losses for the CNN correction. All methods converge similarly, with both losses decreasing rapidly toward a common low-loss regime and no systematic degradation as the number of anchor points is reduced. The loss of the CNN trained with TBPTT however, remains above the other methods for part of the optimization before catching up. As in L63, approximate gradients can alter the optimization path without preventing convergence to a comparable final regime. The fact that this also holds for a high-dimensional CNN correction indicates that their usefulness is not limited to single-parameter calibration.
Figure 9. Evolution of the training and test losses over 15 epochs for the exact BPTT, TBPTT, Zero-order, and Reuse Gradient methods with . For all methods, the CNN was trained with a rollout steps.
Beyond convergence of the online learning objective, we evaluate the trained models in long-term free-running simulations. Figure 10 shows the evolution of the domain-averaged eddy kinetic energy (EKE) in the bottom layer over five years. The biased model exhibits strongly reduced EKE, consistent with its excessive bottom drag, whereas all trained corrections recover values in the same range as the ground truth and hold them for the full five years. The individual trajectories track one another early on before progressively diverging, as expected in a chaotic system.
Figure 10. Evolution of the domain-averaged eddy kinetic energy (EKE) in the bottom layer over the 5-year simulation period following training. The CNN was trained with a rollout steps.
To determine whether this recovery extends beyond a bulk statistic, we finally examine the spatial structure of the circulation. Figure 11 compares the final bottom-layer relative vorticity after five years for the ground-truth, biased and trained simulations. The biased field is markedly weaker, again reflecting the excessive drag, while the trained corrections recover stronger and more coherent vorticity structures, closer to the ground truth.
Figure 11. Final bottom-layer relative vorticity after five years of simulation, for the ground-truth, biased and debiased runs. The debiased run applies a CNN correction to the biased model; the CNN was trained over 15 epochs with the Pullback Reuse approximation, a rollout of steps and .
Discussion and Conclusion
Differentiable programming is opening new avenues for online learning in numerical modeling, with a growing number of studies using differentiable models to compute sensitivities for model calibration and to train components within a hybrid modeling framework. The computational cost and memory requirements of the backward pass however, grow with both the length of the unrolled trajectory and the dimensionality of the model state, constraining the temporal horizon over which learning can be performed and the spatial resolution at which numerical models that can be trained.
We propose a class of gradient approximation methods for backpropagation through numerical solvers, that reduce this cost while keeping the gradient accurate enough for optimization. The proposed methods go beyond TBPTT, which discards the sensitivities arriving at truncation boundaries, by preserving the adjoint recurrence over the full trajectory and approximating only the pullback operators within it. Exact pullbacks are constructed only at a sparse set of anchor points. Between anchors, Zero-Order propagates the adjoint through the identity, while Pullback Reuse applies the frozen anchor Jacobian. Since the same parameter pullback is shared across all steps within a chunk, the parameter-gradient sum can be factorized, reducing the number of parameter pullbacks from one per time step to one per chunk.
We evaluated the methods on three systems of increasing complexity, from the low-dimensional Lorenz-63 model to two-dimensional quasi-geostrophic turbulence and a semi-realistic multilayer ocean configuration. In all three, the approximate gradients converge to a loss regime comparable to exact BPTT and recover the reference dynamics, whether the trainable component is a single physical coefficient or a sub-model. Gradient fidelity depends on both the rollout length and the approximation level, with Pullback Reuse consistently giving the highest directional agreement with the exact gradient. On the quasi-geostrophic cases, the proposed methods reduce peak memory by about an order of magnitude, and Zero-order reaches a speedup of roughly four times over exact BPTT while the cosine similarity with the exact gradient stays above 0.7.
Longer-horizon experiments could reveal an additional effect of pullback approximation beyond computational savings. By changing how sensitivity information propagates through the trajectory, approximate pullbacks may alter the accumulation of unstable gradient components and influence optimization stability. Related work has shown that training-horizon choices and truncated gradient propagation can affect the stability and long-term behavior of learned dynamical systems [23]; whether the proposed pullback approximation methods provide a similar stabilizing effect, while retaining more temporal sensitivity information than conventional truncation, remains open.
The Pullback Approximation is currently controlled by a fixed number of anchors. This gives a simple and reproducible handle on the cost–fidelity trade-off, but applies the same backward resolution throughout the trajectory regardless of the local dynamics. Making the refresh interval adaptive is a natural extension, reconstructing exact pullbacks when an estimate of the approximation error grows too large and reusing them longer when it does not. Possible criteria could include changes in the system’s state or energy, measures of local perturbation growth, and indicators of gradient agreement. Such an error-controlled strategy could allocate computational effort where accurate sensitivity information is most important.
Taken together, these results indicate that substantial reductions in the cost of reverse-mode differentiation are compatible with successful online training of hybrid dynamical models. The proposed methods do not reproduce the exact BPTT gradient, yet the approximate backward passes retain enough information for optimization while cutting the number expensive pullback constructions. Zero-Order and Pullback Reuse are two instances of this idea rather than a closed set, and other backward pass approximations could be explored within the same framework to target different balances between cost and gradient fidelity. If those trade-offs can be exploited effectively, they offer a route toward differentiable online learning at longer rollouts and larger scales than exact BPTT currently permits.
Acknowledgments
The authors gratefully acknowledge IMT Atlantique, Lab-STICC, and the Odyssey research team for their support. This work was supported in part by the Région Bretagne and the Brittany doctoral school, and in part by the Horizon Europe project AI4PEX (grant agreement 101137682).
S.O. was supported by the SequoIA AI Cluster Chair HROMS, funded by the Agence Nationale de la Recherche (ANR-23-IACL-0009), and by ANR–France 2030 as part of the PEPR TRACCS program (ANR-25-EXTR-0008). He also received funding from the ANR Chair AI4Extremes and from the French national program LEFE (Les Enveloppes Fluides et l’Environnement) under project OL4ROMS.
Code and Data Availability
No observational data were used in this study. All datasets used for training and evaluation are synthetic and generated by the simulation code. The code implementing the gradient approximation methods and the numerical experiments reported in this manuscript is publicly available at:
https://github.com/emiliogz0/approx_adjoint_models_online_learning.git
Online objectives for the considered use cases
Lorenz-63 system. The online objective is the mean squared error between the state predicted by the hybrid model, , and the reference trajectory generated by the classical Lorenz-63 system, , with . The error is accumulated over the rollout of length and averaged over the three state variables,
Large-eddy simulation of quasi-geostrophic turbulence. The online objective is the mean squared error between the filtered vorticity predicted by the hybrid LES, and the filtered DNS reference, accumulated over the rollout of length and averaged over the LES grid ,
where is the number of LES grid points.
Multilayer quasi-geostrophic Western Mediterranean experiment. For both the bottom-drag calibration and the neural-correction experiments, the online objective is the normalized mean squared error between the hybrid-model and reference trajectories. The error is evaluated at the observation times within the rollout window and over the full prognostic state, comprising the horizontal velocities and the layer-thickness anomaly ,
where denotes field in layer , is the number of layers, and is the set of ocean grid points associated with field , land points being excluded from the loss. The normalization is the root-mean-square amplitude of field in layer , computed over ocean points in the training set.
Simulation configuration and hyperparameters
| Parameter | Value |
| Numerical solver | RK4 |
| Loss function | MSE |
| Optimizer | Adam |
| Learning rate | (constant) |
| Rollout length | 12 |
| Batch size | 20 |
| Epochs | 250 |
Table II. Training setup and hyperparameters for the Lorenz-63 experiment.
| Parameter | Value |
| Numerical solver | RK4 |
| Loss function | MSE |
| Optimizer | Adam |
| Learning rate | (constant) |
| Rollout length | 40 |
| Batch size | 20 |
| Epochs | 20 |
Table III. Training setup and hyperparameters for the quasi-geostrophic turbulence large-eddy simulation experiment.
References
- [1]Aicher, C., Foti, N., and Fox, E., 2020. Adaptively Truncating Backpropagation Through Time to Control Gradient Bias. Proceedings of The 35th Uncertainty in Artificial Intelligence Conference, PMLR, pages 799–808.arxiv.org/abs/1905.07473
- [2]Alexander, R., 1991. The Modified Newton Method in the Solution of Stiff Ordinary Differential Equations. Mathematics of Computation, 57(196):673–701. doi:10.2307/2938711.DOI
- [3]Bengio, Y., Léonard, N., and Courville, A., 2013. Estimating or Propagating Gradients Through Stochastic Neurons for Conditional Computation. arXiv preprint arXiv:1308.3432.arxiv.org/abs/1308.3432
- [5]Broyden, C., 1965. A Class of Methods for Solving Nonlinear Simultaneous Equations. Mathematics of Computation, 19(92):577–593. doi:10.2307/2003941.DOI
- [6]Chen, T., Xu, B., Zhang, C., and Guestrin, C., 2016. Training Deep Nets with Sublinear Memory Cost. arXiv preprint arXiv:1604.06174.arxiv.org/abs/1604.06174
- [7]Christensen, H. and Zanna, L., 2022. Parametrization in weather and climate models. doi:10.1093/acrefore/9780190228620.013.826.
- [8]Frezat, H., Balarac, G., Le Sommer, J., Fablet, R., and Luqensat, R., 2021. Physical invariance in neural networks for subgrid-scale scalar flux modeling. Physical Review Fluids, 6(2):024607. doi:10.1103/PhysRevFluids.6.024607.DOI
- [9]Frezat, H., Le Sommer, J., Fablet, R., Balarac, G., and Lguensat, R., 2022. A Posteriori Learning for Quasi-Geostrophic Turbulence Parametrization. Journal of Advances in Modeling Earth Systems, 14(11):e2022MS003124. doi:10.1029/2022MS003124.DOI
- [10]Germano, M., Piomelli, U., Moin, P., and Cabot, W., 1991. A dynamic subgrid-scale eddy viscosity model. Physics of fluids. A, Fluid dynamics, 3(7):1760–1765. doi:10.1063/1.875955.
- [11]Ghosal, S., 1999. Mathematical and Physical Constraints on Large-Eddy Simulation of Turbulence. AIAA Journal, 37(4):425–433. doi:10.2514/2.752.DOI
- [12]Griewank, A. and Walther, A., 2000. Algorithm 799: revolve: an implementation of checkpointing for the reverse or adjoint mode of computational differentiation. ACM Trans. Math. Softw., 26(1):19–45. doi:10.1145/347837.347846.
- [13]Gruslys, A., Munos, R., Danihelka, I., Lanctot, M., and Graves, A., 2016. Memory-Efficient Backpropagation Through Time. Advances in Neural Information Processing Systems, volume 29, Curran Associates, Inc.arxiv.org/abs/1606.03401
- [14]Gustafsson, K. and Söderlind, G., 1997. Control Strategies for the Iterative Solution of Nonlinear Equations in ODE Solvers. SIAM Journal on Scientific Computing, 18(1):23–40. doi:10.1137/S1064827595287109.DOI
- [15]Hindmarsh, A., Brown, P., Grant, K., Lee, S., Serban, R., Shumaker, D., and Woodward, C., 2005. SUNDIALS: Suite of nonlinear and differential/algebraic equation solvers. ACM Trans. Math. Softw., 31(3):363–396. doi:10.1145/1089014.1089020.DOI
- [16]Hubara, I., Courbariaux, M., Soudry, D., El-Yaniv, R., and Bengio, Y., 2016. Binarized Neural Networks. Advances in Neural Information Processing Systems, volume 29, Curran Associates, Inc.
- [17]Jang, E., Gu, S., and Poole, B., 2017. Categorical Reparameterization with Gumbel-Softmax. arXiv preprint arXiv:1611.01144.arxiv.org/abs/1611.01144
- [18]Jansen, M. and Held, I., 2014. Parameterizing subgrid-scale eddy effects using energetically consistent backscatter. Ocean Modelling, 80:36–48. doi:10.1016/j.ocemod.2014.06.002.DOI
- [19]Kitsios, V., Frederiksen, J., and Zidikheri, M., 2013. Scaling laws for parameterisations of subgrid eddy–eddy interactions in simulations of oceanic circulations. Ocean Modelling, 68:88–105. doi:10.1016/j.ocemod.2013.05.001.DOI
- [20]Kochkov, D., Yuval, J., Langmore, I., Norgaard, P., Smith, J., Mooers, G., Klöwer, M., Lottes, J., Rasp, S., Düben, P., Hatfield, S., Battaglia, P., Sanchez-Gonzalez, A., Willson, M., Brenner, M., and Hoyer, S., 2024. Neural general circulation models for weather and climate. Nature, 632(8027):1060–1066. doi:10.1038/s41586-024-07744-y.DOI
- [21]Lam, R., Sanchez-Gonzalez, A., Willson, M., Wünschberger, P., Fortunato, M., Alef, F., Ravuri, S., Ew alds, T., Eaton-Rosen, Z., Hu, W., Mer ose, A., Hoyer, S., Holland, G., Vinyals, O., Stott, J., Pritzel, A., Mohamed, S., and Battaglia, P., 2023. Learning skillful medium-range global weather forecasting. Science, 382(6677):1416–1421. doi:10.1126/science.adi2336.DOI
- [22]Leonard, A., 1975. Energy Cascade in Large-Eddy Simulations of Turbulent Fluid Flows. In Frenkiel, F. and Munn, R., editors, Turbulent Diffusion in Environmental Pollution, volume 18 of Advances in Geophysics. Elsevier, pages 237–248. doi:10.1016/S0065-2687(08)60464-1.DOI
- [23]List, B., Chen, L., and Thuerey, N., 2022. Learned turbulence modelling with differentiable fluid solvers: physics-based loss functions and optimisation horizons. Journal of Fluid Mechanics, 949:A25. doi:10.1017/jfm.2022.738.DOI
- [24]List, B., Chen, L., Bali, K., and Thuerey, N., 2025. Differentiability in unrolled training of neural physics simulators on transient dynamics. Computer Methods in Applied Mechanics and Engineering, 433:117441. doi:10.1016/j.cma.2024.117441.DOI
- [25]Lorenz, E., 1963. Deterministic Nonperiodic Flow. Journal of the Atmospheric Sciences, 20(2):130–141. doi:10.1175/1520-0469(1963)020<0130:DNF>2.0.CO;2.doi.org/10.1175/1520-0469(1963)020<0130:dnf>2.0.co;2
- [26]Maddison, J., 2026. Online Learning in Idealized Ocean Gyres. Journal of Advances in Modeling Earth Systems, 18(2):e2024MS004883. doi:10.1029/2024MS004883.DOI
- [27]Mason, P., 1994. Large-eddy simulation: A critical review of the technique. Quarterly Journal of the Royal Meteorological Society, 120(515):1–26. doi:10.1002/qj.49712051503.DOI
- [28]Meneveau, C. and Katz, J., 2000. Scale-Invariance and Turbulence Models for Large-Eddy Simulation. Annual Review of Fluid Mechanics, 32:1–32. doi:10.1146/annurev.fluid.32.1.1.DOI
- [29]Meunier, E., Ouala, S., Frezat, H., Le Sommer, J., and Fablet, R., 2025. Towards fully differentiable neural ocean model with Veros. arXiv preprint arXiv:2511.17427.arxiv.org/abs/2511.17427
- [30]Millot, C., 1999. Circulation in the Western Mediterranean Sea. Journal of Marine Systems, 20(1):423–442. doi:10.1016/S0924-7963(98)00078-5.DOI
- [31]Moin, P. and Mahesh, K., 1998. Direct numerical simulation: a tool in turbulence research. Annual Review of Fluid Mechanics, 30:539–578. doi:10.1146/annurev.fluid.30.1.539.DOI
- [32]Ouala, S., Nguyen, D., Drumetz, L., Chapron, B., Pascual, A., Collard, F., Gaultier, L., and Fablet, R., 2020. Learning Latent Dynamics for Partially-Observed Chaotic Systems. Chaos: An Interdisciplinary Journal of Nonlinear Science, 30(10). doi:10.1063/5.0019039.
- [33]Ouala, S., Chapron, B., Collard, F., Gaultier, L., and Fablet, R., 2023a. Extending the extended dynamic mode decomposition with latent observables: the latent EDMD framework. Machine Learning : Science and Technology, 4(2):025018. doi:10.1088/2632-2153/accd6.DOI
- [34]Ouala, S., Chapron, B., Collard, F., Gaultier, L., and Fablet, R., 2024. Online calibration of deep learning sub-models for hybrid numerical modeling systems. Communications Physics, 7(1):402. doi:10.1038/s42005-024-01880-7.
- [36]Pathak, J., Subramanian, S., Harrington, P., Raja, S., Chattopadhyay, A., Mardani, M., Kurth, T., Hall, D., Li, Z., Azizzadenesheli, K., Hassanzadeh, P., Kashinath, K., and Anandkumar, A., 2022. FourCastNet: A Global Data-driven High-resolution Weather Model using Adaptive Fourier Neural Operators. arXiv preprint arXiv:2202.11214.arxiv.org/abs/2202.11214
- [37]Piomelli, U., Cabot, W., Moin, P., and Lee, S., 1991. Subgrid-scale backscatter in turbulent and transitional flows. Physics of Fluids A: Fluid Dynamics, 3(7):1766–1771. doi:10.1063/1.857956.DOI
- [38]Pope, S., 2000. Turbulent flows, volume 20. Cambridge university press, Cambridge.DOI
- [39]Rasp, S., 2020. Coupled online learning as a way to tackle instabilities and biases in neural network parametrizations: general algorithms and Lorenz 96 case study (v1.0). Geoscientific Model Development, 13(5):2185–2196. doi:10.5194/gmd-13-2185-2020.
- [40]Sagaut, P. and Levasseur, V., 2005. Sensitivity of spectral variational multiscale methods for large-eddy simulation of isotropic turbulence. Physics of Fluids, 17(3):035113. doi:10.1063/1.1863243.DOI
- [41]Sandham, N., Johnstone, R., and Jacobs, C., 2017. Surface-sampled simulations of turbulent flow at high Reynolds number. International Journal for Numerical Methods in Fluids, 85(9):525–537. doi:10.1002/fld.4395.DOI
- [42]Sapienza, F., Bolibar, J., Schäfer, F., Groënke, B., Pal, A., Boussange, V., Heimbach, P., Hooker, G., Pérez, F., Persson, P., and Rackauckas, C., 2025. Differentiable Programming for Differential Equations: A Review. arXiv preprint arXiv:2406.09699.DOI
- [43]Schnell, P. and Thuerey, N., 2024. Stabilizing Backpropagation Through Time to Learn Complex Physics. arXiv preprint arXiv:2405.02041.arxiv.org/abs/2405.02041
- [44]Smagorinsky, J., 1963. General circulation experiments with the primitive equations: I. the basic experiment. Monthly Weather Review, 91(3):99–164. doi:10.1175/1520-0493(1963)091<0099:GCEWTP>2.3.CO;2.doi.org/10.1175/1520-0493(1963)091<0099:gcewtp>2.3.co;2
- [45]Spalart, P. and Allmaras, S., 1992. A one-equation turbulence model for aerodynamic flows. In 30th Aerospace Sciences Meeting and Exhibit. American Institute of Aeronautics and Astronautics, page 439. doi:10.2514/6.1992-439.DOI
- [46]Stumm, P. and Walther, A., 2010. New Algorithms for Optimal Online Checkpointing. SIAM Journal on Scientific Computing, 32(2):836–854. doi:10.1137/080742439.DOI
- [47]Tallec, C. and Ollivier, Y., 2017. Unbiasing Truncated Backpropagation Through Time. arXiv preprint arXiv:1705.08209.arxiv.org/abs/1705.08209
- [48]Tang, H. and Glass, J., 2018. On Training Recurrent Networks with Truncated Backpropagation Through Time in Speech Recognition. arXiv preprint arXiv:1807.03396.arxiv.org/abs/1807.03396
- [49]Thiry, L., Li, L., Mémin, E., and Roullet, G., 2024a. A Unified Formulation of Quasi-Geostrophic and Shallow Water Equations via Projection. Journal of Advances in Modeling Earth Systems, 16(10). doi:10.1029/2024MS004510.DOI
- [50]Thiry, L., Li, L., Roullet, G., and Mémin, E., 2024b. MQGeometry-1.0: a multi-layer quasi-geostrophic solver on non-rectangular geometries. Geoscientific Model Development, 17(4):1749–1764. doi:10.5194/gmd-17-1749-2024.DOI
- [52]Wilcox, D., 2008. Formulation of the k-ω turbulence model revisited. AIAA Journal, 46:2823–2838. doi:10.2514/1.36541.DOI
- [53]Williams, R. and Peng, J., 1990. An Efficient Gradient-Based Algorithm for On-Line Training of Recurrent Network Trajectories. Neural Computation, 2(4):490–501. doi:10.1162/neco.1990.2.4.490.DOI
- [54]Williams, R. and Zipser, D., 2013. Gradient-based learning algorithms for recurrent networks and their computational complexity. In Backpropagation: Theory, architectures, and applications. Psychology Press, pages 433–486.
- [55]Yan, F., Frezat, H., Le Sommer, J., Mak, J., and Otness, K., 2025. Adjoint-based online learning of two-layer quasi-geostrophic baroclinic turbulence. Journal of Advances in Modeling Earth Systems, 17:e2024MS004857.arxiv.org/abs/2411.14106
- [56]Zanna, L. and Bolton, T., 2021. Deep Learning of Unresolved Turbulent Ocean Processes in Climate Models. In Camps-Valls, G., Tuia, D., Zhu, X., and Reichstein, M., editors, Deep Learning for the Earth Sciences. Wiley, 1 edition, pages 298–306. doi:10.1002/9781119646181.ch20.DOI
- [57]Zanna, L., Mana, P., Anstey, J., David, T., and Bolton, T., 2017. Scale-aware deterministic and stochastic parameterizations of eddy-mean flow interaction. Ocean Modelling, 111:66–80. doi:10.1016/j.ocemod.2017.01.004.DOI









