⚡ electrical engineering

Beyond Shrinkage: Foundations of Data-Driven Control for Piecewise Affine Systems

This paper establishes the theoretical foundations for data-enabled predictive control of piecewise affine systems by extending Willems' Fundamental Lemma, analyzing the coherence of linear predictors with shrinkage regularizers, and investigating the impact of misclassification errors to ensure effective and explainable control actions.

Original authors: Gianluca Giacomelli, Victor G. Lopez, Simone Formentin, Matthias A. Müller, Valentina Breschi

Published 2026-05-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Gianluca Giacomelli, Victor G. Lopez, Simone Formentin, Matthias A. Müller, Valentina Breschi

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

The Big Picture: Driving Without a Map

Imagine you are trying to drive a car from point A to point B. Usually, you need a map (a mathematical model) to know how the car will react when you turn the wheel or press the gas.

Data-Driven Control (DeePC) is like learning to drive by just looking at a video of someone else driving. You don't need to know the engine's physics; you just look at the past footage (data) and say, "If I do what they did in this situation, the car will go there."

This works great for simple, predictable cars (Linear systems). But what if you are driving a shapeshifting car?

When you drive slowly, it handles like a sedan.
When you speed up, it suddenly handles like a race car.
When you turn left, it behaves like a boat; when you turn right, it behaves like a tank.

This is a Piecewise Affine (PWA) system. It's a machine that acts like one simple rule in one zone, and a completely different rule in another zone. The paper asks: Can we use the "look at the video" method to control these shapeshifting machines without building a complex map first?

The Problem: The "Shrinkage" Mistake

The researchers tried to apply the standard "look at the video" method to these shapeshifting cars. To make the math work, they used a technique called Regularization (or "Shrinkage").

The Analogy: Imagine you are trying to predict the weather. You have a giant book of past weather data.

The Goal: You want to predict tomorrow's weather.
The Mistake: You try to be "efficient" by shrinking your search. You tell the computer, "Don't look at all the past data. Just pick a few days that look similar to today and ignore the rest."

In the world of math, this "picking a few" is done by forcing some numbers in the calculation to become zero (shrinking them). The researchers tested two popular ways to do this shrinking:

Elastic-Net: A method that tries to pick a few good data points.
Group Lasso (CAP): A method that tries to pick entire groups of data points (e.g., "Pick all the rainy days" or "Pick all the sunny days").

The Discovery: "Coherence" is Missing

The paper's main finding is that simple shrinking doesn't work well for shapeshifting machines.

Here is the analogy:
Imagine your shapeshifting car is currently in "Race Car Mode" (high speed). To control it correctly, you need to look at the video footage of other times the car was in Race Car Mode.

However, the "shrinking" methods are like a confused librarian. They look at the video library and say, "I need to find data that fits the math equation." Because they are trying to be efficient, they might accidentally grab a clip from "Boat Mode" just because the numbers look mathematically convenient, even though the car isn't actually in Boat Mode right now.

The paper calls this a lack of Coherence.

Coherent: The controller uses data that matches the actual current behavior of the machine.
Incoherent: The controller uses a mix of data from different behaviors (Race Car + Boat) just to make the math work.

The researchers proved mathematically that even with the best "shrinking" tricks, the controller often ends up mixing up the modes. It might try to steer the car using rules for a boat while the car is actually driving on a highway.

The "Misclassification" Problem

The researchers also looked at what happens if we don't know exactly which "mode" the data belongs to.

The Analogy: Imagine you are sorting a pile of photos into "Sunny Days" and "Rainy Days" folders.

Perfect World: You sort them perfectly.
Real World: You use a robot (an algorithm) to sort them, and it makes mistakes. It puts a few rainy photos in the sunny folder.

The paper found that if you sort your data incorrectly (misclassification), the controller gets confused.

The Group Lasso method (picking whole groups) was very sensitive to these sorting errors. If the robot put a few wrong photos in the folder, the controller's performance dropped significantly.
The Elastic-Net method was a bit more forgiving, but still not perfect.

The Conclusion: "Beyond Shrinkage"

The paper concludes that you cannot simply take a standard data-driven controller and add a "shrinkage" filter to make it work for complex, shapeshifting systems.

The Result: The controller might still get the car from A to B (it tracks the path), but it does so in a way that doesn't make sense for the machine's actual physics. It's like driving a car by randomly pressing pedals just because the math says it will work, rather than understanding why the car moves.
The Future: To truly control these machines effectively, we need to stop trying to "shrink" the data and instead build a controller that explicitly understands the "switching" logic (the different modes). This might require more complex math (mixed-integer problems), but it ensures the controller's decisions are coherent with how the machine actually behaves.

In short: You can't just "simplify" the data to control a shapeshifting machine. If you try to force the data to fit a simple pattern, you end up with a controller that is mathematically clever but practically confused. To drive the shapeshifting car safely, you need to respect its different modes, not just shrink them away.

Technical Summary: Beyond Shrinkage: Foundations of Data-Driven Control for Piecewise Affine Systems

Problem Statement
Data-enabled predictive control (DeePC) has emerged as a powerful framework for controlling systems directly from raw input/output data, bypassing explicit system identification. While effective for Linear-Time Invariant (LTI) systems, extending DeePC to nonlinear systems remains a significant challenge. Piecewise Affine (PWA) systems are a prominent class of nonlinear models known for their universal approximation capabilities and extensive use in control literature. However, existing data-driven strategies for nonlinear systems often rely on linearization, local affine predictors, or data selection techniques that do not explicitly account for the structural switching logic of PWA systems. Currently, no strategy specifically addresses data-driven predictive control for PWA systems that ensures the controller's decisions are coherent with the system's underlying piecewise behavior. Furthermore, the impact of regularization strategies (shrinkage) on achieving this coherence, and the sensitivity of such methods to data misclassification, remains unexplored.

Methodology
The authors develop a theoretical foundation for data-driven control of PWA systems by extending Willems' Fundamental Lemma. The methodology proceeds through the following steps:

Behavioral Characterization: The paper transitions from a state-space PWA representation to an equivalent Piecewise Affine with eXogenous inputs (PWARX) model. It establishes a kernel representation where the global behavior is a weighted sum of local affine kernels, dictated by the active mode.
Data-Driven Representation: The authors propose an extension of Willems' Fundamental Lemma for PWA systems. They construct a "Mosaic" data matrix by partitioning available data into subsets corresponding to specific modes (assuming the active mode sequence is known for the dataset). This leads to a data-driven predictor that utilizes a binary selection matrix to enforce sparsity patterns consistent with the active mode.
Analysis of Shrinkage Strategies: Instead of solving the computationally expensive mixed-integer problem required to explicitly optimize the active mode sequence, the authors analyze two "shrinkage-based" DeePC schemes that rely on regularization to induce sparsity:
- Elastic-DeePC: Utilizes an Elastic Net regularizer (combining $L_1$ and $L_2$ norms) to promote sparsity in the data selectors.
- CAP-DeePC: Utilizes the Composite Absolute Penalty (specifically Group Lasso) to promote the sparsification of groups of local behaviors.
Coherence Analysis: The paper defines "coherence" as the ability of the DeePC solution to utilize data exclusively from the active mode required by the initial conditions and reference trajectory. The authors derive explicit solutions and necessary conditions for these shrinkage schemes to achieve such coherence.
Misclassification Impact: Recognizing that the active mode sequence is typically unknown in practice, the authors analyze the impact of estimating modes via unsupervised clustering (e.g., K-means). They derive bounds on the attained cost when the data matrices are constructed using misclassified data, comparing the performance of Elastic-DeePC and CAP-DeePC under these conditions.

Key Contributions

Behavioral Extension: The paper provides a behavioral characterization of PWA systems and extends Willems' Fundamental Lemma to this class, defining a data-driven predictor based on Mosaic data matrices and binary selection.
Coherence Limitations: Theoretical analysis and explicit solution derivation reveal that using shrinkage regularization (Elastic Net or Group Lasso) alone is insufficient to guarantee that the control actions are coherent with the actual PWA behavior. The solutions often depend on data from multiple modes, even when only one should be active, leading to outcomes that are not structurally consistent with the system's dynamics.
Regularization Analysis: The study introduces the first analysis of Composite Absolute Penalty (CAP) regularization for PWA systems, contrasting it with Elastic Net. It demonstrates that while CAP promotes group sparsity, it cannot enforce the strict structural coherence required for PWA systems without solving a mixed-integer problem.
Misclassification Bounds: The authors provide theoretical bounds on the performance degradation (cost) caused by misclassifying data points into incorrect mode clusters. The analysis shows that CAP-DeePC is more sensitive to these errors than Elastic-DeePC due to its dependence on cluster sizes in the regularization parameter.

Results
Numerical experiments on a simple PWA system validate the theoretical findings:

Tracking Performance: Both shrinkage-based schemes can track references and force the system to switch modes. However, the Behavioral Performance Indicator (BPI) shows that the sparsity patterns of the solutions rarely match the true system behavior (i.e., the BPI is not equal to 1), confirming the lack of coherence.
Mode Switching: Performance tends to deteriorate when the system is forced to switch from the second mode back to the first, highlighting the difficulty of the shrinkage approach in handling transitions.
Impact of Errors: When data is misclassified (simulated via K-means clustering), the performance of CAP-DeePC deteriorates significantly compared to the exact clustering case, whereas Elastic-DeePC shows slight improvement or stability. This aligns with the theoretical bounds, indicating CAP-DeePC's higher sensitivity to data partitioning errors.

Significance and Claims
The paper claims to lay the foundational groundwork for data-driven control of PWA systems. Its primary significance lies in demonstrating that simply applying standard shrinkage regularization to a DeePC framework is inadequate for PWA systems. The authors argue that while such methods may achieve input/output tracking, they fail to produce control actions that are "explainable" or coherent with the underlying piecewise structure of the system.

The work concludes that to ensure coherence between the controller's solution and the local system behavior, future approaches must move beyond simple regularization. The authors suggest that this necessitates a shift toward mixed-integer DeePC schemes that explicitly optimize for the active mode sequence, despite the associated computational complexity. Additionally, the paper notes that its current results are limited to noise-free data and known mode counts, identifying these as necessary areas for future research.

The Big Picture: Driving Without a Map

The Problem: The "Shrinkage" Mistake

The Discovery: "Coherence" is Missing

The "Misclassification" Problem

The Conclusion: "Beyond Shrinkage"

More like this