betaFeedback

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):

u˙t=F(ut)+M(ut,θ)(1)\dot{\mathbf{u}}_t = \mathbf{F}(\mathbf{u}_t) + \mathbf{M}(\mathbf{u}_t,\theta) \tag*{(1)}

where ut∈Rd\mathbf{u}_t \in\mathbb{R}^d denotes the state of the system at time tt. The right-hand side is composed of two contributions. The first term, F\mathbf{F}, represents the physics-based dynamical model which is derived from first principles or established empirical formulations. The second term, M\mathbf{M}, is a data-driven sub-model designed to account for imperfections or unmodeled dynamics in F\mathbf{F}. This component is typically implemented as a neural network parameterized by a set of trainable parameters θ∈Ra\theta\in\mathbb{R}^a.

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 ff that represents the numerical integrator of the system (1). Given an initial state u0∈Rd\mathbf{u}_0 \in\mathbb{R}^d, and a parameter vector, the system evolves through the recursive application of ff to generate a rollout trajectory un=f(un−1,θ)\mathbf{u}_n = f(\mathbf{u}_{n-1}, \theta), where n∈Z+n \in\mathbb{Z}^{+} denotes the discrete time index.

In online learning, the optimization problem is formulated directly on such trajectories and the objective is to identify θ\theta that minimizes a loss function evaluated over a specified finite temporally unrolled window. Let NN denote the number of integration steps over which the hybrid system is recursively unrolled. The state reached after this rollout can be expressed as

uN=f∘f∘⋯∘f⏟N times(u0),(2)\mathbf{u}_N = \underbrace{f \circ f \circ\cdots\circ f}_{N\ \mathrm{times}}(\mathbf{u}_0), \tag*{(2)}

In the online learning literature, NN 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 LN\mathcal{L}_N, which depends on the sequence of hybrid states {un}n=1N\{\mathbf{u}_n\}_{n=1}^{N}

min⁡θ LN({un=f(un−1,θ)}n=1N,{yn}n=1N,θ)(3)\min_{\theta}\ \mathcal{L}_N\left(\{\mathbf{u}_n=f(\mathbf{u}_{n-1},\theta)\}_{n=1}^{N},\{\mathbf{y}_n\}_{n=1}^{N},\theta\right) \tag*{(3)}

where LN\mathcal{L}_N measures the discrepancy between the predicted trajectory and a target trajectory {yn}n=1N\{\mathbf{y}_n\}_{n=1}^{N}.

As in any gradient-descent based optimization procedure, training requires computing the sensitivity of the loss with respect to the trainable parameters dLNdθ\frac{d\mathcal{L}_N}{d\theta}. 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]:

dLNdθ=∑n=1Ngn∂f∂θ(un−1,θ)(4)\frac{d\mathcal{L}_N}{d\theta} = \sum_{n=1}^{N} \mathbf{g}_n \frac{\partial f}{\partial\theta}(\mathbf{u}_{n-1},\theta) \tag*{(4)}

where gn=dLNdun\mathbf{g}_n = \frac{d\mathcal{L}_N}{d\mathbf{u}_n} is the adjoint vector at step nn, that is the sensitivity of the scalar loss with respect to the intermediate state un\mathbf{u}_n. By the chain rule, the sequence of adjoint vectors satisfy an inhomogeneous backward recurrence:

gN=dLNduN=∂LN∂uN(5)\begin{aligned} \mathbf{g}_N &= \frac{d\mathcal{L}_N}{d\mathbf{u}_N} = \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_N} \tag*{(5)} \end{aligned}
gn=dLNdun=gn+1∂f∂u(un,θ)+∂LN∂un(6)\begin{aligned} \mathbf{g}_n &= \frac{d\mathcal{L}_N}{d\mathbf{u}_n} = \mathbf{g}_{n+1}\frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_n,\theta) + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} \tag*{(6)} \end{aligned}

In this recurrence, the vector-matrix product gn+1∂f∂u\mathbf{g}_{n+1}\frac{\partial f}{\partial\mathbf{u}} is a pullback operation along ff, where the adjoint vector, a cotangent on the state space gn+1\mathbf{g}_{n+1} is pulled back from step n+1n+1 to step nn by contraction with the Jacobian matrix of ff evaluated at un\mathbf{u}_n. The additional source term ∂LN∂un\frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} 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 gn+1\mathbf{g}_{n+1} with ∂f/∂u\partial f/\partial\mathbf{u} to propagate the adjoint backward through (5), while the parameter-pullback contracts gn\mathbf{g}_n with ∂f/∂θ\partial f/\partial\theta to accumulate the parameter gradient in (4). We write VJPu\mathrm{VJP}^{\mathbf{u}} and VJPθ\mathrm{VJP}^{\theta} 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 NN 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 ATBA_{\mathrm{TB}}, expressed in unrolled time steps. For a trajectory of NN steps, the corresponding number of windows is KK such that ATB=N/KA_{\mathrm{TB}} = N/K. Applying the truncation to (5) yields

gn={∂LN∂un,if n≡0(modATB),gn+1∂f∂u(un−1,θ)+∂LN∂un,otherwise.(7)g_n = \begin{cases} \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n}, & \text{if } n \equiv0 \pmod{A_{\mathrm{TB}}},\\[6pt] g_{n+1}\frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_{n-1},\theta) + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n}, & \text{otherwise.} \end{cases} \tag*{(7)}

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 ATBA_{\mathrm{TB}} 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 NN steps into KK chunks C1,…,CKC_1,\ldots,C_K of length APA=N/KA_{\mathrm{PA}} = N/K. Each chunk CiC_i has a single anchor step niancn_i^{\mathrm{anc}} 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 niancn_i^{\mathrm{anc}} only, and reused or replaced at every other step of CiC_i. Under this approximation, the parameter gradient (5) becomes

dLNdθ≈∑n=1Ngnm∂f∂θ(unianc,θ)(8)\frac{d\mathcal{L}_N}{d\theta} \approx\sum_{n=1}^{N} g_n^m \frac{\partial f}{\partial\theta}\left(\mathbf{u}_{n_i^{\mathrm{anc}}},\theta\right) \tag*{(8)}

so that the parameter pullback at step nn is linearized at the anchor state of its chunk rather than at un−1\mathbf{u}_{n-1}. The approximate adjoint gnmg_n^m is obtained from a modified form of the recurrence (5), with mm 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 ff with step size hh,

∂f∂u(un,θ)=I+∑k=1phkk!∂∂udk−1(F(⋅)+M(⋅,θ)(ut))dtk−1∣un+O(hp+1).(9)\frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_n,\theta) = \mathbf{I} + \sum_{k=1}^{p}\frac{h^k}{k!}\frac{\partial}{\partial\mathbf{u}}\frac{d^{k-1}\left(\mathbf{F}(\cdot)+\mathbf{M}(\cdot,\theta)(\mathbf{u}_t)\right)}{dt^{k-1}}\bigg|_{\mathbf{u}_n} + \mathcal{O}(h^{p+1}). \tag*{(9)}

in which every term beyond the leading one is O(h)\mathcal{O}(h), so the Jacobian can be approximated as

∂f∂u(un,θ)=I+O(h)(10)\frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_n,\theta) = \mathbf{I} + \mathcal{O}(h) \tag*{(10)}

Assuming that hh is small enough, the adjoint is then propagated unchanged between anchors, and the recurrence (5) becomes, for every n∈Cin \in C_i,

gnZO={gn+1ZO∂f∂u(un,θ)+∂LN∂unif n=nianc,gn+1ZO+∂LN∂unotherwise.(11)g_n^{\mathrm{ZO}} = \begin{cases} g_{n+1}^{\mathrm{ZO}} \frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_n,\theta) + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} & \text{if } n = n_i^{\mathrm{anc}},\\ g_{n+1}^{\mathrm{ZO}} + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} & \text{otherwise.} \end{cases} \tag*{(11)}
gnZO={gn+1ZO∂f∂u(un,θ)+∂LN∂unif n=nianc,gn+1ZO+∂LN∂unotherwise.(12)g_n^{\mathrm{ZO}} = \begin{cases} g_{n+1}^{\mathrm{ZO}} \frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_n,\theta) + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} & \text{if } n = n_i^{\mathrm{anc}},\\ g_{n+1}^{\mathrm{ZO}} + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} & \text{otherwise.} \end{cases} \tag*{(12)}

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 n∈Cin \in C_i,

gnReuse={gn+1Reuse∂f∂u(un,θ)+∂LN∂unif n=nianc,gn+1Reuse∂f∂u(unianc,θ)+∂LN∂unotherwise.(13)g_n^{\mathrm{Reuse}} = \begin{cases} g_{n+1}^{\mathrm{Reuse}} \frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_n,\theta) + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} & \text{if } n = n_i^{\mathrm{anc}},\\ g_{n+1}^{\mathrm{Reuse}} \frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_{n_i}^{\mathrm{anc}},\theta) + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} & \text{otherwise.} \end{cases} \tag*{(13)}
gnReuse={gn+1Reuse∂f∂u(un,θ)+∂LN∂unif n=nianc,gn+1Reuse∂f∂u(unianc,θ)+∂LN∂unotherwise.(14)g_n^{\mathrm{Reuse}} = \begin{cases} g_{n+1}^{\mathrm{Reuse}} \frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_n,\theta) + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} & \text{if } n = n_i^{\mathrm{anc}},\\ g_{n+1}^{\mathrm{Reuse}} \frac{\partial f}{\partial\mathbf{u}}(\mathbf{u}_{n_i}^{\mathrm{anc}},\theta) + \frac{\partial\mathcal{L}_N}{\partial\mathbf{u}_n} & \text{otherwise.} \end{cases} \tag*{(14)}

The resulting approximation error scales with the variation of the local Jacobian over the chunk, and vanishes as h→0h \to0 or APA→1A_{\mathrm{PA}} \to1.

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 ua(n)\mathbf{u}_{a(n)} is the same for all steps belonging to a given chunk, the sum splits into KK groups of APAA_{\mathrm{PA}} consecutive terms:

∂LN∂θ≈∑n=1Ngnm∂f∂θ(unianc,θ)=∑n=1APAgnm∂f∂θ(un1anc,θ)+∑n=APA+12APAgnm∂f∂θ(un2anc,θ)+⋯+∑n=(K−1)APA+1Ngnm∂f∂θ(unKanc,θ).(15)\frac{\partial\mathcal{L}_N}{\partial\theta} \approx \sum_{n=1}^{N} g_n^m \frac{\partial f}{\partial\theta}(\mathbf{u}_{n_i^{\mathrm{anc}}},\theta) = \sum_{n=1}^{A_{\mathrm{PA}}} g_n^m \frac{\partial f}{\partial\theta}(\mathbf{u}_{n_1^{\mathrm{anc}}},\theta) + \sum_{n=A_{\mathrm{PA}}+1}^{2A_{\mathrm{PA}}} g_n^m \frac{\partial f}{\partial\theta}(\mathbf{u}_{n_2^{\mathrm{anc}}},\theta) + \cdots + \sum_{n=(K-1)A_{\mathrm{PA}}+1}^{N} g_n^m \frac{\partial f}{\partial\theta}(\mathbf{u}_{n_K^{\mathrm{anc}}},\theta). \tag*{(15)}

where gnmg_n^m 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 nn. By linearity of the vector-Jacobian product, it can therefore be pulled out of the sum, so that the ii-th group reduces to a single product:

∑n=(i−1)APA+1iAPAgnm∂f∂θ(unianc,θ)=(∑n=(i−1)APA+1iAPAgnm)∂f∂θ(unianc,θ),(16)\sum_{n=(i-1)A_{\mathrm{PA}}+1}^{iA_{\mathrm{PA}}} g_n^m \frac{\partial f}{\partial\theta}(\mathbf{u}_{n_i^{\mathrm{anc}}},\theta) = \left( \sum_{n=(i-1)A_{\mathrm{PA}}+1}^{iA_{\mathrm{PA}}} g_n^m \right) \frac{\partial f}{\partial\theta}(\mathbf{u}_{n_i^{\mathrm{anc}}},\theta), \tag*{(16)}

where SiS_i is simply the sum of the approximate adjoints visited inside chunk CiC_i. The parameter gradient then reads

∂LN∂θ≈∑i=1KSi∂f∂θ(unianc,θ).(17)\frac{\partial\mathcal{L}_N}{\partial\theta} \approx \sum_{i=1}^{K} S_i \frac{\partial f}{\partial\theta}(\mathbf{u}_{n_i^{\mathrm{anc}}},\theta). \tag*{(17)}

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:

  1. Outer loop over chunks (anchor linearization and parameter pullback). The chunks are traversed backward, i=K,…,1i = K,\ldots,1. Reverse-mode AD is invoked once at the anchor state uniancu_{n_i}^{\mathrm{anc}} to construct the two pullback operators VJPiu\mathrm{VJP}^{u}_{i} and VJPiθ\mathrm{VJP}^{\theta}_{i}. Once the inner loop has completed, VJPiθ(Si)\mathrm{VJP}^{\theta}_{i}(S_i) is added to the global parameter gradient.

  1. Inner loop over steps (adjoint sensitivity accumulation). The steps of the chunk are traversed backward. At each step, the loss cotangent ∂LN∂un\frac{\partial L_N}{\partial u_n} is incorporated, the state sensitivity is updated according to the chosen approximation, the identity for ZO or the reused operator VJPiu\mathrm{VJP}^{u}_{i} for Reuse; the resulting gnmg_n^m is accumulated into SiS_i.

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 NN, but with the number of chunks KK. Where exact BPTT evaluates one parameter VJPθ\mathrm{VJP}^{\theta} per time step, the PA methods accumulate the sensitivities into SiS_i through simple vector additions and apply VJPθ\mathrm{VJP}^{\theta} 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.

Schematic illustration of the factorized double-loop backward pass

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 un\mathbf{u}_n is partitioned into KK chunks of length APAA_{\mathrm{PA}}, each containing a single anchor step. During the inner loop, the local sensitivity gnm\mathbf{g}_n^m combines the propagated state sensitivity with the loss cotangent at step nn. These step-wise sensitivities are accumulated within each chunk into SiS_i, which is passed through the parameter VJP once per chunk to update the total parameter gradient gθ\mathbf{g}_{\theta}.

Algorithm 1: Factorized double-loop backward pass for the Zero-order and Pullback Reuse approximations.

Input: anchor states {unianc}i=1K\{u_{n_i}^{\mathrm{anc}}\}_{i=1}^{K}, terminal sensitivity gN+1=0g_{N+1}=0, loss cotangents {∂LN∂un}n=1N\left\{\frac{\partial L_N}{\partial u_n}\right\}_{n=1}^{N}

Output: total parameter gradient gθg_\theta

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 N\sqrt{N} 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 VJPu\mathrm{VJP}^{u} and VJPθ\mathrm{VJP}^{\theta}. 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 ff. 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.

AlgorithmForward model stepsPullback constructionsVJP evaluationsPeak memory footprint
Exact BPTTNNNNN VJPu+N VJPθN\,\mathrm{VJP}^{u} + N\,\mathrm{VJP}^{\theta}NN states + NN AD residuals
TBPTTNNNNN VJPu+N VJPθN\,\mathrm{VJP}^{u} + N\,\mathrm{VJP}^{\theta}ATBA_{\mathrm{TB}} states + ATBA_{\mathrm{TB}} AD residuals
Zero-OrderN+KN + KKKK VJPu+K VJPθK\,\mathrm{VJP}^{u} + K\,\mathrm{VJP}^{\theta}NN states + 1 AD residual
Pullback ReuseN+KN + KKKN VJPu+K VJPθN\,\mathrm{VJP}^{u} + K\,\mathrm{VJP}^{\theta}NN states + 1 AD residual
N\sqrt{N} Checkpointing2N2NNNN VJPu+N VJPθN\,\mathrm{VJP}^{u} + N\,\mathrm{VJP}^{\theta}N\sqrt{N} states + N\sqrt{N} AD residuals

Table I. Theoretical complexity of the reverse-mode automatic differentiation algorithms considered in this work. NN denotes the total number of unrolled time steps, KK the number of chunks for the Pullback Approximation methods or of windows for TBPTT, the latter of length ATB=N/KA_{\mathrm{TB}} = N/K. A pullback construction corresponds to one taped forward evaluation of ff 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 ff.

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 N\sqrt{N} strategy of Chen et al. (2016) stores N\sqrt{N} checkpoints, bringing memory down to O(N)O(\sqrt{N}) 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 hh 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 NN. 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 α\alpha. For TBPTT, α=ATB\alpha= A_{TB} is the window length; for the Pullback Approximation methods, α=K\alpha= K is the number of chunks, and hence of anchor points. In both cases a smaller α\alpha 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 ut=[xt,yt,zt]\mathbf{u}_t = [x_t, y_t, z_t] and σ\sigma, ρ\rho and β\beta are positive constants. We use the standard values σ=10\sigma= 10, ρ=28\rho= 28 and β=8/3\beta= 8/3, for which the system chaotic and its trajectories converge to the Lorenz attractor [25].

The hybrid setup follows (1). The dynamical model F\mathbf{F} is an incomplete L63 system (19) in which the term −βzt-\beta z_t has been removed which prevents the model from reproducing the true attractor. A sub-model M(ut,θ)=[m1(⋅),m2(⋅),m3(⋅)]T\mathbf{M}(\mathbf{u}_t, \theta) = [m_1(\cdot), m_2(\cdot), m_3(\cdot)]^{T} 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.

x˙t=σ(yt−xt),y˙t=xt(ρ−zt)−yt,z˙t=xtyt−βzt(18)\begin{aligned} \dot{x}_t &= \sigma(y_t-x_t),\\ \dot{y}_t &= x_t(\rho-z_t)-y_t,\\ \dot{z}_t &= x_ty_t-\beta z_t \tag*{(18)} \end{aligned}
x˙t=σ(yt−xt),y˙t=xt(ρ−zt)−yt,z˙t=xtyt(19)\begin{aligned} \dot{x}_t &= \sigma(y_t-x_t),\\ \dot{y}_t &= x_t(\rho-z_t)-y_t,\\ \dot{z}_t &= x_ty_t \tag*{(19)} \end{aligned}
x˙t=σ(yt−xt)+m1(ut,θ),y˙t=xt(ρ−zt)−yt+m2(ut,θ),z˙t=xtyt−βzt+m3(ut,θ)(20)\begin{aligned} \dot{x}_t &= \sigma(y_t-x_t)+m_1(\mathbf{u}_t,\theta),\\ \dot{y}_t &= x_t(\rho-z_t)-y_t+m_2(\mathbf{u}_t,\theta),\\ \dot{z}_t &= x_ty_t-\beta z_t+m_3(\mathbf{u}_t,\theta) \tag*{(20)} \end{aligned}

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 n=2,000n = 2{,}000 points at dt=0.01dt = 0.01, corresponding to T=20T = 20 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 NN and degrees of approximation α\alpha. 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 α\alpha 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 NN increases and α\alpha 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 NN. 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 NN, since the footprint of exact BPTT grows faster, and rises with α\alpha, 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 α>1\alpha> 1; the apparent 2×2\times speedup at α=1\alpha= 1 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 NN and are fastest at the fewest anchors. Reuse is consistently ahead of ZO here, despite the latter saving additional VJPu^{u} 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 N=12N = 12 unrolled time steps. Results are shown for Exact BPTT, TBPTT, Zero-Order, and Reuse Gradient, with the latter three evaluated at α=2\alpha= 2, 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 α=6\alpha= 6, α=4\alpha= 4 and α=2\alpha= 2. 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 (x,y)(x, y) square domain with a side length L=2πL = 2\pi, the dimensionless governing equations for vorticity (ωt)(\omega_t) and streamfunction (ψt)(\psi_t) are

∂ωt∂t+A(ωt,ψt)=1Re⁡∇2ωt−f−rωt(21)\frac{\partial\omega_t}{\partial t} + \mathcal{A}(\omega_t,\psi_t) = \frac{1}{\operatorname{Re}}\nabla^2\omega_t - f - r\omega_t \tag*{(21)}
∇2ψt=−ωt(22)\nabla^2\psi_t = -\omega_t \tag*{(22)}

where, A(ωt,ψt)\mathcal{A}(\omega_t,\psi_t) is the nonlinear advection term:

A(ωt,ψt)=∂ψt∂y∂ωt∂x−∂ψt∂x∂ωt∂y,\mathcal{A}(\omega_t,\psi_t) = \frac{\partial\psi_t}{\partial y}\frac{\partial\omega_t}{\partial x} - \frac{\partial\psi_t}{\partial x}\frac{\partial\omega_t}{\partial y},

and ff is a deterministic forcing

f(x,y)=kf[cos⁡(kfx)+cos⁡(kfy)].f(x,y) = k_f\left[\cos\left(k_fx\right) + \cos\left(k_fy\right)\right].

We consider a large eddy simulation (LES) setting in which both fields are filtered with a Gaussian filter ([40]), denoted (⋅)(\cdot). Applying the filter to (16a)–(16b) yields

∂ωˉt∂t+A(ωˉt,ψˉt)=1Re⁡∇2ωˉt−fˉ−rωˉt+A(ωˉt,ψˉt)−A(ωt,ψt)⏟Πt≈Mθ(23)\frac{\partial\bar{\omega}_t}{\partial t} + \mathcal{A}(\bar{\omega}_t,\bar{\psi}_t) = \frac{1}{\operatorname{Re}}\nabla^2\bar{\omega}_t - \bar{f} - r\bar{\omega}_t + \underbrace{\mathcal{A}(\bar{\omega}_t,\bar{\psi}_t) - \mathcal{A}(\omega_t,\psi_t)}_{\Pi_t\approx M_\theta} \tag*{(23)}
∇2ψˉt=−ωˉt(24)\nabla^2\bar{\psi}_t = -\bar{\omega}_t \tag*{(24)}

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 Πt\Pi_t. Here Πt\Pi_t is parameterized by a convolutional neural network (CNN) Mθ(ψˉt,ωˉt,θ)M_\theta(\bar{\psi}_t,\bar{\omega}_t,\theta) that takes as inputs both the vorticity and streamfunction fields (ψˉt,ωˉt)(\bar{\psi}_t,\bar{\omega}_t). 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 hDNS=5×10−5h_{\mathrm{DNS}} = 5 \times10^{-5}. The target dataset is obtained by spatially filtering this trajectory with Gaussian filter of width Δf=2ΔLES\Delta_f = 2\Delta_{\mathrm{LES}}, coarse-graining to a 64 x 64 LES grid, and sampling at the LES timestep hLES=8×10−4h_{\mathrm{LES}} = 8 \times10^{-4}, 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 N=40N = 40 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 NN increases, whereas Reuse stays almost perfectly aligned with the exact gradient at every degree of approximation α\alpha. 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, α\alpha denotes the chunk size; for Zero-Order and Reuse, it denotes the number of chunks (anchor points). In all cases, α\alpha 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 ff 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 α\alpha accordingly. Notably, TBPTT at α=1\alpha= 1 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 (α≤10\alpha\le10) 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 ∼4\sim4 to 5×5\times over exact BPTT at the most aggressive α\alpha. Read alongside the L63 results in § 5.1.1, this confirms that the extra VJPuVJ^{\mathsf{P}}u 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 α\alpha 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 α=1\alpha= 1 and α=5\alpha= 5. The CNN is trained using a window of N=40N=40 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 (t=0t = 0–6060) for the Ground Truth, No SGS, Exact, and Reuse (α=5\alpha= 5) simulations. The CNN was trained for 20 epochs using a window of N=40N = 40 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 FF 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, ut=[ut,vt,ht]⊤\mathbf{u}_t = [u_t, v_t, h_t]^{\top}. The system evolves under the full nonlinear RSW operator φ\varphi while the projection PP onto the geostrophic manifold filters fast ageostrophic motions, u˙t=P∘φ(ut)\dot{\mathbf{u}}_t = P \circ\varphi(\mathbf{u}_t). 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 31∘N31^{\circ}\mathrm{N}–45∘N45^{\circ}\mathrm{N} and 5.5∘W5.5^{\circ}\mathrm{W}–9∘E9^{\circ}\mathrm{E}, discretized on a 310×254310 \times254 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 CDC_D. Physical and numerical parameters are summarized in Appendix § 10:, Table IV.

ParameterValueDescription
Lx×LyL_x \times L_y≈1550×1270 km\approx1550 \times1270\ \mathrm{km}Domain size
nx×nyn_x \times n_y310×254310 \times254Grid dimensions
Δx×Δy\Delta x \times\Delta y5×5 km5 \times5\ \mathrm{km}Spatial resolution
nℓn_{\ell}33Number of vertical layers
HℓH_{\ell}[75,400,2525] m[75, 400, 2525]\ \mathrm{m}Reference layer thickness
gℓ′g'_{\ell}[9.81,0.025,0.0125] m s−2[9.81, 0.025, 0.0125]\ \mathrm{m\ s^{-2}}Reduced gravity
CDC_D3.6057×10−8 s−13.6057 \times10^{-8}\ \mathrm{s^{-1}}Bottom drag coefficient
τ0\tau_01.3×10−3 N m−21.3 \times10^{-3}\ \mathrm{N\ m^{-2}}Wind stress magnitude
ρ0\rho_01000 kg m−31000\ \mathrm{kg\ m^{-3}}Reference density
f0f_09.375×10−5 s−19.375 \times10^{-5}\ \mathrm{s^{-1}}Mean Coriolis parameter
β\beta1.754×10−11 m−1 s−11.754 \times10^{-11}\ \mathrm{m^{-1}\ s^{-1}}Coriolis gradient
—0.60.6Slip coefficient (lateral boundaries)
hh3600 s3600\ \mathrm{s}Time step
—RK3-SSPTime-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 CDC_D 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 CDC_D produce significant differences in kinetic energy and circulation. We restore the correct dynamics in two ways, by calibrating CDC_D directly and by correcting the QG tendencies with a neural network.

In the first strategy, CDC_D is treated as a learnable scalar and calibrated by gradient descent on dLNdCD\frac{d\mathcal{L}_N}{dC_D}. 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 M(ut,θ)\mathrm{M}(\mathbf{u}_t,\theta) 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 3×33 \times3 kernels followed by ReLU activations, and a final 1×11 \times1 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 N=12N = 12 steps. The remaining hyperparameters are given in Appendix § 10; Table V.

ParameterCDC_D calibrationSub-model training
Numerical solverRK3-SSPRK3-SSP
Loss functionNormalized MSE, Eq. (27)Normalized MSE, Eq. (27)
OptimizerAdamAdam
Rollout length NN12121212
Trainable parametersCDC_D (1 scalar)CNN weights (1456)
Learning rate10−410^{-4} (constant)10−610^{-6} (cosine schedule)
Batch size1111
Optimization budget250 iterations15 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 CDC_D. 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 CDC_D 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 CDC_D (right) over 250 optimization iterations, for the exact BPTT, TBPTT, Zero-Order, and Pullback Reuse methods with α=2\alpha= 2, 4, 6. Horizontal lines in the right panel mark the ground truth and biased values of CDC_D. All methods use a rollout of N=12N=12 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 A=2,4,6A = 2, 4, 6. For all methods, the CNN was trained with a rollout N=12N=12 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 N=12N=12 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 N=12N = 12 steps and α=2\alpha= 2.

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, uhyb(tn)\mathbf{u}_{\mathrm{hyb}}(t_n), and the reference trajectory generated by the classical Lorenz-63 system, uref(tn)\mathbf{u}_{\mathrm{ref}}(t_n), with u=(x,y,z)T\mathbf{u}=(x,y,z)^{\mathsf{T}}. The error is accumulated over the rollout of length NN and averaged over the three state variables,

L=13N∑n=1N∥uhyb(tn)−uref(tn)∥22.(25)\mathcal{L}=\frac{1}{3N}\sum_{n=1}^{N}\left\lVert\mathbf{u}_{\mathrm{hyb}}(t_n)-\mathbf{u}_{\mathrm{ref}}(t_n)\right\rVert_{2}^{2}. \tag*{(25)}

Large-eddy simulation of quasi-geostrophic turbulence. The online objective is the mean squared error between the filtered vorticity predicted by the hybrid LES, ωˉhyb\bar{\omega}_{\mathrm{hyb}} and the filtered DNS reference, ωˉref\bar{\omega}_{\mathrm{ref}} accumulated over the rollout of length NN and averaged over the LES grid Ω\Omega,

L=1N∣Ω∣∑n=1N∑(i,j)∈Ω(ωˉhyb(tn;i,j)−ωˉref(tn;i,j))2,(26)\mathcal{L}=\frac{1}{N\lvert\Omega\rvert}\sum_{n=1}^{N}\sum_{(i,j)\in\Omega}\left(\bar{\omega}_{\mathrm{hyb}}(t_n;i,j)-\bar{\omega}_{\mathrm{ref}}(t_n;i,j)\right)^{2}, \tag*{(26)}

where ∣Ω∣=64×64\lvert\Omega\rvert=64\times64 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 NoN_o observation times τk\tau_k within the rollout window and over the full prognostic state, comprising the horizontal velocities (u,v)(u,v) and the layer-thickness anomaly hh,

L=13No∑k=1No∑ϕ∈{u,v,h}1L∣Ωϕ∣∑ℓ=1L∑(i,j)∈Ωϕ(ϕhybℓ(τk;i,j)−ϕrefℓ(τk;i,j)σϕ,ℓ)2,(27)\mathcal{L}=\frac{1}{3N_o}\sum_{k=1}^{N_o}\sum_{\phi\in\{u,v,h\}}\frac{1}{L\lvert\Omega_\phi\rvert}\sum_{\ell=1}^{L}\sum_{(i,j)\in\Omega_\phi}\left(\frac{\phi_{\mathrm{hyb}}^{\ell}(\tau_k;i,j)-\phi_{\mathrm{ref}}^{\ell}(\tau_k;i,j)}{\sigma_{\phi,\ell}}\right)^{2}, \tag*{(27)}

where ϕℓ\phi^{\ell} denotes field ϕ\phi in layer ℓ\ell, LL is the number of layers, and Ωϕ\Omega_\phi is the set of ocean grid points associated with field ϕ\phi, land points being excluded from the loss. The normalization σϕ,ℓ\sigma_{\phi,\ell} is the root-mean-square amplitude of field ϕ\phi in layer ℓ\ell, computed over ocean points in the training set.

Simulation configuration and hyperparameters

ParameterValue
Numerical solverRK4
Loss functionMSE
OptimizerAdam
Learning rate10−310^{-3} (constant)
Rollout length12
Batch size20
Epochs250

Table II. Training setup and hyperparameters for the Lorenz-63 experiment.

ParameterValue
Numerical solverRK4
Loss functionMSE
OptimizerAdam
Learning rate10−410^{-4} (constant)
Rollout length40
Batch size20
Epochs20

Table III. Training setup and hyperparameters for the quasi-geostrophic turbulence large-eddy simulation experiment.

References

  1. [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. [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. [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
  4. [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
  5. [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
  6. [7]Christensen, H. and Zanna, L., 2022. Parametrization in weather and climate models. doi:10.1093/acrefore/9780190228620.013.826.
  7. [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
  8. [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
  9. [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.
  10. [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
  11. [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.
  12. [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
  13. [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
  14. [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
  15. [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.
  16. [17]Jang, E., Gu, S., and Poole, B., 2017. Categorical Reparameterization with Gumbel-Softmax. arXiv preprint arXiv:1611.01144.arxiv.org/abs/1611.01144
  17. [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
  18. [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
  19. [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
  20. [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
  21. [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
  22. [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
  23. [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
  24. [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
  25. [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
  26. [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
  27. [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
  28. [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
  29. [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
  30. [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
  31. [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.
  32. [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
  33. [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.
  34. [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
  35. [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
  36. [38]Pope, S., 2000. Turbulent flows, volume 20. Cambridge university press, Cambridge.DOI
  37. [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.
  38. [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
  39. [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
  40. [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
  41. [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
  42. [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
  43. [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
  44. [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
  45. [47]Tallec, C. and Ollivier, Y., 2017. Unbiasing Truncated Backpropagation Through Time. arXiv preprint arXiv:1705.08209.arxiv.org/abs/1705.08209
  46. [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
  47. [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
  48. [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
  49. [52]Wilcox, D., 2008. Formulation of the k-ω turbulence model revisited. AIAA Journal, 46:2823–2838. doi:10.2514/1.36541.DOI
  50. [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
  51. [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.
  52. [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
  53. [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
  54. [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

Paper details

vlnc:W_9aqgqngt
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