betaFeedback

WorksComputer Science

Deep learning-enhanced ensemble-based data assimilation for high-dimensional nonlinear dynamical systems

Abstract

Data assimilation (DA) is a key component of many forecasting models in science and engineering. DA allows one to estimate better initial conditions using an imperfect dynamical model of the system and noisy/sparse observations available from the system. Ensemble Kalman filter (EnKF) is a DA algorithm that is widely used in applications involving high-dimensional nonlinear dynamical systems. However, EnKF requires evolving large ensembles of forecasts using the dynamical model of the system. This often becomes computationally intractable, especially when the number of states of the system is very large, e.g., for weather prediction. With small ensembles, the estimated background error covariance matrix in the EnKF algorithm suffers from sampling error, leading to an erroneous estimate of the analysis state (initial condition for the next forecast cycle). In this work, we propose hybrid ensemble Kalman filter (H-EnKF), which is applied to a two-layer quasi-geostrophic flow system as a test case. This framework utilizes a pre-trained deep learning-based data-driven surrogate that inexpensively generates and evolves a large data-driven ensemble of the states of the system to accurately compute the background error covariance matrix with less sampling error. The H-EnKF framework estimates a better initial condition without the need for any ad-hoc localization strategies. H-EnKF can be extended to any ensemble-based DA algorithm, e.g., particle filters, which are currently difficult to use for high dimensional systems.

Introduction

Data assimilation (DA) is an indispensable component in many of the forecasting models used for applications in science and engineering [1, 2, 3, 4, 5]. DA allows one to estimate better initial conditions for a system from which noisy and sparse observations are available, along with an imperfect dynamical model of the system. These initial conditions are then used by the dynamical model to predict the future states of the system. The quality of future forecasts strongly depends on the accuracy of the initial conditions. This is especially important in chaotic systems, where even a small error in an initial condition can result in drastically different forecasts [6]. In such systems, an accurate initial condition is of the utmost importance for predictive dynamical models to provide accurate forecasts. DA is critical in various areas of engineering and sciences, such as weather prediction [7] [8, 9], environmental and geophysical flows [10, 11, 12], combustion systems [13, 14, 15], aeronautics [16], hydrology [17], acoustics [18], and fluid mechanics [19, 20].

There are two main categories of DA algorithms: ensemble-based methods and variational methods. Ensemble-based DA algorithms such as ensemble Kalman filter (EnKF) were proposed for estimating better initial conditions from noisy observations assuming Gaussian observation noise [21]. Several other DA algorithms such as variational methods (e.g., 3D-Var and 4D-Var) or a combination of ensemble and variational algorithms also exist [22, 23]. 4D-Var requires obtaining the adjoint of the system’s dynamical model, which is often a difficult and non-trivial task. Moreover, 4D-Var optimizes a cost function which can be computationally expensive. Ensemble-based algorithms do not require obtaining adjoints but require evolving a large ensemble of forecasts of the dynamical system. In this paper, we will focus on ensemble-based algorithms for DA.

A major challenge in EnKF is generating and evolving a large number of ensemble members of the dynamical model in time. The accuracy of the background error covariance matrix in EnKF (which affects the performance of EnKF) depends on the ensemble size [24]. For an accurate estimation of the background error covariance matrix, the number of ensemble members should be of the order of the number of states, ss, in the system, which can be large (e.g., in the weather system, s≈O(107)−O(108)s \approx O(10^{7})-O(10^{8})). However, evolving such large ensembles over multiple time steps becomes computationally intractable. Thus, fewer ensembles are typically used in practice (≈O(50)\approx O(50)) in operational weather models [25]. These covariance matrices, generated from a smaller number of ensemble members, are rank-deficient and suffer from sampling error that degrades the quality of the estimated initial condition (often referred to as the “analysis state”). For this reason, various ad-hoc localization strategies have been proposed to remove spurious long-range spatial correlations in the covariance matrix [3]. However, in this process, one may also remove physically-consistent long-range spatial correlations and this can adversely affect the performance of EnKF and thus, the quality of forecasts [26]. There are other methods to estimate the background error covariance matrix without evolving a large ensemble, e.g., the stochastic Galerkin method [27].

In recent years, we have seen an increase in interest at the intersection of machine learning (ML) and DA for applications in dynamical systems. For example, in Yang et al. [28], a generative model was used to facilitate ensemble generation for analog-based DA. In our previous work [29], we have shown that a data-driven weather forecasting model can be integrated with a sigma-point ensemble Kalman filter to obtain accurate initial conditions for forecasting. Tsuyuki et al. [30] integrated ML with an EnKF to perform state estimation in a nonlinear dynamical system using a small number of ensemble members. Maulik et al. [31] used 4D-Var-based DA with ML for forecasting in high-dimensional dynamical systems. Penny et al. [32] used a recurrent neural network and 4D-Var for scalable state estimation. Chen et al. [33] showed the application of DA in ML-based forecasts in complex turbulent flows with partial observations. There are several other studies that have shown different applications, where ML has been integrated with DA, e.g., predicting subgrid-scale processes in multi-scale chaotic systems [34, 35], closed-form equation discovery of model error [36], etc.

In this paper, we propose hybrid ensemble Kalman filter (H-EnKF), a hybrid algorithm for enhancing the performance of EnKF without resorting to localization strategies. H-EnKF leverages deep learning to build a data-driven surrogate of the dynamical model of the system. This surrogate is used to generate and evolve a large number of data-driven ensemble members, O(s)O(s), to compute the background error covariance matrix of the dynamical system. The data-driven model is trained on the full state of the system and serves as a computationally cheap surrogate to predict the evolution of the states, and is used just for estimating the background error covariance matrix. While the less-accurate but large data-driven ensembles are used to compute the background error covariance matrix with low sampling error, the numerical model of the system is used to generate and evolve a small number of ensemble members, gg, where g≪sg \ll s (note that gg could be just 1). This small number of ensemble members are used to compute an accurate background forecast state to be used in the H-EnKF algorithm. In order to demonstrate the performance of H-EnKF, we have applied it to a well-known test-bed for fully turbulent geophysical flows: the two-layer quasi-geostrophic (QG) system [37, 38].

The remainder of the paper is organized into several sections. In section 2, we describe the QG system, the numerical solver used to simulate the system, the data-driven surrogate model, and the EnKF algorithm. In section 3, we introduce our proposed H-EnKF algorithm. Section 4 describes the metrics to evaluate the performance of EnKF and H-EnKF. In section 5, the performance of the algorithms, in terms of accuracy and cost, is presented, followed by summary and discussion in section 6.

Method

Two-layer QG System

The dimensionless dynamical equations of the two-layer QG flow have been developed following Lutsko et al. [37] and Nabizadeh et al. [38]. The system consists of two constant density layers with a β\beta-plane approximation in which the meridional temperature gradient is relaxed towards an equilibrium profile. The system’s equation is

∂qk∂t+J(ψk,qk)=−1τd(−1)k(ψ1−ψ2−ψR)−1τfδk2∇2ψk−ν∇8qk.(1)\frac{\partial q_k}{\partial t} + J(\psi_k,q_k) = -\frac{1}{\tau_d}(-1)^k(\psi_1-\psi_2-\psi_R)-\frac{1}{\tau_f}\delta_{k2}\nabla^2\psi_k-\nu\nabla^8q_k. \tag*{(1)}

Here, qq is potential vorticity

qk=∇2ψk+(−1)k(ψ1−ψ2)+βy,(2)q_k = \nabla^2\psi_k + (-1)^k(\psi_1-\psi_2)+\beta y, \tag*{(2)}

where ψk\psi_k is the streamfunction of the system. In Eqs. (1) and (2), kk denotes the upper (k=1k=1) and lower (k=2k=2) layers. β\beta is the yy-gradient of the Coriolis parameter. τd\tau_d is the Newtonian relaxation time scale and τf\tau_f is the Rayleigh friction time scale, which only acts on the lower layer. δk2\delta_{k2} is the Kronecker δ\delta-function. JJ denotes the Jacobian. ν\nu denotes the hyperdiffusion coefficient. We have introduced a baroclinically unstable jet at the center of a zonally periodic channel by setting ψ1−ψ2\psi_1-\psi_2 to be equal to a hyperbolic secant centered at y=0y=0. When eddy fluxes are absent, ψ2\psi_2 is identically zero, making zonal velocity in the upper layer, u1(y)=−∂ψ1∂y=−∂ψR∂yu_1(y)=-\frac{\partial\psi_1}{\partial y}=-\frac{\partial\psi_R}{\partial y}, where we set

−∂ψR∂y=sech⁡2(yσ).(3)-\frac{\partial\psi_R}{\partial y}=\operatorname{sech}^2\left(\frac{y}{\sigma}\right). \tag*{(3)}

σ\sigma is the width of the jet. Parameters of the model are set following previous works [37, 38]; β=0.19\beta=0.19, σ=3.5\sigma=3.5, τf=15\tau_f=15, and τd=100\tau_d=100.

To non-dimensionalize the equations, we have used the maximum strength of the equilibrium velocity profile as the velocity scale (UU) and the deformation radius (LL) for the length scale. The system’s time scale (L/UL/U) is referred to as the “advective time scale” (τadv\tau_{adv}) which is approximately 6 h in this system.

Numerical Solver

The spatial discretization is spectral in both xx and yy, where we have retained 96 and 192 Fourier modes, respectively. The length and width of the domain are equal to 46 and 68, respectively. Sponge layers are applied to the northern and southern boundaries. Note that the domain is wide enough for the sponges to not affect the dynamics. Here 5τadv≈15\tau_{adv}\approx1 Earth day ≈200Δt\approx200\Delta t, where Δt=0.025\Delta t=0.025 is the time step of the leapfrog time integrator used in the numerical scheme.

The Data-driven Model: U-NET

To build a data-driven surrogate model to approximate the QG dynamics, we adopt a U-NET architecture [39]. The choice of this architecture is inspired by our previous work in data-driven weather forecasting [29]. The details of the architecture are provided in Table 1 and a schematic is shown in Figure 1. The U-NET allows one to extract small-scale features in the encoder that are directly passed into the decoder as skipped connections. This has been shown to result in improved performance on turbulent flow prediction [40]. The U-NET architecture is trained on NtrN_{tr} noise-free samples (we have performed experiments with Ntr=105N_{tr}=10^{5} and Ntr=104N_{tr}=10^{4} samples; see § 5.1) of the system’s state, i.e., streamfunction, ψk(t)\psi_k(t), k={1,2}k=\{1,2\}. The input to the network is ψk(t)\psi_k(t) and the target is ψk(t+γΔt)\psi_k(t+\gamma\Delta t). We have shown in a previous study [29] that large values of γ\gamma improve the prediction horizon of the data-driven model over small values of γ\gamma. Hence, γ>1\gamma>1 would result in a longer prediction horizon than γ=1\gamma=1. However, in the H-EnKF algorithm (see § 3 for more details) an accurate computation of the background error covariance matrix with data-driven ensembles requires one to evolve the data-driven model for a sufficient number of time steps as well. Since we obtain observations from the system at every 200Δt200\Delta t (1 DA cycle), γ\gamma has to be smaller than 200. Hence, the aim is to choose a γ\gamma such that the U-NET has a good prediction horizon while the data-driven ensembles can evolve sufficiently to provide an accurate covariance matrix as well. In this paper, we have chosen γ=40\gamma=40, such that γΔt\gamma\Delta t matches τadv\tau_{\mathrm{adv}} (≈6h\approx6\mathrm{h}) of the QG system.

NumberLayerNumber of Filters
15×55 \times5 2D Convolution32
25×55 \times5 2D Convolution32
32×22 \times2 Max Pooling–
45×55 \times5 2D Convolution32
55×55 \times5 2D Convolution32
62×22 \times2 Max Pooling–
75×55 \times5 2D Convolution32
85×55 \times5 2D Convolution32
9Up-sampling–
10Concatenation–
115×55 \times5 2D Convolution32
125×55 \times5 2D Convolution32
13Up-sampling–
145×55 \times5 2D Convolution32
15Concatenation–
165×55 \times5 2D Convolution32
175×55 \times5 2D Convolution32
185×55 \times5 2D Convolution2

Table 1. Number of layers and filters in the U-NET architecture used as the data-driven surrogate model.

Schematic of the U-NET model used as a surrogate for data-driven prediction

Figure 1. Schematic of the U-NET model used as a surrogate for data-driven prediction of ψk(t)\psi_k(t) in the two-layer QG system. The input to the model is the system’s full state, ψk(t)\psi_k(t) and the output is ψk(t+40Δt)\psi_k(t+40\Delta t), where k={1,2}k = \{1, 2\}. The detailed information of the number of layers, their index number, number of filters, and size of convolutional kernels after hyperparameter optimization is given in Table 1. Here, 40Δt≈6h40\Delta t \approx6\mathrm{h}.

The samples of ψk(t)\psi_k(t) are obtained from numerically solving Eq. (1) and Eq. (2). Each sample corresponds to a different time (tt). The training and testing sets are obtained from independent simulations starting from different random initial conditions so that there is no correlation between the training and testing sets. The hyperparameters of the U-NET are determined after extensive trial and error.

As shown by us and others in previous studies, the performance of the U-NET can be improved by incorporating the symmetries in the system inside the architecture [41, 29] or by using physics-based regularizers in the loss function of the U-NET [42]. However, in the H-EnKF framework, we only need the U-NET to predict short-term evolution (200Δt≈1200\Delta t\approx1 Earth day into the future, more details in § 3). For such a short-term forecast, the performance of the U-NET remains roughly the same as compared to an architecture with physics-constrained loss functions or imposed symmetries. For more complicated problems (such as weather forecasting) that might benefit from enforcing physics within the data-driven architecture, see the comprehensive review by Kashinath et al. [43]. Note that other types of neural architectures can also be used to build the surrogate model, e.g., neural operator-based models, which have recently been shown to achieve state-of-the-art performance in weather forecasting [44].

Data Assimilation with a Stochastic EnKF

In this section, we describe DA with stochastic EnKF. Stochastic EnKF requires a dynamical model of the system, also called “background forecast model”, represented by MM. We further assume that an ensemble of noisy observations, ψobsj\psi^{j}_{obs}, where jj is the index of the ensemble member, is obtained by adding Gaussian white noise to the observations. Here, we assume that the observation noise distribution can be represented as a standard Gaussian with zero mean and standard deviation of σobs\sigma_{obs}. In this paper, we have considered σobs=0.1\sigma_{obs} = 0.1 (10% of standard deviation of ψk(t)\psi_k(t), 1.0). Throughout the rest of the paper, we will drop the word “stochastic”, assuming that an ensemble of noisy observations is available as opposed to a single noisy observation. MM evolves an ensemble of state vectors ψj\psi^j from tt to t+Δtt + \Delta t starting from a noisy initial condition, ψ(t0)\psi(t_0). Let us assume that j∈{1,2,⋯n}j \in\{1, 2, \cdots n\}, where nn denotes the number of ensemble members. Here, and throughout the rest of the paper, we have dropped the subscript kk (the index for the two layers in the system) for clarity unless it is necessary (e.g., in Eq. (A.1) and Eq. (A.2)) keeping in mind that all computations take place on both layers. Furthermore, we assume that assimilation of observations takes place at every αΔt\alpha\Delta t (in this paper, we choose α=200\alpha= 200, i.e., DA occurs every day).

The ensemble of state vectors is generated by adding Gaussian white noise with zero mean and standard deviation of σb\sigma_b to the noisy state vector at time t0t_0, ψ(t0)\psi(t_0):

ψj(t0)=ψ(t0)+N(0,σb2).(4)\psi^{j}(t_0)=\psi(t_0)+\mathcal{N}\left(0,\sigma_b^2\right). \tag*{(4)}

The value of σb\sigma_b has been chosen after significant trial and error for both EnKF and H-EnKF algorithms separately to obtain the best performance (see section 5). The evolution of the ensemble of state vectors, ψj(t)\psi^{j}(t), at any time tt, can be written in discrete form:

ψj(t+αΔt)=M∘M∘⋯M⏟α[ψj(t)].(5)\psi^{j}(t+\alpha\Delta t)=\underbrace{M\circ M\circ\cdots M}_{\alpha}\left[\psi^{j}(t)\right]. \tag*{(5)}

Then, we compute the background error covariance matrix using the ensembles that are obtained at αΔt\alpha\Delta t:

P=E[(ψj(t+αΔt)−ψ‾(t+αΔt))(ψj(t+αΔt)−ψ‾(t+αΔt))].(6)\mathbf{P}=\mathbb{E}\left[\left(\psi^{j}(t+\alpha\Delta t)-\overline{\psi}(t+\alpha\Delta t)\right)\left(\psi^{j}(t+\alpha\Delta t)-\overline{\psi}(t+\alpha\Delta t)\right)\right]. \tag*{(6)}

where ψ‾(t+αΔt)\overline{\psi}(t+\alpha\Delta t) is the mean over the nn ensemble members and E\mathbb{E} is the sample expectation operator. The Kalman gain is computed using P\mathbf{P} as:

K=P(P+σobsI)−1.(7)\mathbf{K}=\mathbf{P}\left(\mathbf{P}+\sigma_{\mathrm{obs}}\mathbf{I}\right)^{-1}. \tag*{(7)}

Here, the observation operator, HH, is I\mathbf{I}. However, we can extend Eq. (7) to nonlinear HH as well. Finally, using the ensemble of noisy observations, ψobsj(t+αΔt)\psi_{\mathrm{obs}}^{j}(t+\alpha\Delta t), the noise-reduced analysis state is computed as:

ψaj(t+αΔt)=ψj(t+αΔt)−K(ψobsj(t+αΔt)−ψj(t+αΔt)),(8)\psi_{a}^{j}(t+\alpha\Delta t)=\psi^{j}(t+\alpha\Delta t)-\mathbf{K}\left(\psi_{\mathrm{obs}}^{j}(t+\alpha\Delta t)-\psi^{j}(t+\alpha\Delta t)\right), \tag*{(8)}

where ψaj(t+αΔt)\psi_{a}^{j}(t+\alpha\Delta t) is the ensemble of analysis states. ψ‾a(t+αΔt)\overline{\psi}_{a}(t+\alpha\Delta t) is a noise-reduced estimate of the state of the system. Hence, ψ‾a(t+αΔt)\overline{\psi}_{a}(t+\alpha\Delta t) is used as the initial condition by the dynamical model, MM, for free forecasting. Moreover, the ensemble of analysis states, ψaj(t+αΔt)\psi_{a}^{j}(t+\alpha\Delta t), can be used for probabilistic forecasting as well, see e.g., Holstein et al. [45].

Proposed DA Algorithm: H-EnKF

The major challenge with using EnKF is computing the background error covariance matrix, P\mathbf{P}, using Eq. (6). An accurate computation of P\mathbf{P} requires nn to be large, typically the same order as that of the dimension of ψ(t)\psi(t). However, this makes the evaluation of Eq. (5) computationally expensive. This is especially true for high-dimensional systems where MM is an expensive numerical model. Hence, traditional applications of EnKF uses small values of nn, which induces sampling error in P\mathbf{P}, resulting in spurious long-range correlations. In this section, we show how the U-NET-based surrogate model is used in developing H-EnKF. A schematic of H-EnKF is shown in Figure 2.

Schematic of the H-EnKF framework, showing noisy initial condition $\psi(t)$, Numerical Model and U-NET ensemble evolution, perturbed observation $\psi_{\mathrm{obs}}^j$, and the analysis covariance and state equations

Figure 2. Schematic of the H-EnKF framework. Noisy initial condition ψ(t0)\psi(t_0) is perturbed with N(0,σb2)\mathcal{N}(0,\sigma_b^2) to generate two sets of ensembles: 1) ψDi(t)\psi_D^i(t) with nDn_D ensembles where nD≈O(1000)n_D\approx O(1000) and 2) ψNj(t)\psi_N^j(t) with nNn_N ensembles where nN≈O(10)n_N\approx O(10). A pre-trained U-NET predicts the evolution of each of the nDn_D ensembles autoregressively for αΔt\alpha\Delta t. Similarly, the numerical solver for the QG system evolves the nNn_N ensembles of ψNj(t)\psi_N^j(t) for αΔt\alpha\Delta t. At this point, a noisy observation of ψobs\psi_{\mathrm{obs}} is perturbed with N(0,σobs2)\mathcal{N}(0,\sigma_{\mathrm{obs}}^2) to generate nNn_N ensembles. Here, an EnKF algorithm computes the background covariance matrix PDP_D using the ensembles evolved with the U-NET and finally produces the analysis state ensembles ψaj\psi_a^j using the background forecast ψNj(t)\psi_N^j(t) from the numerical model. While the analysis ensembles are carried forward and evolved by the numerical model, the U-NET needs the ensembles to be restarted by perturbing the ensemble-averaged analysis state using Gaussian noise (zero mean and σb\sigma_b standard deviation) generating nDn_D ensembles to be evolved over the next αΔt\alpha\Delta t. In this paper, we have chosen α=200\alpha=200 and γ=40\gamma=40. Here, 40Δt≈6h40\Delta t\approx6h and 200Δt≈1200\Delta t\approx1 Earth day.

We denote the U-NET-based surrogate model as MDM_D, which evolves the state ψ(t)\psi(t) to ψ(t+γΔt)\psi(t+\gamma\Delta t) (in this paper, γ=40\gamma=40). Since MDM_D is already trained, it is computationally inexpensive during inference. Hence, one can afford to evolve a very large number of ensemble members, O(1000)O(1000), with MDM_D. We denote the number of ensemble members that are evolved with MDM_D as nDn_D. Similarly, we denote the number of ensemble members evolved with the numerical model (MNM_N) as nNn_N. Note that for all practical problems involving high-dimensional systems, one can computationally afford a small number of nNn_N but a very large number of nDn_D (nN≪nDn_N \ll n_D). Similar to section 2.4, DA occurs at every αΔt\alpha\Delta t and we assume that α\alpha is an integer multiple of γ\gamma.

In H-EnKF, we first evolve a large data-driven ensemble using MDM_D:

ψDi(t+αΔt)=MD∘MD∘⋯MD⏟α/γ[ψDi(t)],(9)\psi_{D}^{i}(t+\alpha\Delta t)=\underbrace{M_D\circ M_D\circ\cdots M_D}_{\alpha/\gamma}\left[\psi_{D}^{i}(t)\right], \tag*{(9)}
PD=E[(ψDj(t+αΔt)−ψˉ(t+αΔt))(ψDj(t+αΔt)−ψˉ(t+αΔt))T]P_D=\mathbb{E}\left[(\psi_D^j(t+\alpha\Delta t)-\bar{\psi}(t+\alpha\Delta t))(\psi_D^j(t+\alpha\Delta t)-\bar{\psi}(t+\alpha\Delta t))^{T}\right]
KD=PD(PD+σobs)−1K_D=P_D(P_D+\sigma_{\mathrm{obs}})^{-1}
ψaj=ψNj(t+αΔt)−KD(ψobsj−ψNj(t+αΔt))\psi_a^j=\psi_N^j(t+\alpha\Delta t)-K_D\left(\psi_{\mathrm{obs}}^j-\psi_N^j(t+\alpha\Delta t)\right)

where i∈{1,2,3,⋯nD}i \in\{1,2,3,\cdots n_D\}. At the same time, we evolve a small number of numerical ensemble members using MNM_N:

ψNi,j(t+αΔt)=MN∘MN∘⋯∘MN⏟α[ψNi,j(t)],(10)\psi_N^{i,j}(t+\alpha\Delta t)=\underbrace{M_N\circ M_N\circ\cdots\circ M_N}_{\alpha}\left[\psi_N^{i,j}(t)\right], \tag*{(10)}

where j∈{1,2,3,⋯nN}j \in\{1,2,3,\cdots n_N\}. In both Eq. (9) and Eq. (10), the ensembles are generated with Gaussian white noise as shown in Eq. (4), . At this point, we compute the background error covariance matrix, PD\mathbf{P}_D, using the nDn_D ensemble members evolved by MDM_D:

PD=E[(ψDi,j(t+αΔt)−ψ‾D(t+αΔt))(ψDi,j(t+αΔt)−ψ‾D(t+αΔt))T].(11)\mathbf{P}_D=\mathbb{E}\left[\left(\psi_D^{i,j}(t+\alpha\Delta t)-\overline{\psi}_D(t+\alpha\Delta t)\right)\left(\psi_D^{i,j}(t+\alpha\Delta t)-\overline{\psi}_D(t+\alpha\Delta t)\right)^{\mathsf{T}}\right]. \tag*{(11)}

Similar to Eq. (6), ψ‾D(t+αΔt)\overline{\psi}_D(t+\alpha\Delta t) denotes the mean of ψDi,j(t+αΔt)\psi_D^{i,j}(t+\alpha\Delta t) over nDn_D ensemble members. Since nN≪nDn_N \ll n_D, PD\mathbf{P}_D calculated with nDn_D ensemble members would have much lower sampling error as compared to the one computed with nNn_N ensemble members. Then, we compute Kalman gain, KD\mathbf{K}_D, as:

KD=PD(PD+σobsI)−1.(12)\mathbf{K}_D=\mathbf{P}_D\left(\mathbf{P}_D+\sigma_{obs}\mathbf{I}\right)^{-1}. \tag*{(12)}

Then we compute the ensemble of analysis states as:

ψai,j(t+αΔt)=ψNi,j(t+αΔt)−KD(ψobsi,j(t+αΔt)−ψNi,j(t+αΔt)),(13)\psi_a^{i,j}(t+\alpha\Delta t)=\psi_N^{i,j}(t+\alpha\Delta t)-\mathbf{K}_D\left(\psi_{obs}^{i,j}(t+\alpha\Delta t)-\psi_N^{i,j}(t+\alpha\Delta t)\right), \tag*{(13)}

where ψai,j(t+αΔt)\psi_a^{i,j}(t+\alpha\Delta t) is the ensemble of analysis states. Note that in Eq. (13), we have used nNn_N ensemble members of the background forecast state which are more accurate (since MNM_N is a more accurate numerical model that integrates physical equations as compared to the data-driven model, MDM_D). However, PD\mathbf{P}_D is obtained from the large number (nDn_D) of ensemble members from MDM_D to alleviate issues related to sampling error and spurious long-range correlations.

In H-EnKF, the nNn_N ensemble members (obtained as the analysis states) keep evolving for future DA cycles with the numerical model, as is done in a standard EnKF. However, after every DA cycle, we reinitialize the nDn_D ensemble members using Eq. (4), where ψ(t0)\psi(t_0) is replaced with ψ‾a(t+αΔt)\overline{\psi}_a(t+\alpha\Delta t) for t>t0t>t_0. This is because the data-driven models’ forecasts do not remain stable for long time scales [41, 46, 47].

It is important to note that, one can also use the data-driven model’s prediction to compute the background forecast state, i.e., a fully data-driven model without the need for any numerical integration [29]. However, the quality of such forecasts would depend on how frequently we perform DA. If the frequency of DA is small, i.e., we evolve the data-driven model for a long period of time before performing DA, the quality of the data-driven forecasted state would degrade. That would lead to inaccuracies in the computation of the analysis state.

Metrics for measuring performance

We define two metrics for measuring the performance of a model: relative error (Ek(t)E_k(t)) and Anomaly Correlation Coefficient (ACCk\mathrm{ACC}_k) for each layer, kk. Details on computing these metrics are given in Appendix A.

Results

Performance of U-NET for Fully Data-driven Prediction

First, we show the performance of fully data-driven predictions with U-NET trained on NtrN_{\mathrm{tr}} samples of ψk(t)\psi_k(t). Figure 3 shows the predicted patterns of the time-mean removed anomalies of ψ1(t)\psi_1(t) with U-NET trained on Ntr=104N_{\mathrm{tr}} = 10^4 and Ntr=105N_{\mathrm{tr}} = 10^5 samples. Qualitatively good performance up to day 3 can be seen in Figure 3 with both Ntr=104N_{\mathrm{tr}} = 10^4 and Ntr=105N_{\mathrm{tr}} = 10^5 samples.

Predicted patterns of time-mean removed $\psi_1(t)$ anomalies

Figure 3. Predicted patterns of time-mean removed ψ1(t)\psi_1(t) anomalies by the U-NET trained on Ntr=105N_{\mathrm{tr}} = 10^5 and Ntr=104N_{\mathrm{tr}} = 10^4 training samples as compared to the truth (obtained from numerical simulation). Note that only part of the latitudinal extent of the domain is shown.

We quantify the accuracy of the predicted ψ1\psi_1 using the metrics defined in section 4. Figure 4 shows that E1(t)E_1(t) is 22.2% lower for the U-NET trained with Ntr=105N_{\mathrm{tr}} = 10^5 samples as compared to the one trained with Ntr=104N_{\mathrm{tr}} = 10^4 samples at day 3. ACC1\mathrm{ACC}_1 in Figure 4 shows that both U-NETs have roughly the same prediction horizon (time at which ACC1≈0.60\mathrm{ACC}_1 \approx0.60).

Performance metrics of the U-NET trained on $N_{\mathrm{tr}} = 10^{5}$ and $N_{\mathrm{tr}} = 10^{4}$ samples

Figure 4. Performance metrics of the U-NET trained on Ntr=105N_{\mathrm{tr}} = 10^{5} and Ntr=104N_{\mathrm{tr}} = 10^{4} samples. (a) E1(t)E_{1}(t), where the subscript “1” refers to the first layer. (b) ACC1\mathrm{ACC}_{1} is the ACC for the first layer. Note that similar results are found for E2(t)E_{2}(t) and ACC for 2nd layer, but are not shown for brevity. Shading shows standard deviation over 100 random noise-free initial conditions.

For the H-EnKF framework, we would need the U-NET to predict the states of the system for only 1 day. For 1-day prediction, both the relative error and ACC metrics of the U-NETs are not sensitive to NtrN_{\mathrm{tr}}. We have used an U-NET trained on Ntr=105N_{\mathrm{tr}} = 10^5 samples as our data-driven model in the H-EnKF algorithm. However, using an U-NET trained on Ntr=104N_{\mathrm{tr}} = 10^4 samples, we would obtain the same performance for the H-EnKF algorithm. We have also conducted experiments where an energy-constrained loss function was used to train the U-NET and found no significant improvement over the baseline performance in short-term (not shown for brevity).

Performance of H-EnKF for DA

Next, we show the performance of H-EnKF as compared to standard EnKF for different values of nDn_D and nNn_N. For MDM_D in H-EnKF, we have used a U-NET trained on Ntr=105N_{\mathrm{tr}} = 10^5 samples. For regular EnKF, we assume that the dynamical model is the numerical solver of the QG system. As discussed in section 2.4, we have considered the observation noise, σobs=0.1\sigma_{\mathrm{obs}} = 0.1, to be 10% of the standard deviation (≈1.0\approx1.0) of ψk(t)\psi_k(t). Note that the computational cost (based on the wall-clock time of execution, see section 5.5 for details) of evolving 1 numerical ensemble member (nN=1n_N = 1) of the state vectors ψk(t)\psi_k(t) for one Δt\Delta t is similar to evolving 200 data-driven ensemble members (nD=200n_D = 200) using the U-NET.

Figure 5(a) and (Figure 5c) show that the best performance is given by H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10) followed by H-EnKF (nD=1000n_D = 1000, nN=10n_N = 10) and finally EnKF (nD=0n_D = 0, nN=20n_N = 20). Regular EnKF diverges due to the small number of ensemble members, a well known problem with EnKF in the absence of localization. Based on the computational cost analysis, EnKF (nD=0n_D = 0, nN=20n_N = 20) is as expensive as H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10) while the latter has

Performance of H-EnKF and standard EnKF for $\psi_1(t)$ over 60 DA cycles

Figure 5. Performance of H-EnKF and standard EnKF for ψ1(t)\psi_1(t) over 60 DA cycles. (a) E1(t)E_1(t) over 60 DA cycles for H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10), H-EnKF (nD=1000n_D = 1000, nN=10n_N = 10), and EnKF (nD=0n_D = 0, nN=20n_N = 20). (b) Same as (a) but for ACC1\mathrm{ACC}_1. (c) Zoomed in view of (a) between 0≤E1(t)≤0.150 \leq E_1(t) \leq0.15. (d) Zoomed in view of (b) between 0.90≤ACC1≤1.00.90 \leq\mathrm{ACC}_1 \leq1.0. Shading shows standard deviation over 30 random initial conditions. σb=0.80\sigma_b = 0.80 has been used for EnKF while σb=0.10\sigma_b = 0.10 has been used for the H-EnKF models. The σb\sigma_b value has been chosen to minimize the average E1(t)E_1(t) over 60 DA cycles based on extensive trial and error.

5× smaller average E1(t)E_1(t) over 60 DA cycles. Moreover, H-EnKF (nD=1000n_D = 1000, nN=10n_N = 10) is 0.75× cheaper than EnKF (nD=0n_D = 0, nN=20n_N = 20) with 3× smaller average E1(t)E_1(t) over 60 DA cycles.

A similar conclusion can be made from Figure 5(b) and (d) where ACC1\mathrm{ACC}_1 for H-EnKF algorithms remain ≈ 0.95 throughout the 60 DA cycles while EnKF (nD=0n_D = 0, nN=20n_N = 20) shows a rapid decrease in ACC1\mathrm{ACC}_1 from the beginning of the DA cycles (when localization is not performed). For H-EnKF, σb=0.10\sigma_b = 0.10 has been used to obtain the best performance. We have conducted several trials with different values of σb\sigma_b and chose the value that minimized the average E1(t)E_1(t) over 60 DA cycles.

These results demonstrate the effectiveness of the H-EnKF framework in terms of estimating a better initial condition from noisy observations of the system. In this framework, one can trade off a small number of computationally expensive numerical ensemble members with a large number of cheap data-driven ensemble members to improve the accuracy of the estimated analysis states without affecting the overall computational cost.

It must be kept in mind that the performance of standard EnKF can be improved by simply increasing the number of numerical ensemble members or with localization. In our experiments with QG, we have seen that stable and divergence-free filters can be obtained with O(1000)O(1000) numerical ensemble members. Figure B.9 in Appendix § 9 shows the performance of EnKF over 10 DA cycles with nN=1000n_N = 1000 and nN=5000n_N = 5000. For standard EnKF, σb=0.80\sigma_b = 0.80 has been used to obtain the best performance. Similar to H-EnKF, we had conducted several trials to obtain the best σb\sigma_b, that minimized the average E1(t)E_1(t) over 10 DA cycles. However, evolving O(1000)O(1000) ensemble members with the numerical solver comes at 50× more computational cost compared to H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10). Moreover, for other practical systems with higher dimensions, evolving such a large size of ensembles may not even be computationally tractable.

We have further demonstrated results with EnKF (nD=0,nN=20n_D = 0, n_N = 20) with localization in Fig. C.10 (Appendix § 10), which shows that localization can also improve the performance of EnKF in this system without any increase in the computational cost. However, in more complex systems, localization can remove long-range physical correlations and affect the accuracy of the estimated analysis states [26]. Furthermore, for other types of ensemble-based DA algorithms, such as particle filters, one may not be able to perform localization [48, 49]. Moreover, in particle filters, the large data-driven ensembles would provide an advantage in terms of sampling non-parametric and non-Gaussian distributions.

Analysis of Covariance Matrices

The superior performance of H-EnKF (nD=1000n_D = 1000, nN=10n_N = 10) and H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10) over EnKF (nD=0n_D = 0, nN=20n_N = 20) is due to the improved representation of the background error covariance matrix, PD\mathbf{P}_D, which is calculated using the nDn_D data-driven ensembles. Figure 6 shows that the 60 DA cycles-averaged covariance structure of grid point x=3.38x = 3.38 and y=1.21y = 1.21 is localized around that grid point for H-EnKF (nD=1000n_D = 1000, nN=10n_N = 10) and H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10). However, for EnKF (nD=0,nN=20n_D = 0, n_N = 20), the covariance structure is non-local with spurious long-range correlations across the domain. This is due to the reduction of sampling error during the computation of PD\mathbf{P}_{D} in Eq. (11) using the nDn_D ensembles. We have also shown the 10 DA cycles-averaged covariance structure of EnKF (nD=0n_D = 0, nN=5000n_N = 5000). Due to high computational cost, we have only performed 10 DA cycles with nN=5000n_N = 5000 ensembles. For this problem (≈36000\approx36000 states), one can consider this covariance matrix to be close to the true covariance. It is clear that the H-EnKF covariance matrices are similar to the true covariance but at significantly lower computational cost.

Normalized background covariance matrices for EnKF and H-EnKF

Figure 6. The normalized background covariance matrix averaged over 60 DA cycles, except EnKF (nD=0n_D = 0, nN=5000n_N = 5000) which is averaged over 10 DA cycles (due to limitations on computational cost). H-EnKF algorithms show more localized covariance structure and less spurious long-range correlation as compared to EnKF (nD=0n_D = 0, nN=20n_N = 20). The non-local structure of covariance of EnKF is due to low ensemble size leading to sampling error.

Performance of Free Prediction

Next, we compare the free prediction performance of the numerical model for the QG system with initial conditions that are obtained as the mean of the analysis states after 60 DA cycles (see Figure 5). In Figure 7(a) and (b), we demonstrate that the initial condition obtained from H-EnKF (nD=1000n_D = 1000, nN=10n_N = 10) has prediction skill up to 3.8 days, while H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10) shows prediction skill up to 4.5 days.

Performance of free prediction of the QG numerical solver

Figure 7. Performance of the free prediction of the QG numerical solver with initial condition (as mean analysis state) from H-EnKF. (a) E1(t)E_1(t) with initial condition at the end of 60 DA cycles. (b) ACC1\mathrm{ACC}_1 with the same initial condition as (a). (c) E1(t)E_1(t) with initial condition at the end of 10 DA cycles. (d) ACC1\mathrm{ACC}_1 with the same initial condition as (c). Shading shows standard deviation over 30 random initial conditions. Performance of initial condition from EnKF (nD=0n_D = 0, nN=20n_N = 20) is not shown because it has no prediction skill at all.

Figure 7(c) and (Figure 7d) show the free prediction of the numerical model for QG with initial conditions that are obtained as the mean of the analysis states after 10 DA cycles. Here, the initial condition obtained from H-EnKF (nD=1000n_D = 1000, nN=10n_N = 10) has prediction skill up to 4.1 days and H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10) has prediction skill up to 5.8 days.

We have not shown the free prediction performance of the initial condition from the standard EnKF because the analysis states obtained from the algorithm have too large of an error, as can be seen in Figure 5, leading to no prediction skill at all.

An important point to notice in Figure 7 is the difference between the prediction skill of the initial condition obtained from H-EnKF (nD=1000n_D = 1000, nN=10n_N = 10) and H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10). Although the initial conditions from both the models qualitatively seem to be very close, as is evident from inspecting E1(t)E_1(t) in Figure 5, they result in significant difference in prediction skill (≈0.7\approx0.7 days for the initial condition at 60 DA cycles and 1.7 days for the initial condition at 10 DA cycles). This shows that increasing nDn_D (which is 200×200 \times cheaper than nNn_N) to compute PD\mathbf{P}_D leads to significant improvement in the quality of the analysis states which in turn leads to an improvement in the prediction skill of the numerical model.

Computational Cost Analysis and Scaling

In this section, we discuss how the mean error over 10 DA cycles, ⟨E1(t)⟩\langle E_1(t) \rangle, where ⟨⋅⟩\langle\cdot\rangle denotes mean over 10 DA cycles, scales with the computational cost associated with different EnKF and H-EnKF algorithms. To have a fair cost comparison, we have executed both the EnKF and H-EnKF algorithms on the same hardware. The computations of background error covariance matrix, Kalman gain, and analysis states have been performed on an AMD EPYC 7742 CPU with 64 cores for both EnKF and H-EnKF. The numerical model has been executed on the same CPU. However, the U-NET is run on a NVIDIA Tesla V100 GPU. We have not neglected the overhead cost of transferring data from GPU to CPU for H-EnKF. There are two things to note about the performance of the numerical simulation. First, one could have used a GPU-enabled numerical model as well, which would significantly improve its runtime performance. However, the overarching goal of this work is to facilitate DA in practical large scale problems. In many practical problems, state-of-the-art simulation codes for fluid dynamics, combustion, weather prediction, etc., are CPU-based and would require enormous amounts of resources to refactor on GPUs. Second, one could have used a distributed-parallel numerical solver, which would also improve its runtime performance. However, one can also execute the U-NET on distributed GPUs as well, wherein the runtime performance gain due to distributed parallelism would be equivalent between the U-NET and the numerical solver. Owing to these careful observations and considerations, our computational cost analysis is fair.

Here, we define 1 computational cost unit as the “wall-clock” runtime of evolving nN=1n_N = 1 ensemble member with the dynamical model over one Δt\Delta t. Experimentally, we find that the runtime of nN=1n_N = 1 ensemble member is the same as the runtime of nD=200n_D = 200 ensemble members with the U-NET model over one Δt\Delta t. To obtain a robust measure of runtime for the U-NET for one Δt\Delta t, we had run the U-NET for 200Δt200\Delta t and recorded the wall-clock time averaged over 100 independent runs as T200ΔtDT^{D}_{200\Delta t}. From here, the runtime for the U-NET over 1Δt1\Delta t is obtained as T200ΔtD/200T^{D}_{200\Delta t}/200. For the numerical solver, we had followed the same procedure to obtain the runtime for evolving one numerical ensemble member over one Δt\Delta t as T200ΔtN/200T^{N}_{200\Delta t}/200.

In Figure 8(a), EnKF (nD=0n_D = 0, nN=20n_N = 20) shown with red circle has ⟨E1(t)⟩\langle E_1(t)\rangle of 52.6% with computational cost of 20 units. H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10) shown with black circle has a factor of 5 smaller error at the same computational cost. By increasing the number of numerical ensemble members to nN=90n_N = 90 and keeping the same number of data-driven ensemble members (nD=2000n_D = 2000), ⟨E1(t)⟩\langle E_1(t)\rangle goes down by a factor of 1.07 but at 5 times higher computational cost. With a further increase in cost to 2000 units, ⟨E1(t)⟩\langle E_1(t)\rangle of EnKF (nD=0n_D = 0, nN=2000n_N = 2000) improves by a factor 1.5 in comparison to H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10). At the same cost, ⟨E1(t)⟩\langle E_1(t)\rangle of H-EnKF (nD=2000n_D = 2000, nN=1990n_N = 1990) improves by a factor of 4.0. From this analysis, it is quite clear that trading a small number of numerical ensemble members for a large number of data-driven ones leads to a significant improvement in performance without an increase in computational cost.

Figure 8. Computational cost and accuracy scaling for H-EnKF and EnKF algorithms. Here, we have shown ⟨E1(t)⟩\langle E_1(t)\rangle, the mean of E1(t)E_1(t), over 10 DA cycles (instead of 60) because of the high computational cost associated with computing 60 DA cycles on EnKF models with large numerical ensembles (O(1000)O(1000)). (a) ⟨E1(t)⟩\langle E_1(t)\rangle of different H-EnKF and EnKF algorithms along with their computational cost. (b) Scaling of ⟨E1(t)⟩\langle E_1(t)\rangle at different levels of fixed computational cost for different H-EnKF and EnKF models. The unit for computational cost is the runtime for the numerical QG solver to evolve one numerical ensemble for one Δt\Delta t, T200Δt/200T_{200}\Delta t/200. See § 5.5 for more details.

Figure 8(b) shows the scaling of ⟨E1(t)⟩\langle E_1(t)\rangle for H-EnKF and EnKF having different levels of fixed computational cost. We see that the effect of the background forecast derived from nNn_N is more pronounced when nNn_N is large (nN=2000n_N = 2000) (given by the black squares). Keeping the cost fixed at 2000 units, adding more nDn_D (nD=0n_D = 0 to nD=2000n_D = 2000), decreases the error only very slightly (from 6.5% to 2.5%). For low nNn_N (nN=100n_N = 100 or nN=20n_N = 20), adding more nDn_D significantly improves the performance of H-EnKF, shown by the blue circles (from 29.5% to 9.46%) or red asterisk (from 48% to 9.40%). It must be noted that H-EnKF (nD=2000n_D = 2000, nN=10n_N = 10) at 5×5\times smaller cost performs almost equally well as H-EnKF (nD=2000n_D = 2000, nN=90n_N = 90). A further improvement in the error (about 4×4\times) is seen only with a 100×100\times increase in computational cost.

Discussion and Summary

In this paper, we have proposed H-EnKF: a hybrid ensemble Kalman filter algorithm that leverages a deep learning-based data-driven model to efficiently evolve a large ensemble of states of a dynamical model to better estimate the background error covariance with low sampling error. The ensemble of background forecast states used in the H-EnKF algorithm is obtained from an accurate, high-resolution, numerical solver evolving a small number of ensemble of states (owing to computational cost). This combination allows one to obtain an accurate DA algorithm at low computational cost alleviating one of the major

sources of error –sampling error in covariance due to low ensemble size– without the need for localization.

There is a major difference between how the numerical ensembles are evolved throughout the DA cycles as compared to the data-driven ensembles in H-EnKF. In H-EnKF, after every DA cycle, the data-driven ensembles are regenerated with Gaussian noise added to the mean of the analysis states. This is due to a limitation of current data-driven models for high-dimensional systems, which become unstable when evolved for a long period of time [41, 47, 46]. We acknowledge that in more complex systems, this approach can cause issues, as frequently perturbing the state can violate conservation laws, e.g., of mass (this is not a problem here as we are perturbing streamfunctions, ψ\psi). In such problems, the perturbation should be added such that they do not violate the conservation laws, e.g., see Zeng et al. [50].

We have shown that the H-EnKF algorithm achieves a stable filter without localization and has a factor of 5 smaller error at the same computational cost as that of standard EnKF for the two-layer QG system (Figure 5). We have further shown that H-EnKF is most useful for situations where one can only afford small numerical ensembles (Figure 8). In such situations, one can trade off a small number of numerical ensemble members for a larger number of data-driven ones and obtain a more accurate covariance estimation. In H-EnKF applied to the two-layer QG system, the runtime for the evolution of the data-driven ensembles is a factor 200 smaller than the numerical ones. However, in more practical problems, such as weather prediction, the difference in runtime between evolving data-driven and numerical ensembles can be much larger, e.g., in FourCastNet [44], the data-driven model is 100000×100000 \times faster than the state-of-the-art operational weather forecasting models. We expect the H-EnKF algorithm to be most effective for high-dimensional problems such as these.

As a test case, the proposed hybrid framework has been applied to EnKF, a specific ensemble-based DA algorithm that is used with Gaussian observation noise. However, one can readily extend this hybrid framework to other types of novel extensions of regular EnKF, e.g., multi-model EnKF [51] or other ensemble-based DA algorithms, e.g., particle filters. Particle filters are especially useful for systems with strong non-Gaussian observation noise. However, due to large computational cost, it has been difficult to use in high-dimensional systems such as geophysical flows [52, 48]. For future work, we aim to explore how the H-EnKF algorithm can be used in particle filter-based DA.

The EnKF algorithms with small ensemble members are currently used in weather prediction by leveraging ad-hoc techniques such as localization that removes spurious long-range correlations. Localization can also remove physical correlations in the flow fields as well, which would result in inaccuracies in the covariance [26]. Due to low computational cost during inference, deep learning-based surrogates can generate a large ensemble of states that can better approximate the true background covariance as compared to artificially obtained covariance with localization. However, for applications where localization works well, one can use localization on the covariance matrix obtained from the data-driven ensembles in our hybrid framework. In such scenarios, we can bring down the computational cost even further by evolving only a small number of data-driven ensembles (which are already quite inexpensive to evolve). Moreover, localization may be difficult to perform on other ensemble-based DA algorithms, e.g., particle filters. For such algorithms, our hybrid approach which does not require localization would be useful as well.

One of the key aspects of the H-EnKF framework is the accurate data-driven surrogate which needs to be built for every application. However, building a fully data-driven surrogate for high-dimensional realistic systems, e.g., weather and climate, can be challenging. Recent successes in data-driven short-term weather modeling [53, 29, 44] show that short-term accurate surrogates can be as accurate as operational numerical models if trained on observations [44]. Further improvement in data-driven surrogates can be achieved by conserving key physics as can be seen in many different applications in both fluids [54] and weather and climate community [43].

Acknowledgements

We thank Matti Morzfeld and Yonquiang Sun for insightful comments and discussions. This work was supported by an award from the ONR Young Investigator Program (N00014-20-1-2722) and a grant from the NSF CSSI program (OAC-2005123) to P.H. Computational resources were provided by NSF XSEDE (allocation ATM170020) to use Bridges GPU and the Rice University Center for Research Computing. The codes for H-EnKF are publicly available at https://github.com/ashesh6810/Hybrid-Ensemble-Kalman-Filter.

Equations for Error metrics

We define relative error as:

Ek(t)=∥ψkpred(t)−ψktrue(t)∥2max⁡(ψktrue(t))(14)E_k(t) = \frac{\lVert\psi_k^{pred}(t) - \psi_k^{true}(t) \rVert_2}{\max\left(\psi_k^{true}(t)\right)} \tag*{(14)}

ψkpred\psi_k^{pred} is the predicted streamfunction and ψktrue\psi_k^{true} is the true streamfunction obtained from numerical simulations.

We define ACCk\mathrm{ACC}_k as:

ACCk=∑m∑p(ψk,m,ppred(t)−⟨ψk,m,ptrue⟩)(ψk,m,ptrue(t)−⟨ψk,m,ptrue⟩)(∑m∑p(ψk,m,ppred(t)−⟨ψk,m,ptrue⟩)2)×(∑m∑p(ψk,m,ptrue(t)−⟨ψk,m,ptrue⟩)2)(15)\mathrm{ACC}_k = \frac{\sum_m \sum_p \left(\psi_{k,m,p}^{pred}(t) - \left\langle\psi_{k,m,p}^{true}\right\rangle\right)\left(\psi_{k,m,p}^{true}(t) - \left\langle\psi_{k,m,p}^{true}\right\rangle\right)}{\sqrt{\left(\sum_m \sum_p \left(\psi_{k,m,p}^{pred}(t) - \left\langle\psi_{k,m,p}^{true}\right\rangle\right)^2\right) \times\left(\sum_m \sum_p \left(\psi_{k,m,p}^{true}(t) - \left\langle\psi_{k,m,p}^{true}\right\rangle\right)^2\right)}} \tag*{(15)}

where ⟨ψk,m,ptrue⟩\left\langle\psi_{k,m,p}^{true}\right\rangle is the time-averaged value of ψk,m,ptrue(t)\psi_{k,m,p}^{true}(t) and the indices mm and pp refer to the latitudinal and longitudinal grid points on which ψk(t)\psi_k(t) is represented. Similar to Ek(t)E_k(t), ACC is also computed for each layer.

EnKF with Large Numerical Ensembles

Here, we show that EnKF with a large number of numerical ensemble members (nNn_N) can have stable and divergence-free filters with low E1(t)E_1(t). However, in order to have performance comparable to H-EnKF, one needs to have O(1000)O(1000) nNn_N which comes at a high computational cost. Figure B.9 shows that as nNn_N increases, the performance of EnKF improves as well. This is expected since with large ensembles, the matrix, P\mathbf{P}, would not suffer from sampling error and spurious correlations, as shown in Figure 6 as well.

EnKF with Small Numerical Ensembles and Localization

In Fig. C.10, we report E1(t)E_1(t) and ACC1\mathrm{ACC}_1 for EnKF (nD=0n_D = 0, nN=20n_N = 20) with and without localization. Here, we have used covariance localization [3]. The Gaspari-Cohn function is used to generate the regularizing correlation function. A radius of 5l5l, where ll is the L2L_2 distance between two consecutive grid points, has been used as the radius in the Gaspari-Cohn function. In this system, localization is an effective method to obtain divergence-free filters with similar performance as H-EnKF (nD=2000n_D = 2000, nN=20n_N = 20). However, it must be noted that localization often removes long-range physical correlations as well and is required to be tuned for each application in more complex systems [26].

Performance of EnKF for $\psi_1(t)$ over 10 DA cycles with large $n_N$

Figure B.9. Performance of EnKF for ψ1(t)\psi_1(t) over 10 DA cycles with large nNn_N. Due to the computational cost of evolving large ensembles, we only report E1(t)E_1(t) and ACC1\mathrm{ACC}_1. (a) E1(t)E_1(t) for EnKF (nD=0n_D = 0, nN=20n_N = 20), EnKF (nD=0n_D = 0, nN=1000n_N = 1000), and EnKF (nD=0n_D = 0, nN=5000n_N = 5000). (b) Same as (a) but for the ACC1\mathrm{ACC}_1. (c) Zoomed in view of (b) between 0.90≤ACC1≤1.00.90 \leq\mathrm{ACC}_1 \leq1.0. Shading shows standard deviation over 30 initial conditions. σb=0.80\sigma_b = 0.80 has been used for all the EnKF algorithms. The σb\sigma_b value has been chosen to minimize the average E1(t)E_1(t) over 10 DA cycles based on extensive trial and error.

Performance of EnKF for $\psi_{1}(t)$ over 10 DA cycles with localization

Figure C.10. Performance of EnKF for ψ1(t)\psi_{1}(t) over 10 DA cycles with localization. (a) E1(t)E_{1}(t) over 10 DA cycles for EnKF (nD=0n_{D}=0, nN=20n_{N}=20) and EnKF (nD=0n_{D}=0, nN=20n_{N}=20) with localization. (b) Same as (a) but for ACC1_{1}. Shading shows standard deviation over 30 initial conditions. σb=0.80\sigma_{b}=0.80 has been used for both the EnKF algorithms. The σb\sigma_{b} value has been chosen to minimize the average E1(t)E_{1}(t) over 10 DA cycles based on extensive trial and error.

References

  1. [1]E. Kalnay, Atmospheric modeling, data assimilation and predictability, Cambridge university press, 2003.DOI
  2. [2]K. Law, A. Stuart, K. Zygalakis, Data assimilation, Springer, 2015.arxiv.org/abs/1506.07825
  3. [3]M. Asch, M. Bocquet, M. Nodet, Data assimilation: methods, algorithms, and applications, SIAM, 2016.
  4. [4]M. Morzfeld, J. Adams, S. Lunderman, R. Orozco, Feature-based data assimilation in geophysics, Nonlinear Processes in Geophysics 25 (2) (2018) 355–374.DOI
  5. [5]M. Morzfeld, D. Hodyss, Gaussian approximations in filters and smoothers for data assimilation, Tellus A: Dynamic Meteorology and Oceanography 71 (1) (2019) 1600344.DOI
  6. [6]E. N. Lorenz, Predictability: A problem partly solved, in: Proc. Seminar on predictability, Vol. 1, 1996, pp. 1–18.
  7. [7]A. Carrassi, M. Bocquet, L. Bertino, G. Evensen, Data assimilation in the geosciences: An overview of methods, issues, and perspectives, Wiley Interdisciplinary Reviews: Climate Change 9 (5) (2018) e535.arxiv.org/abs/1709.02798

Paper details

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

views · 6

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