⚡ electrical engineering

Control-Oriented System Identification: Classical, Learning, and Physics-Informed Approaches

This paper surveys classical, machine learning, and data-driven system identification methods, proposing a unified framework that integrates control-relevant and physics-informed properties through various optimization constraints to enhance model explainability, sample efficiency, and the provision of provable guarantees for control synthesis.

Original authors: S. Sivaranjani, Yuanyuan Shi, Nikolay Atanasov, Thai Duong, Jie Feng, Tim Martin, Yuezhu Xu, Vijay Gupta, Frank Allgöwer

Published 2026-07-16

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: S. Sivaranjani, Yuanyuan Shi, Nikolay Atanasov, Thai Duong, Jie Feng, Tim Martin, Yuezhu Xu, Vijay Gupta, Frank Allgöwer

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 teach a robot how to walk, or a self-driving car how to navigate a storm. You could just feed the machine a mountain of video footage and let it guess the rules of physics on its own. This is like letting a child learn to ride a bike by falling over a thousand times until they finally figure it out. It works, but it's messy, slow, and sometimes the child learns the wrong lesson—like thinking it's okay to ride into a wall because they haven't hit one yet.

In the world of engineering, this is the difference between "learning from data" and "learning with a map." The paper you're about to read lives in the corner of science called Control-Oriented System Identification. Think of "System Identification" as the art of building a mathematical map of how something moves or changes. "Control" is the art of steering that thing to do what you want. For decades, engineers have had a strict rulebook: if you want to steer a plane safely, your map must obey the laws of physics, like energy conservation or the fact that you can't create something from nothing. But recently, powerful new "machine learning" tools have arrived that are great at guessing patterns but terrible at following rules. They might learn to fly a plane perfectly in a simulation, only to crash in the real world because they forgot that gravity exists. This paper asks a big question: Can we teach machines to learn from data while forcing them to respect the unbreakable laws of physics and safety?

The Great Map-Making Heist

This paper is a massive tour guide through a bustling city of ideas, showing us how to build better maps for machines. The authors, a team of researchers from universities in the US and Germany, are essentially saying: "Stop letting your AI guess the laws of physics. Make it obey them."

They argue that while modern machine learning is amazing at finding patterns in noisy, messy data, it often produces "black box" models. These are like magic 8-balls: you shake them, they give an answer, but you have no idea why. If that magic 8-ball is controlling a nuclear reactor or a robot arm, and it starts acting weird, you won't know why until it's too late. The paper suggests that we need to mix the "magic" of machine learning with the "strict rules" of classical control theory.

The Three Ways to Teach a Robot to Behave

The authors propose three main ways to force a learning algorithm to respect the rules of the universe, using a simple analogy: imagine you are training a dog to fetch a ball, but you want to make sure it never runs into traffic.

Direct Parameterization (Building the Dog's Legs): This is like building the dog's legs so that it physically cannot run into traffic. You design the model's structure from the start so that it only knows how to move in safe, physics-compliant ways. For example, if you are modeling a pendulum, you build the math so that it must conserve energy, just like a real pendulum does. The paper shows that this works great and is very efficient, but it's hard to design these "special legs" for every possible situation.
Hard Constraints (The Invisible Fence): This is like putting an invisible electric fence around the yard. The dog can run anywhere it wants, but if it tries to cross the line, it gets a shock (or in math terms, the computer says "No, that's not allowed!"). The paper explains that this is very precise, but it can be computationally expensive, like trying to calculate the exact path of a million dogs at once. Sometimes, the fence gets in the way of the dog learning new tricks.
Soft Constraints (The Gentle Nudge): This is like giving the dog a treat every time it stays in the yard, and a gentle "no" when it wanders off. You don't forbid the dog from running into traffic, but you make it very expensive (in terms of "points" or "loss") to do so. This is the easiest way to add rules to modern AI, but the paper warns that it's not a guarantee. The dog might still run into traffic if the treat isn't big enough.

The "Oops" Moment: Why Just Guessing Fails

One of the most fun parts of the paper is a little experiment they run to prove their point. They take a simple electrical circuit (an RLC circuit) that is known to be "passive" (meaning it can't create energy out of thin air). They feed data from this circuit into a standard machine learning tool to build a model.

The result? The new model looks perfect. It predicts the circuit's behavior with 99.6% accuracy. But when the authors check if the model respects the "no free energy" rule, they find out it's broken. The model thinks the circuit can generate energy on its own! It's like a map that shows a shortcut through a mountain that doesn't exist. The paper uses this to prove that just being accurate isn't enough. If your map is slightly wrong about the laws of physics, your robot might crash.

The New Tools: Physics-Informed AI

The paper then dives into the cool new tools researchers are using to fix this. They talk about Neural ODEs (Neural Ordinary Differential Equations), which are like AI that speaks the language of calculus. Instead of just guessing the next step, they learn the rate of change, which is how real physics works.

They also highlight Hamiltonian Neural Networks, which are designed specifically to learn systems that conserve energy, like planets orbiting a sun or a pendulum swinging. In one example, they trained a network to learn the dynamics of a quadcopter (a small flying robot). The "physics-aware" version learned the rules of flight much faster and with less data than the "black box" version. It even kept the robot's energy balanced, preventing it from flying into a wall because it thought it had infinite fuel.

The "No-Model" Approach: Learning from the Trail

The paper also explores a fascinating idea called Behavioral Systems Theory. Imagine you don't know how a car works, but you have a video of it driving. Instead of trying to guess the engine size or the tire pressure, you just look at the trail of tire tracks. The paper explains that you can verify if a system is safe or stable just by looking at these trails, without ever building a full model of the car. It's like checking if a river is safe to swim in by watching the current, rather than measuring the depth of the water at every single point.

The Road Ahead: What's Still Missing?

The authors are honest about what they haven't solved yet. They point out that while we are getting better at teaching AI the rules of physics, it's still really hard to do this for complex, changing systems (like a power grid that switches modes or a traffic network that changes with the time of day).

They also warn about a trade-off. If you make the rules too strict, the AI might become too rigid to learn complex, real-world behaviors. It's like teaching a dog to fetch, but if you tell it "never move more than one inch," it can't fetch the ball at all. The paper suggests that the future lies in finding the perfect balance: a model that is flexible enough to learn from messy data but rigid enough to never break the laws of physics.

The Takeaway

In short, this paper is a call to action for the next generation of engineers and scientists. It says: "Don't just let your AI learn from data. Give it a compass." By mixing the power of machine learning with the timeless rules of physics, we can build robots, cars, and power grids that are not only smart but also safe, explainable, and trustworthy. The paper doesn't claim to have solved everything, but it provides a clear map of the territory, showing us exactly where the cliffs are and where the safe paths lie.

Technical Summary: Control-Oriented System Identification

1. Problem Statement

The paper addresses the challenge of system identification for dynamical systems where the primary goal is not merely to minimize prediction error on training data, but to learn models that preserve specific control-relevant and physics-informed properties.

While modern machine learning (ML) approaches excel at identifying models from noisy, high-dimensional data, they often fail to guarantee properties essential for downstream control synthesis, such as stability, dissipativity, monotonicity, and symmetry preservation. Conversely, classical control theory relies heavily on these properties to provide provable guarantees for closed-loop behavior (e.g., stability via Lyapunov functions, scalability via dissipativity in networked systems). The central problem is that standard identification algorithms, even when they achieve high fidelity in approximating input-output trajectories, do not inherently guarantee that the learned model inherits these structural properties. As demonstrated in the paper, a linear model can approximate a passive system with 99.6% accuracy yet fail to be passive itself.

The paper posits that merging system identification with control-relevant properties provides necessary inductive bias, enhances explainability, enables provable control guarantees, and improves sample complexity.

2. Methodology and Framework

The authors formulate system identification as a constrained optimization problem. They propose a unified framework to enforce control-relevant properties through three distinct mechanisms:

Direct Parameterization: Constraining the model structure by construction to satisfy a property.
- Examples: Lagrangian/Hamiltonian neural networks (enforcing energy conservation), Input Convex Neural Networks (enforcing monotonicity), and specific transfer function parameterizations (enforcing passivity).
Hard Constraints: Imposing explicit constraints on the optimization problem (e.g., Linear Matrix Inequalities - LMIs, Semidefinite Programs - SDPs).
- Examples: Enforcing Lyapunov stability via $A^T P + PA \prec 0$ , or dissipativity via QSR-dissipativity conditions. The paper notes that direct imposition is often computationally expensive, leading to "two-stage" approaches where an unconstrained model is identified first, followed by a perturbation/projection to satisfy constraints.
Soft Constraints (Regularization): Encouraging properties through penalty terms in the loss function.
- Examples: Physics-Informed Neural Networks (PINNs) that minimize residuals of physical laws (e.g., energy conservation) alongside data-fitting errors, or regularization terms that penalize eigenvalues with positive real parts.

The survey categorizes existing literature into three main streams:

Classical System Identification: Techniques for linear and nonlinear systems (e.g., subspace methods, SINDy, Koopman operators) adapted to preserve properties via the three mechanisms above.
Deep Learning-Based Identification: Architectures like Neural ODEs, Recurrent Equilibrium Networks (RENs), and Transformers, modified to embed physics priors or constraints.
Direct Data-Driven/Behavioral Approaches: Methods that bypass explicit model identification (state-space or transfer function) and verify properties directly from measured trajectories using Willems' Fundamental Lemma and Set-Membership approaches.

3. Key Contributions and Surveyed Results

A. Classification of Approaches

The paper provides a comprehensive taxonomy of methods for imposing control-relevant properties, comparing their trade-offs regarding guarantees, scalability, and model expressiveness.

Direct Parameterization offers strong guarantees by construction but may limit model expressiveness.
Hard Constraints provide explicit certificates (e.g., via LMIs) but can lead to computationally intractable problems or model bias if the "best fit" model violates constraints.
Soft Constraints are computationally scalable and easy to integrate but generally offer only probabilistic or empirical guarantees, requiring post-training verification.

B. Classical and Nonlinear Identification

Linear Systems: The paper reviews methods to enforce stability, passivity, and dissipativity in state-space and frequency-domain models. It highlights the "perturbation approach" where a baseline model is minimally adjusted to satisfy constraints (e.g., modifying the $C$ matrix in an RLC circuit identification to restore passivity).
Nonlinear Systems: The survey covers:
- Koopman Operators: Methods to enforce stability and dissipativity on the lifted linear model.
- SINDy: Sparse identification techniques augmented with "trapping" constraints to preserve energy or stability.
- Port-Hamiltonian (PH) Models: Unified frameworks for energy-based modeling that naturally preserve passivity and interconnection structures.
- Gaussian Processes: Kernel methods modified to ensure BIBO stability or to learn Lagrangian/PH structures.

C. Deep Learning Architectures

The paper details how modern architectures are adapted:

Hamiltonian/Lagrangian Neural Networks: Parameterize the energy function rather than the dynamics, guaranteeing energy conservation (or controlled dissipation).
Monotone Neural Networks: Architectures (e.g., gradients of Input Convex Neural Networks) that guarantee monotonicity, crucial for power systems and biological networks.
Recurrent Equilibrium Networks (RENs): Models designed to be contractive and dissipative by construction, offering stability guarantees without iterative projection.
Physics-Informed Neural Networks (PINNs): Use soft constraints to embed physical laws (e.g., heat transfer equations in building dynamics) into the loss function, often outperforming black-box models in long-horizon predictions.

D. Direct Verification (Behavioral and Set-Membership)

A significant portion of the paper is dedicated to data-driven verification without explicit model identification:

Behavioral Framework: Using Willems' Fundamental Lemma to verify dissipativity directly from a single input-output trajectory via Linear Matrix Inequalities (LMIs).
Set-Membership Approaches: Defining a set of all systems consistent with noisy data (an ellipsoidal outer approximation). Robust control techniques (S-procedure) are then used to verify if all systems in this set satisfy a property (e.g., $L_2$ -gain bounds). This provides rigorous guarantees even with noisy data.

4. Experimental Illustrations

The paper supports its survey with several expository examples (with code available on a public repository):

Pendulum Dynamics: Comparing a black-box Neural ODE against a Hamiltonian-based Neural ODE. The physics-informed model converges faster, preserves energy conservation, and satisfies $SO(3)$ manifold constraints, whereas the black-box model drifts.
RLC Circuit: Demonstrating that a standard system identification tool yields a non-passive model despite high fit accuracy, and showing how a perturbation method restores passivity.
Duffing Oscillator: Comparing Koopman models with and without soft stability constraints. The constrained model remains stable, while the unconstrained one diverges.
Power System: Illustrating Monotone Neural Networks for voltage control, showing that while they achieve comparable accuracy to standard MLPs, they require careful training and offer structural guarantees.
Building Thermal Dynamics: Showing that PINNs (incorporating resistor-capacitor physics) outperform standard neural networks in long-term temperature forecasting.

5. Significance and Future Directions

The paper claims that control-oriented identification should be viewed not just as a function approximation problem, but as a model selection problem where preserving structural properties is paramount for safety, interpretability, and control synthesis.

Significance:

It bridges the gap between classical control theory (which relies on structural properties) and modern machine learning (which relies on data-driven flexibility).
It provides a roadmap for researchers to select appropriate identification strategies based on whether they need strict guarantees (hard constraints), scalability (soft constraints), or specific structural priors (direct parameterization).
It highlights that "vanilla" machine learning is insufficient for control applications without these inductive biases.

Future Directions Identified:

Networked Systems: Identifying models that preserve both the graph structure and control properties (e.g., monotonicity) in large-scale networks.
Switched and Time-Varying Systems: Extending identification to systems with unknown switching signals or time-varying dynamics while preserving properties like dissipativity.
Experiment Design: Developing input design strategies that simultaneously excite system modes and ensure the resulting data supports the identification of control-relevant properties.
Bridging Representations: Creating a unified framework that merges the rigorous guarantees of behavioral/set-membership representations with the flexibility of deep learning approximations.
Trade-offs: Further investigation into the bias-variance trade-off when imposing structural constraints, specifically regarding universal approximation theorems for structured model classes.

The paper concludes that while significant progress has been made, the field requires more work on scalable algorithms for complex, networked, and time-varying systems, as well as standardized benchmarks to compare data-driven and control-oriented approaches.