⚡ electrical engineering

Deep Koopman Learning using Noisy Data

This paper proposes a deep learning framework that approximates the Koopman operator for dynamical systems under noisy observations by characterizing and mitigating measurement noise effects through updates to observable function parameters, requiring only bounded noise assumptions.

Original authors: Wenjian Hao, Devesh Upadhyay, Shaoshuai Mou

Published 2026-03-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Wenjian Hao, Devesh Upadhyay, Shaoshuai Mou

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to learn how to drive a car, but every time you look at your speedometer or check the fuel gauge, the numbers are slightly wrong. Sometimes they jump up, sometimes they drop down, and sometimes they just wiggle randomly. This is what engineers call "noisy data."

In the real world, almost every sensor (on a robot, a drone, or a self-driving car) has this kind of "static" or "fuzziness." If you try to build a model of how the car moves using these fuzzy numbers, your model will be wrong, and the car might crash.

This paper introduces a new, smarter way to learn how systems move, even when the data is messy. The authors call their method Deep Koopman Learning using Noisy Data (DKND).

Here is a simple breakdown of what they did, using some everyday analogies:

1. The Problem: The "Fuzzy Mirror"

Think of a complex machine (like a drone) as a black box. You push a button (input), and the drone moves (output). To control it, you need to know the rules of how it moves.

The Old Way: Scientists used to try to find a simple, straight-line rule to describe the drone's movement. But drones are non-linear (they twist, turn, and accelerate in complex ways).
The "Lifting" Trick: To make things easier, they use a mathematical trick called the Koopman Operator. Imagine taking a 2D drawing of a ball rolling on a hill and "lifting" it into a 3D hologram. In this 3D world, the ball's movement looks like a straight line, which is much easier to predict.
The Noise Issue: The problem is that the sensors measuring the ball's position are fuzzy. When you "lift" a fuzzy 2D drawing into a 3D hologram, the fuzziness gets distorted. It doesn't just stay a little blurry; it can turn into a giant, confusing mess that ruins the straight-line prediction.

2. The Solution: The "Noise-Canceling" Model

The authors realized that if you just try to ignore the noise, you get bad results. Instead, they built a model that expects the noise and actively fights against it.

Think of it like Noise-Canceling Headphones:

Standard Headphones: Just play the music. If there is background noise, you hear the music and the noise.
Noise-Canceling Headphones: They listen to the background noise, create an "anti-noise" signal, and cancel it out so you hear only the music.

The DKND method does something similar for math:

It acknowledges the mess: It admits, "Okay, our data is noisy."
It creates a "Clean" version: It tries to imagine what the data would look like if there were no noise.
It minimizes the gap: It adjusts its internal settings (the "tunable parameters" of a neural network) to make sure the difference between the "Noisy Reality" and the "Clean Prediction" is as small as possible.

3. How It Works (The "Two-Step Dance")

The algorithm performs a clever two-step dance to learn the rules:

Step 1: The "Best Guess" Fit. It looks at the noisy data and tries to draw the best possible line through it, just like a standard computer program would.
Step 2: The "Reality Check." This is the secret sauce. It calculates how much the noise distorted the math. It then tweaks the internal "knobs" of the model to ensure that even if the noise changes slightly, the model's prediction stays stable.

Instead of just saying, "Minimize the error," it says, "Minimize the error plus the worst-case scenario of how the noise could mess things up." This makes the model incredibly robust.

4. The Results: Driving in the Rain

The authors tested their method on four different "cars":

A simple 2D line (easy driving).
A Cartpole (balancing a pole on a cart—like a tightrope walker).
A Lunar Lander (landing a rocket on the moon).
A Surface Vehicle (a boat moving on water).

They tested these with three types of "noise":

Gaussian: Random static (like TV snow).
Poisson: Random spikes (like lightning strikes).
Uniform: Constant jitter (like a shaky hand).

The Verdict:
When the data was clean, all methods worked okay. But when the data got noisy, the old methods (like standard Deep Learning or DMD) started to fail, with errors skyrocketing. The new DKND method, however, kept its cool. It was like a driver who could still navigate perfectly even when the road was covered in fog and the GPS was glitching.

Why This Matters

This is a big deal for robotics and automation. Real-world robots don't live in perfect, clean laboratories. They live in the rain, the wind, and the dust. This paper gives engineers a new tool to build robots that can learn and control themselves even when their sensors are lying to them a little bit.

In a nutshell: They taught a computer how to learn the rules of the game, even when the scorecard is scribbled over with messy ink.

1. Problem Statement

The paper addresses the challenge of learning the dynamics of nonlinear, time-invariant systems from noisy observational data.

System Model: The system is defined as $x(t+1) = f(x(t), u(t))$ , where $x$ is the state and $u$ is the control input.
Observation Model: The true state $x(t)$ is unobservable. Instead, only noisy measurements $y(t) = x(t) + w(t)$ are available, where $w(t)$ is unknown but bounded measurement noise ( $\|w(t)\| \leq w_{max}$ ).
The Core Challenge: Standard Deep Koopman Operator (DKO) methods minimize the error between predicted and observed states. However, when observations are noisy, the nonlinear transformations (lifting functions) applied by Deep Neural Networks (DNNs) distort the noise characteristics. This leads to biased estimates of the linear operator matrices ( $A, B, C$ ) and degrades the accuracy of the learned dynamics, making them unsuitable for robust control design. Existing methods like Total Least Squares (TLS) or Robust Koopman (min-max) often struggle with the specific noise correlations introduced by DNN-based lifting.

2. Methodology

The authors propose a data-driven framework called Deep Koopman Learning with Noisy Data (DKND). The method modifies the standard DKO formulation to explicitly account for and mitigate the effects of bounded measurement noise.

Key Theoretical Development

Instead of directly minimizing the residual error between the true state (unknown) and the prediction, the authors derive an upper bound on the estimation error.

Error Decomposition: They define two models:
- $\tilde{f}$ : The dynamics learned from noise-free data (theoretical ideal).
- $\bar{f}$ : The dynamics learned from noisy data (practical implementation).
Loss Function Formulation: The total error is bounded by the sum of:
- The standard prediction error on noisy data ( $\|y_{t+1} - \hat{f}(y_t, u_t, \theta)\|^2$ ).
- The discrepancy between the noise-free model and the noisy model ( $\|\tilde{f} - \bar{f}\|^2$ ).
Noise Characterization: The authors prove that the discrepancy term can be upper-bounded by a function of the noise bound $w_{max}$ and the Lipschitz constant of the DNN lifting function $g(\cdot, \theta)$ .
Optimization Objective: The final loss function $\hat{L}_f$ to be minimized is:
$\hat{L}_f = \underbrace{\frac{1}{2T} \sum (\| \bar{G} - [A, B] \begin{bmatrix} G \\ U \end{bmatrix} \|^2_F + \| Y - CG \|^2_F)}_{\text{Standard DKO Error}} + \underbrace{\hat{L}_{f,2}(\theta)}_{\text{Noise Discrepancy Penalty}}$
Where $\hat{L}_{f,2}(\theta)$ is a term derived in Theorem 1 that penalizes the sensitivity of the DNN parameters to the bounded noise.

Algorithm (DKND)

The solution is an iterative algorithm (Algorithm 1):

Initialization: Initialize DNN parameters $\theta_0$ .
Matrix Update: Given current $\theta_k$ , compute the optimal linear matrices $A^*_k, B^*_k, C^*_k$ using the Moore-Penrose pseudoinverse (closed-form solution).
Parameter Update: Compute the gradient of the total loss $\hat{L}_f$ with respect to $\theta_k$ (using the chain rule and matrix derivative identities for the inverse terms) and update $\theta$ via gradient descent.
Convergence: Repeat until the loss falls below a threshold $\epsilon$ .

3. Key Contributions

Noise-Robust Framework: The paper introduces the first Deep Koopman framework specifically designed to handle unknown but bounded measurement noise by characterizing the noise propagation through the DNN lifting functions.
Theoretical Guarantee: It provides a theoretical upper bound (Theorem 1) linking the noise bound and the DNN parameters to the estimation error, allowing the optimization to mitigate noise effects by tuning $\theta$ .
Practical Implementation: The method requires only that noise be bounded (a common assumption in control), avoiding the need for complex noise distribution modeling or direct measurement of noise-free states.
Efficient Optimization: The algorithm decouples the linear matrix estimation (closed-form) from the non-linear DNN parameter tuning, making it computationally feasible.

4. Experimental Results

The authors evaluated DKND on four benchmarks: a 2D linear system, Cartpole, Lunar Lander, and an Unmanned Surface Vehicle (USV). They tested against three baselines:

DK: Standard Deep Koopman (minimizing Eq. 12 directly).
DMDTLS: Dynamic Mode Decomposition with Total Least Squares.
MLP: Multi-Layer Perceptron (black-box dynamics learning).

Noise Types Tested: Gaussian, Poisson, and Uniform distributions (with clipping to ensure boundedness).

Key Findings:

Superior Accuracy: DKND consistently achieved the lowest Root Mean Square Deviation (RMSD) on test data across all noise types and system complexities.
Robustness to Noise Magnitude: As noise intensity increased (e.g., Uniform noise with $w_{max}$ $w_{ma x}$ up to 8.2), the performance gap between DKND and the baselines widened significantly.
- Example: In the Lunar Lander task with Uniform noise, DKND RMSD was 2.33, while MLP was 6.29 and DMDTLS failed catastrophically (288.29).
Generalization: Unlike DMDTLS, which struggled with high-dimensional nonlinear systems (Cartpole, Lunar Lander), DKND maintained stability and accuracy.
Training vs. Testing: While training errors were similar across gradient-based methods (due to early stopping criteria), DKND showed significantly better generalization on the test set, indicating it learned the true underlying dynamics rather than overfitting to the noise.

5. Significance and Conclusion

This paper is significant for the control and machine learning communities because it bridges the gap between theoretical Koopman operator theory and practical, noisy real-world data.

Control Applications: By providing a more accurate and robust linear representation of nonlinear dynamics under noise, DKND enables the application of powerful linear control techniques (like LQR or MPC) to complex nonlinear systems where sensor noise is inevitable.
Limitations: The authors note that the method assumes bounded noise; the formal impact of the bound size on performance is an open question. Additionally, like all DNN-based methods, it is limited to local minima due to non-convex optimization.
Future Work: The authors suggest exploring optimal control strategies directly based on the learned noisy dynamics.

In summary, DKND offers a mathematically grounded, computationally efficient, and empirically superior approach to learning system dynamics in the presence of measurement noise, outperforming existing state-of-the-art methods in both linear and highly nonlinear benchmarks.