Adaptive Behavioral Predictive Control: State-Free Regulation Without Hankel Weights

1. Problem Statement

The paper addresses the challenge of controlling unknown, potentially nonlinear dynamical systems using streaming data in real-time. Traditional data-driven predictive control methods, such as Data-Enabled Predictive Control (DeePC) or behavioral control, typically rely on:

• Batch data processing: Storing large Hankel matrices of past trajectories.
• Iterative optimization: Solving Quadratic Programs (QPs) at every time step to compute control actions.

These requirements create computational bottlenecks for systems with:

• Strict real-time constraints.
• Continuous operation where data accumulates indefinitely.
• Slow nonlinear drifts requiring frequent model updates.
• Limited memory or computational resources.

The goal is to develop a controller that operates directly on streaming input-output data, updates the plant model online, and computes control actions in closed form without iterative optimization or batch storage.

2. Methodology: Adaptive Behavioral Predictive Control (ABPC)

The proposed ABPC framework combines indirect adaptive control with behavioral system theory and kernel methods. It avoids state-space modeling and batch Hankel matrices entirely.

A. Kernel-Based Recursive Identification

Instead of fixed linear models (like standard ARX), ABPC uses a Linear-Parameter-Varying (LPV) ARX model identified via Recursive Least Squares (RLS) with kernelization.

• Feature Dictionary: The regressor vector is constructed using a kernel dictionary $\{ \gamma_j \}$ (e.g., polynomial, Radial Basis Function (RBF), or unitary/linear). This allows the model to capture nonlinearities (e.g., NARX, Hammerstein) while keeping the parameter estimation linear.
• Online Update: At each time step $k$, the RLS algorithm updates the parameter vector $\theta_k$ using the most recent input-output pair $(u_k, y_k)$.
• LPV Coefficients: The identified parameters are mapped to time-varying LPV coefficients ($A_k, B_k, C_k$) based on the current regressor state $s_k$.

B. Frozen Surrogate and Toeplitz Stacking

To enable closed-form control, the method employs a "frozen" approximation over a finite prediction horizon $N$:

1. Freezing: The LPV coefficients identified at step $k$ are held constant over the horizon $N$.
2. Toeplitz Stacking: The one-step predictor is stacked over the horizon using Toeplitz matrices to form a linear relationship between future inputs $U$ and future outputs $Y$:
   $$Y = S_k + G_k U$$
   where $S_k$ is the free response (based on initial conditions) and $G_k$ is the dynamic response matrix (Toeplitz structure).
3. Convexity: This transformation converts the potentially nonlinear prediction problem into a strictly convex quadratic optimization problem with respect to the input sequence $U$.

C. Closed-Form Control Synthesis

The control objective minimizes a quadratic cost function $J(U)$ comprising tracking error and input increments:
$$J(U) = \frac{1}{2}(S_k + G_k U - R)^\top Q_y (S_k + G_k U - R) + \frac{1}{2} \Delta U^\top R_u \Delta U$$

• Solution: Since the Hessian matrix $H$ is symmetric positive definite (guaranteed by input penalties), the optimal control sequence is found via Cholesky factorization ($H = LL^\top$) followed by forward and backward substitution.
• Efficiency: This eliminates the need for iterative QP solvers. The computation is $O((mN)^2)$ per step, dominated by the factorization, making it suitable for real-time implementation.

3. Key Contributions

1. Streaming Data Architecture: Introduction of a kernel-based indirect adaptive controller that operates on streaming data, removing the need for batch Hankel matrices and trajectory storage.
2. Closed-Form Optimization: Integration of kernel-RLS identification with Toeplitz stacking to derive a closed-form Cholesky-based solution, bypassing iterative optimization.
3. Unifying Framework: The method generalizes Predictive Cost Adaptive Control (PCAC) and Generalized Predictive Control (GPC). It nests PCAC as a special case (unitary dictionary) and extends expressiveness to nonlinear systems via nonlinear dictionaries.
4. Systematic Numerical Validation: A comprehensive study covering linear, unstable, MIMO, and various nonlinear systems (Hammerstein, NARX with cross-terms, cubic, and quaternion dynamics), analyzing the trade-offs between kernel choice, conditioning, and performance.

4. Results and Numerical Studies

The paper validates ABPC through seven numerical examples:

• Linear Systems (Stable & Unstable):
  • ABPC successfully stabilizes unstable, non-minimum phase systems.
  • Kernel Performance: In linear regimes, RBF and Unitary kernels performed similarly well. Polynomial kernels showed slightly higher transient errors but remained stable.
• Nonlinear Systems (NARX & Hammerstein):
  • Polynomial Kernels: Demonstrated superior performance for systems with polynomial nonlinearities (e.g., quadratic NARX, cubic cross-terms, Hammerstein). They achieved the lowest tracking errors (RMSE/IAE) because the feature space exactly matched the system structure.
  • RBF Kernels: Showed strong local approximation capabilities, often outperforming linear/unitary kernels in specific nonlinear regimes, though sometimes requiring higher lag orders for stability.
• MIMO and Complex Dynamics:
  • Successfully controlled an underactuated MIMO system and a rigid-body attitude stabilization problem on $SO(3)$ (quaternion dynamics).
  • In the quaternion case, linear and polynomial kernels provided smoother velocity responses and lower integrated error, despite slightly slower transient convergence compared to RBF/Unitary.
• Disturbance Rejection:
  • The controller effectively rejected sinusoidal disturbances.
  • Critical Finding: For sinusoidal disturbances, linear and polynomial dictionaries failed to capture the mode (leading to "parameter chasing" and instability) unless the lag order was sufficiently high. The Unitary dictionary (acting as an internal model) and RBF (with sufficient depth) maintained stability.
• Robustness:
  • Tests with additive measurement noise confirmed that the ranking of kernel performance remained consistent, and the controller remained bounded and stable.

5. Significance and Limitations

Significance:

• Computational Efficiency: By replacing iterative QPs with a single Cholesky factorization, ABPC enables predictive control on hardware with limited computational power.
• State-Free: It adheres to the behavioral paradigm, requiring no state-space realization or observability assumptions.
• Adaptability: The kernel-RLS approach allows the controller to adapt to slow nonlinear drifts and changing dynamics without retraining on batch data.
• Practical Guidance: The study provides empirical rules for kernel selection (e.g., use polynomials for polynomial plants, RBF for general nonlinearities, and unitary for sinusoidal/internal model needs).

Limitations:

• No Formal Stability Proofs: The analysis is numerical. While the "frozen" surrogate is convex, formal stability guarantees for the time-varying closed-loop system are not provided.
• Constraint Handling: The current formulation does not explicitly handle hard input/output constraints (though soft penalties or clipping are suggested as future work).
• Kernel Selection: Performance is highly dependent on the choice of the kernel dictionary and the lag order; poor choices can lead to ill-conditioning or instability.

In conclusion, ABPC represents a significant step toward real-time, data-driven predictive control that bridges the gap between adaptive identification and optimal control, offering a computationally tractable alternative to batch-based behavioral methods.