---
title: 'DLKoopman: Deep Learning Koopman Methods'
url: https://www.emergentmind.com/topics/dlkoopman
type: topic
---

# DLKoopman: Deep Learning Koopman Methods

Searching arXiv for recent papers on DLKoopman and closely related Koopman deep-learning methods.
Searching for “DLKoopman” on arXiv.
DLKoopman denotes, in its most specific and documented sense, a deep-learning Koopman framework implemented as an open-source Python package that learns a nonlinear encoding of a dynamical system into a latent space with linear evolution, while simultaneously learning the latent linear dynamics [2211.08992]. In adjacent literature, however, the same label is not fully standardized. It can refer to deep Koopman models for controlled nonlinear systems, and in at least one fluid-dynamics paper it refers not to a neural architecture at all but to a Koopman-based reduced-order modeling strategy built on Dynamic Mode Decomposition (DMD) [2202.08004]. The term therefore names a research direction centered on data-driven Koopman liftings, latent linearity, and reduced-order prediction, rather than a single immutable algorithm.

## 1. Terminological scope and principal meanings

The literature uses the label “DLKoopman” in more than one sense. The most explicit usage is the software package “DLKoopman: A deep learning software package for Koopman theory,” which is distributed on PyPI as `dlkoopman` and was reported at version **1.1.2** at submission time [2211.08992]. That package is presented as a generalized tool for learning encoders, decoders, and latent linear dynamics for either state prediction from snapshots or trajectory prediction from rollout data.

A second usage appears in work on nonlinear control, where the relevant object is a deep Koopman model with control. There, the central problem is to learn a Koopman embedding and Koopman operator jointly, together with an auxiliary control network that handles nonlinear or state-dependent control effects while preserving latent linearity for Linear Quadratic Regulator (LQR) design [2202.08004].

A third usage appears in reduced-order modeling for fluid dynamics. That paper explicitly states that **DLKoopman in this paper is not a separate neural network model but a Koopman-based reduced-order modeling strategy built on Dynamic Mode Decomposition (DMD)** [2409.03549].

| Usage of the label | Characterization | Representative source |
|---|---|---|
| DLKoopman software package | Deep-learning Koopman tool for state and trajectory prediction | [2211.08992] |
| Deep Koopman with control | End-to-end latent linear model with auxiliary control network and LQR | [2202.08004] |
| DMD-based reduced-order modeling label | Koopman/DMD reduction pipeline, not a separate neural network | [2409.03549] |

This multiplicity is consequential. It means that “DLKoopman” can denote a software artifact, a modeling architecture, or a broader Koopman-learning workflow, depending on context.

## 2. Core formulation of the DLKoopman software package

In the package-centered formulation, Koopman theory is used to map a nonlinear state $\mathbf{x}$ to a latent state $\mathbf{y}$ through an encoder $g(\cdot)$,
$$
\mathbf{y} = g(\mathbf{x}),
$$
and latent evolution is imposed to be linear. In continuous time, the package uses
$$
\frac{d\mathbf{x}}{di} = f(\mathbf{x}(i)), \qquad 
\frac{d\mathbf{y}}{di} = \mathbf{\mathcal{K}} \mathbf{y}(i),
$$
with solution
$$
\mathbf{y}(i) = e^{\mathbf{\mathcal{K}} i}\mathbf{y}(0) 
= \mathbf{W} e^{\mathbf{\Omega} i}\mathbf{W}^{\dagger}\mathbf{y}(0),
\qquad \forall i \in \mathbb{R},
$$
followed by decoding
$$
\mathbf{x} = g^{-1}(\mathbf{y}).
$$
In discrete time, the latent system is
$$
\mathbf{y}_{i+1} = \mathbf{K}\mathbf{y}_i, \qquad
\mathbf{y}_i = \mathbf{K}^i \mathbf{y}_0
= \mathbf{W}\mathbf{\Lambda}^i\mathbf{W}^{\dagger}\mathbf{y}_0,
\qquad \forall i \in \mathbb{Z}.
$$
The package emphasizes an MLP autoencoder structure: the encoder maps $\mathbf{x}\mapsto\mathbf{y}$, the decoder maps $\mathbf{y}\mapsto\mathbf{x}$, and the latent space is chosen so that dynamics there are as linear as possible [2211.08992].

Two operating modes are distinguished. **State prediction from snapshot data** takes individual states $\{\mathbf{x}_i,\, i\in I\}$ and predicts states at unknown indices $i' \notin I$, including forward extrapolation, backward extrapolation, and interpolation. In this mode, encoded snapshot matrices are formed,
$$
\mathbf{Y}_{\text{prev}} = [\mathbf{y}_{i_0}\ \mathbf{y}_{i_1}\ \cdots\ \mathbf{y}_{i_{m-1}}],
\qquad
\mathbf{Y}_{\text{next}} = [\mathbf{y}_{i_1}\ \mathbf{y}_{i_2}\ \cdots\ \mathbf{y}_{i_m}],
$$
and the finite Koopman matrix is estimated by
$$
\mathbf{K} = \mathbf{Y}_{\text{next}}\mathbf{Y}_{\text{prev}}^{\dagger}.
$$

**Trajectory prediction from rollout data** uses full trajectories
$$
\left\{[\mathbf{x}^j_0,\mathbf{x}^j_1,\dots,\mathbf{x}^j_m],\ j\in\{j_1,\dots,j_J\}\right\},
$$
and learns the Koopman matrix directly as the weights of a linear neural network layer with equal input and output dimension, no bias, and no activation function. Rollout then proceeds by repeated application of
$$
\mathbf{y}_{i+1} = \mathbf{K}\mathbf{y}_i.
$$
The package notes an intrinsic limitation of this trajectory mode: because the linear layer is iterated forward, it is naturally suited only to positive integer steps [2211.08992].

## 3. Training objective, evaluation, and software workflow

The package jointly optimizes latent linearity, reconstruction, and prediction. Its overall loss is
$$
L = L_{\text{lin}} + \alpha\left(L_{\text{recon}} + L_{\text{pred}}\right)
+ \beta L_{\text{Autoencoder}} + \gamma L_{\mathbf{K}},
$$
where all core losses are computed using MSE [2211.08992]. In the package’s interpretation, reconstruction enforces $\mathbf{x}\approx g^{-1}(g(\mathbf{x}))$, linearity enforces $\mathbf{y}_{i+1}\approx \mathbf{K}\mathbf{y}_i$, and prediction compares decoded latent predictions against real states.

A distinct software contribution is the metric **Average Normalized Absolute Error (ANAE)**:
$$
\text{ANAE}(\mathbf{p},\mathbf{q})
= \text{Avg}_{p_i \ne 0}\left(\frac{|p_i-q_i|}{|p_i|}\right).
$$
The package presents ANAE as a human-readable measure of how far a prediction deviates from the reference relative to the reference magnitude. The implementation also includes a hyperparameter-search module that can sample a user-specified space of configurations and rank models by criteria such as `avg_pred_anae_va` on validation data [2211.08992].

The state-prediction example in the package paper uses pressure distributions over a NACA0012 airfoil. Each state is a **200-dimensional pressure vector**, and an illustrative configuration is
```python
StatePred(
    dh = dh,
    rank = 6,
    encoded_size = 50,
    encoder_hidden_layers = [100]
)
```
with training parameters
```python
sp.train_net(
    numepochs = 1000,
    decoder_loss_weight = 0.1,
    weight_decay = 1e-5,
    Kreg = 0
)
```
The reported result is **6.95% prediction ANAE** on test data, after which the trained model can be used for interpolation and extrapolation at unseen indices such as \(3.75^\circ\) and \(21^\circ\) [2211.08992].

The trajectory-prediction example uses the polynomial manifold system
$$
\dot{x}_1 = \mu x_1,\qquad
\dot{x}_2 = \lambda(x_2 - x_1^2), \qquad \lambda < \mu < 0,
$$
with about **10,000 trajectories**. The package paper presents this as evidence that the framework can handle standard Koopman benchmark-style rollout data in addition to sparse snapshot interpolation [2211.08992].

## 4. Deep Koopman formulations for control

A major extension of the DLKoopman idea concerns controlled nonlinear systems. In that setting, the central model begins from
$$
x_{k+1} = F(x_k,u_k),
$$
and replaces the usual linear-control Koopman assumption
$$
g_x(x_{k+1}) = K_{xx} g_x(x_k) + K_{xu} u_k
$$
with a learned decomposition
$$
g(x,u) = [g_x(x,u);\, g_u(x,u)], \qquad g_x(x,u)=g_x(x),
$$
so that latent dynamics become
$$
g_x(x_{k+1}) = K_{xx} g_x(x_k) + K_{xu} g_u(x_k,u_k).
$$
The state embedding concatenates the original state with learned nonlinear features,
$$
z_k = g_x(x_k) = \begin{bmatrix} x_k \\ g_\theta(x_k) \end{bmatrix},
$$
and recovers the original state by the fixed linear map
$$
x_k = Cz_k, \qquad
C = \begin{bmatrix} I_n & 0 \end{bmatrix}.
$$
The Koopman matrices are parameterized as linear layers,
$$
K_{xx}=A,\qquad K_{xu}=B,
$$
yielding
$$
z_{k+1} = A z_k + B\, g_\phi(x_k,u_k).
$$
Three variants are defined: **DKUC**, where $g_u(x_k,u_k)=u_k$; **DKAC**, where $g_u(x_k,u_k)=g_u(x_k)u_k$ with $g_u(x_k)$ parameterized by a neural network; and **DKN**, where $g_u(x_k,u_k)=g_\phi(x_k,u_k)$ is fully nonlinear [2202.08004].

Training uses a weighted $K$-step prediction loss
$$
L(\theta,\phi) = \sum_{i=1}^{K} \gamma^{i-1}\, MSE(Z_i,\hat Z_i),
$$
which explicitly favors multi-step rollout consistency. Control is then posed as an LQR problem in latent space:
$$
\min_{\hat u_{t=1,\dots,\infty}}
\sum_{t=1}^{\infty}
(z_t-z_t^{des})^T\hat Q(z_t-z_t^{des}) +\hat u_t^T\hat R\hat u_t
$$
subject to
$$
z_{t+1}=Az_t+B\hat u_t,\qquad z_0=g_x(x_0),
$$
with latent optimal control
$$
\hat u_t^* = K_{LQR}(z_t-z_t^{des})
$$
and actual actuation recovered by inverse control decoding,
$$
u_t^* = g_\phi^{-1}(x_t,\hat u_t^*).
$$
For DKUC this inversion is trivial, while for DKAC it reduces to
$$
u_t^* = g_\phi(x_t)^{-1}\hat u_t^*.
$$

The reported environments are **DampingPendulum**, **Pendulum**, **MountainCarContinuous**, **CartPole**, **DoublePendulum**, and a **Franka** 7-DOF robotic manipulator. On the **15th-step error** metric, the paper reports, for example, on **DampingPendulum**: KRBF \(2.700\times 10^{-2}\), KDNN \(2.517\times 10^{-2}\), KRNN \(2.032\times 10^{-2}\), DKUC \(2.835\times 10^{-2}\), DKAC \(9.511\times 10^{-3}\), and DKN \(2.575\times 10^{-3}\). On **CartPole**, DKN achieves \(8.423\times 10^{-3}\), and on **Franka**, DKUC, DKAC, and DKN all report errors on the order of \(10^{-3}\) [2202.08004].

The same paper records several limitations. **DKN inverse control decoding is hard**, input constraints are not handled, scalability to very high-dimensional systems remains open, and performance still depends on the learned embedding quality and data coverage. These limitations are structural rather than incidental: they arise from the requirement that a learned nonlinear embedding remain compatible with linear latent control design [2202.08004].

## 5. Reduced-order modeling, turbulent flows, and the nonuniform use of the term

A distinct line of work places deep Koopman learning in reduced-order modeling for complex flows. In the study of turbulent shear flows, the observable vector is written as
$$
\boldsymbol{\Psi}(\boldsymbol{h}) \in \mathbb{R}^{d_K},
$$
with the first \(d_h\) components equal to manifold coordinates and the remaining components learned by neural networks. The approximate Koopman matrix is estimated in an EDMD-DL style,
$$
K = \boldsymbol{\psi}(t+\delta t)\,\boldsymbol{\psi}(t)^\dagger,
$$
and training minimizes a Frobenius-norm loss. Long-horizon rollout is stabilized by **Projected Koopman Dynamics**,
$$
\boldsymbol{h}(t+\delta t) = \mathsfbi{P}\,\mathsfbi{K}\,\boldsymbol{\Psi}(\boldsymbol{h}(t)),
$$
which evolves observables linearly and projects back to the state coordinates at every step [2407.16542].

For minimal flow unit plane Couette flow, dimension reduction is essential because the DNS state dimension is on the order of \(10^5\). The paper first projects onto **256 POD modes**, retaining about **99.8\%** of the energy, yielding a **502-dimensional representation** after symmetry handling, and then uses a variant of IRMAE-WD, denoted **IRMAE-WD-B**, to obtain low-dimensional manifold coordinates. The singular values drop by orders of magnitude for dimensions roughly \(32\)–\(36\), and the modeling choice is **\(d_h=36\)**. Reported results include accurate short-time prediction over about \(3\tau_L\), good recovery of long-time Reynolds stresses and energy-balance statistics, and instability of KDManD for very long times beyond about \(40\tau_L\) [2407.16542].

The fluid-dynamics reduced-order modeling paper [2409.03549] is important chiefly because it clarifies nomenclature. It states that **DLKoopman in this paper is not a separate neural network model but a Koopman-based reduced-order modeling strategy built on Dynamic Mode Decomposition (DMD)**. The setting is a nonlinear dynamical system
$$
\frac{dy}{dt}(x,t)=f(y,u,t), \qquad y(x,t_0)=y_0(x),
$$
with Koopman operator
$$
\mathcal{K}^t \varphi = \varphi(F^t).
$$
Snapshots are organized as
$$
V=[u_0\;u_1\;\dots\;u_{N_t}] \in \mathbb{R}^{N_x\times (N_t+1)},
$$
with shifted matrices
$$
V_0=[u_0\;u_1\;\dots\;u_{N_t-1}],\qquad
V_1=[u_1\;u_2\;\dots\;u_{N_t}],
$$
and reduced reconstruction
$$
u_{DMD}(x,t_i) = \sum_{j=1}^{N_{DMD}} a_j(t_i)\lambda_j^{\,i-1}\phi_j(x),
\qquad i=1,\dots,N_t.
$$
Its distinctive element is a mode weight
$$
w\mathcal{K}_j = \int_{\Delta t}^{t_{N_t}} \sum_{i=1}^{N_t} a_j(t)\lambda_j^{i-1}\,dt,
$$
together with the relative reconstruction error
$$
Er_{DMD} = \frac{\left\|u(x)-u_{DMD}(x)\right\|_2}{\left\|u(x)\right\|_2}.
$$

In the shallow-water test case, the training set comprises **289 unsteady solutions**, sampled every \(\Delta t = 1800\) s, for each solution variable \(h,u,v\). Two experiments are reported, with \(\varepsilon=10^{-3}\) and \(\varepsilon=10^{-4}\). For the height field \(h\), the numbers of selected modes are **21** and **67**; for \(u\), **116** and **199**; for \(v\), **151** and **212**. In the first test, the model rank decreases from **288** to **21** for \(h\), a **92.70\% reduction**, and the reported relative errors are on the order of \(\mathcal{O}(10^{-3})\); in the stricter second test, errors are on the order of \(\mathcal{O}(10^{-4})\) [2409.03549].

These two papers show that the DLKoopman label can refer either to neural latent-space Koopman learning or to Koopman-based reduced-order model selection in a DMD pipeline. The shared principle is linearized evolution in an observable space; the implementation details differ substantially.

## 6. Methodological context, neighboring approaches, and persistent limitations

The broader Koopman literature clarifies why DLKoopman methods are attractive and why they remain technically delicate. A systems-and-control survey emphasizes that the central difficulty is not the linear algebra of Koopman evolution itself, but learning the right observables or eigenfunctions from finite data so that a finite-dimensional approximation is predictive and useful for control [2102.02522]. This observation situates DLKoopman within a larger design space of latent coordinates, invariant subspaces, and finite-dimensional closures.

Several neighboring methods address specific weaknesses of generic deep latent observables. **Analytic EDMD** replaces the usual \(L^2\)-based EDMD approximation with a Taylor-structured projection in an analytic reproducing kernel Hilbert space. Near a hyperbolic equilibrium, that construction preserves the triangular structure of the Koopman operator, does not suffer from **spectral pollution**, and can reach arbitrary spectral accuracy with a fixed finite basis size by improving the empirical approximation of the inner products [2405.15945]. **Koopman-Schur decomposition** replaces fragile eigenvector-based mode extraction by a unitary Schur decomposition,
$$
\widehat U = QTQ^*,
$$
and thereby shifts attention from ill-conditioned eigenvectors to orthonormal bases of invariant subspaces, which is especially relevant for highly non-normal or nearly defective Koopman compressions [2312.15837]. **Time-delay observables** provide a universal coordinate system in which the Koopman generator has coefficients
$$
K_{jk}=\langle \phi_j,\phi_k'\rangle,
$$
and the SVD/Hankel basis is identified as an optimal finite-dimensional basis in several senses [1810.01479].

Other recent approaches tackle interpretability and symbolic structure. **Deep-Koopman-KANDy** replaces the encoder and decoder of a Deep-Koopman operator with two-layer Kolmogorov–Arnold Networks, then performs post-hoc symbolic dictionary readout through a level-set construction and the chain-rule identity
$$
h'(g(x))=\frac{\nabla f(x)\cdot \nabla g(x)}{\|\nabla g(x)\|^2}.
$$
On Lorenz, it reports recovery of the target dictionary \(\{x,y,z,xy,xz\}\) with **perfect recall** and **Jaccard score \(0.79\pm0.06\)**; on the Arnold cat map, where finite-dimensional Koopman closure is provably impossible, it fails to find a sparse closure, as expected [2605.06000]. **Koopman Regularization** instead learns a functionally independent minimal set of Koopman eigenfunctions or unit velocity measurements by minimizing the Koopman Partial Differential Equation under an explicit functional-independence constraint, and reports noise reduction of about **60\% and above** together with **81\%** noise reduction in one imaginary-eigenvalue linear case and **2.5\%** MSE for a dimensionality-reduction experiment on Lorenz [2403.11302].

These neighboring developments make clear that DLKoopman methods face recurring issues: latent observables learned by deep networks are flexible but often opaque; finite-dimensional closures may be approximate, local, or data-dependent; control-oriented architectures can require invertible control encodings; and long-horizon stability can degrade even when short-term prediction is accurate. The term “DLKoopman” therefore names an active intersection of deep representation learning and Koopman operator theory whose practical utility is established, but whose notions of closure, spectral faithfulness, robustness, and interpretability remain method-dependent rather than universal.

Source: https://www.emergentmind.com/topics/dlkoopman