Abstract
This paper presents a novel data-driven iterative learning control (ILC) algorithm for stabilized multivariable nonlinear dynamical systems. The proposed algorithm incorporates two data-driven learning mechanisms: an adaptive feedforward algorithm that models perturbed dynamics as an unknown linear time-varying system and minimizes RMS errors with respect to an LTI reference model, followed by a second learning mechanism for fast convergence in trajectory tracking. For multivariate systems, the non-commutative nature of the cascade of systems necessitates the use of the right inverse for adaptive model matching to promote error convergence. To address challenges in adaptive filtering, a transposition-based technique is introduced to obtain the right inverse for square and over-actuated systems. For -input- -output systems, the approach necessitates conducting experiments. An efficient algorithm is proposed to reduce this requirement by reorganizing impulse response matrix components. The effectiveness of the proposed methods is demonstrated through both simulations and experiments.
Keywords: Iterative learning control, Dynamic coupling, Multivariate inversion, Adaptive model matching
1. Introduction
Iterative Learning Control (ILC) is a feedforward strategy that improves tracking accuracy by utilizing task repetition. Iterative updates of control signals effectively reduce error repetition across trials. ILC’s superior performance has led to its use in manufacturing and scientific instruments, including robot manipulators (Lee et al., 2021), fast tool servos (Simonelli, 2017), wafer stages (Li et al., 2021), atomic force microscopes (Leang & Devasia, 2006), and galvanometer mirror steering (Shih & Chen, 2022). It has also found applications in civil and biomedical engineering, such as building temperature control (Minakais, Mishra, & Wen, 2019) and stroke rehabilitation (Freeman, 2017).
For linear-time-invariant (LTI) systems, provided a dynamic model is available via first principle modeling or system identification, there are different ILC algorithms for various requirements. P- and PD-type ILC (Arimoto, Kawamura, & Miyazaki, 1984) is simple for implementation. Frequency-domain ILC (Longman, 2000) improves the convergence of the tracking error. Norm-optimal ILC (Gunnarsson & Norrlöf, 2001; Mishra, Topcu, & Tomizuka, 2010), based on quadratic programming can directly penalize and/or impose constraints on system signals in time domain. The convergence and attainable performance of ILC can be thoroughly analyzed, thanks to the understanding of the model and its associated uncertainties.
For nonlinear dynamical systems, LTI techniques can be applied with a known nonlinear model. P-type ILC uses Jacobian information (Arimoto et al., 1984; Xu & Tan, 2003), while frequency-domain ILC employs feedback linearization to eliminate nonlinear dynamics (Wang, Zhao, Chen, & Tomizuka, 2015). Alternatively, norm-optimal ILC treats the system as linear-time varying (LTV) along the state trajectory (Lee, Lee, & Kim, 2000; Lin, Owens, & Hätönen, 2006; Volckaert, Diehl, & Swevers, 2013). The key challenge is obtaining an accurate nonlinear model.
Unlike model-based ILC, data-driven ILC directly derives control corrections from experimental I/O data, reducing susceptibility to modeling errors. Time-domain approaches use quadratic cost optimization with dedicated experiments (Bolder, Kleinendorst, & Oomen, 2018; Freeman, Lewin, & Rogers, 2005), while frequency-domain methods construct learning filters via Fourier transform division (Kim & Zou, 2012; Zhang & Zou, 2022). These techniques leverage LTI system structures, but their applicability to nonlinear systems remains challenging as these structures break down.
The main challenges associated with data-driven ILC for nonlinear systems include the determination of a learning control structure and the ILC convergence. The former ensures appropriate parameterization and minimal computational complexity, while the latter involves a convergence criterion that allows for straightforward analysis, ideally achieving geometric convergence.
Neural network-based learning filters (Afshar, Wang, & Chai, 2009; Zhang, Wang, & Masayoshi, 2020) approximate nonlinear functions but risk bias, poor extrapolation, and slow convergence due to non-convex hyperparameter optimization. Huo, Freeman, and Liu (2020) approximates a nonlinear system with an average LTI model at a fixed operating point, enabling data-driven gradient ILC. The learning gain is constrained by the unknown Lipschitz constant, and performance is further limited by the approximation. Iterative dynamic linearization models iteration-domain I/O variations as linear dynamics, using LMS-type algorithms for time-varying system estimation and error filtering (Hou, Chi, & Gao, 2016; Wu et al., 2022). However, design parameters are heuristically tuned due to unknown system bounds. A quadratic cost for LTV systems was formulated in He et al. (2021), yielding a descent direction of ILC update from past data, but the solution remains suboptimal. Norm optimal control is reformulated using behavioral systems theory in Jiang and Chu (2022) and Li (2024), yet extending the computation horizon for faster convergence is costly. Gaussian process regression in Meindl, Bachhuber, and Seel (2024) yielded a data-driven model and optimal control law for a quadratic cost, but the empirically chosen kernel, lack of convergence guarantees, and high computational cost remain challenges.
Lee (2019) introduced a data-driven dual learning mechanism for nonlinear SISO systems, combining time-domain adaptive recursive least squares (RLS) algorithm for system inversion identification with iteration-domain error correction. Subsequent work (Lee, Rai, & Tsao, 2022) demonstrated fast convergence, efficient memory use, and easy implementation. However, extending this approach to multi-input-multi-output (MIMO) systems is challenging due to dynamic input–output coupling and non-commutative properties. This paper addresses these challenges.
This work explores dynamic inversion for nonlinear or time-varying MIMO systems using multi-channel adaptive filters, emphasizing the right inverse to improve tracking error convergence. While the original construction requires extensive experiments and may be affected by non-smooth effects like friction, we also propose an approach with fewer experiments leveraging the efficient linear MIMO adaptive control (Plett, 2001).
The main contributions of this work are:
The development of data-driven MIMO ILC algorithms through error filtering of system’s right inverse. The benefits of fast convergence, efficient memory usage, and low computational complexity are inherited from the SISO approach (Lee et al., 2022).
For square systems, the choice of left vs. right inverses in MIMO ILC is examined, with the right inverse preferred from error recursion. It is derived by rerouting I/O signals, while transpose filtering (Plett, 2001) improves efficiency and reduces experiments for practical use. The algorithm convergence can be examined by adaptive filter signals.
The ILC algorithms are compared and validated via simulations and experiments on a gantry-type motion system with position-dependent cross-coupled dynamics. The feasibility of applying the method to a non-square (over-actuated) system is also examined.
The rest of this article is structured as follows. Section 2 examines control and error recursion in linear multivariate ILC, establishing that the left inverse ensures control convergence while the right inverse promotes error convergence. Section 3 reviews data-driven ILC for SISO systems and its direct MIMO extension using the left inverse.
Section 4 proposes an MIMO ILC algorithm with the right inverse and a modification for efficient implementation. Section 5 validates the approach through simulations and experiments on a gantry motion system. Finally, Section 6 presents the conclusions.
2. Preliminaries of multivariate ILC
2.1. System description
Denote the general I/O relationship of a SISO system , which maps input vector of length onto output vector . If is a linear process, then the output is related to input by the linear matrix–vector multiplication:
| (1) |
Entry denotes the impulse response coefficient at discrete time index , and the superscript means the mapping is from input channel 1 to output channel 1. The linear system can be described with the following filter form:
| (2) |
When the system is time invariant, namely , the corresponding with complex variable is the discrete-time transfer function of the LTI system.
Similarly, for a MIMO system of input and output channels, denote the I/O relationship for the concatenated input and output vectors and . If the MIMO system is linear, the output is related to input by:
| (3) |
with the linear mapping . Entry is the linear mapping from input channel to output channel. The MIMO system can be described by the multi-channel filter
| (4) |
where the matrix-valued impulse response coefficient is
| (5) |
When the system is time invariant, the corresponding is the discrete-time transfer function matrix:
| (6) |
and is the transfer function of subsystem .
2.2. Linear ILC convergence
In ILC framework, the goal is for the MIMO system to track a desired reference trajectory as iteration accumulates. At iteration , the system produces output under input . A generic linear ILC update law driven by the tracking error is:
| (7) |
wherein the is the learning matrix, and is the smoothing matrix.
If the system is a linear mapping , Eq. (7) can be expanded as
| (8) |
From contraction mapping theorem, the condition for monotonic convergence (Norrlöf & Gunnarsson, 2002) can be established as:
| (9) |
where denotes the matrix two-norm, and is the convergence rate. Furthermore, if the system is LTI and the horizon , then Szegö’s limit theorem (Simon, 2010) establishes a frequency-domain counterpart:
| (10) |
where is the largest singular value of the transfer function matrix .
When the ILC of a linear system converges, the steady-state input is
| (11) |
The corresponding steady-state tracking error is
| (12) |
For an LTI system, the transformed equations in the frequency domain are
| (13) |
and
| (14) |
2.3. Inversion-based ILC
System inversion as the learning function in ILC accelerates convergence (Zundert & Oomen, 2018). For linear systems with equal inputs and outputs , setting in Eq. (9) optimizes convergence with , while perfect tracking is achieved by setting in Eq. (12). For non-square systems, if , the least-squares solution is . If , the least-norm solution is .
For LTI square systems, the optimal learning filter is , achieving perfect tracking with . For non-square systems, if , and if . denotes the Hermitian transpose.
Inversion techniques for LTI systems.
Direct inversion is often infeasible for LTI systems, even for square cases, due to the non-causality and non-minimum phase (NMP) zeros outside the unit circle. Non-causality can be handled by shifting the time-domain signal to introduce pre-actuation, making the upper triangular elements of each subsystem, , non-zero. The stable solution based on or norm minimization handles unstable NMP zeros (Zundert & Oomen, 2018).
In practice, a band-limited inversion is typically used, satisfying
| (15) |
where is a zero-phase reference model with the desired bandwidth, mitigating excessive control actions. The ILC low-pass filter in Eq. (10) acts as a robustness filter, limiting learning where model mismatch is large to ensure convergence.
Distinction between left and right inverses.
For a multivariate system, the commutative property generally does not hold; for example, in LTI systems. When solving for in Eq. (15), the choice of a left or right inverse becomes significant.
Consider the control recursion of linear ILC with :
| (16) |
The propagation factor suggests that left inversion aids control convergence. For LTI systems, the band-limited inversion is obtained by
| (17) |
where is the chosen system norm, and subscript indicates derivation from control recursion. Similarly, the error recursion follows:
| (18) |
Here, the propagation factor suggests that right inversion aids error convergence. The band-limited inversion for LTI systems is given by
| (19) |
where subscript denotes derivation from error recursion.
When the system is under-actuated , the left inverse of the system should be used from the input perspective, as shown in Eq. (16). Conversely, for over-actuated systems , the right inverse is applied from the error perspective, as in Eq. (18). In the case of square systems , to minimize tracking error and ensure bounded control signals in ILC, the right inverse is typically employed. This inverse can be substituted in Eq. (10) to analyze the convergence of the algorithm. Details on the invertibility of MIMO LTI systems can be found in Kadam and Palanthandalam-Madapusi (2022).
3. SISO data-driven ILC algorithm and its direct extension
The proposed multivariate data-driven ILC conducts dedicated experiments between iterations to obtain the filtered error signal for control correction in Eq. (7). As the concept was originally for SISO systems (Lee et al., 2022), a brief introduction and its direct extension to MIMO systems will be given.
3.1. SISO algorithm
Fig. 1 visualizes the crucial step of the data-driven ILC for a nonlinear SISO system, represented by a stable causal filter with an assumed repeatable initial state. In step (1) the nominal input signal enters the nonlinear system and produces output signal . In step (2), some perturbation signal is superimposed on the nominal input and the output is collected. It is observed by expanding the output of the nonlinear system
| (20) |
a linearized I/O relationship
| (21) |
is obtained by neglecting higher order terms (H.O.T.). Therefore, via subtraction of the nominal I/O signals from step (1), which amounts to linearization around nominal input and output trajectories, the resultant input perturbation and output encodes the linear time-varying dynamics of the system. The proposed algorithm leverages the adaptive filters’ tracking ability (Haykin, 2002) of linear time-varying systems to accommodate variations in , and constructs the inverse dynamics for effective learning. Interested readers are referred to the original works by the authors for details (Lee et al., 2022).
Fig. 1.

Illustration of time domain linearization using I/O data perturbed around nominal trajectories for a nonlinear SISO system . Scalar signals and denote the input and output, is some probing signal for implicitly constructing the linearized LTV system .
3.2. Direct MIMO extension with left inverse
The direct extension of the data-driven ILC to a multivariate system uses the same procedures as in SISO systems. This is detailed in Fig. 2. The process includes three stages: (1) ILC tracking trial; (2) dedicated experiment for error filtering; and (3) updating ILC commands.
Fig. 2.

Multivariate data-driven ILC with left inverse (denoted as Algorithm 1). (1) Tracking experiment. System is a nonlinear filter, , , , and are vector-valued signals. (2) Dedicated experiment for error filtering. The adaptive filter functions as a dynamic inverse of the linearized system along . (3) ILC control update.
In step (2), the band-limited excitation signal serves as the perturbation input, and the subtraction of nominal output is for the I/O linearization as in the SISO case:
| (22) |
Since , , and are vector-valued signals, the multichannel linear time-varying filter can be derived from the Jacobian matrix
| (23) |
Subsequently, the excited system response is fed into a causal adaptive finite impulse response (FIR) filter such that the cascade dynamics follow an LTI model referenced as . The adaptation recursively updates the coefficients of to minimize the following signal two-norm as time progresses
| (24) |
The parameter is the preview step, such that the non-causal adaptive inverse filter renders the cascade close to the zero-phase reference model . If the model mismatch converges to an LTI system in steady state, and the perturbation is stationary, white, and zero-mean, then the resolving has the interpretation of system inversion from minimization (Haykin, 2002), namely .
The multi-channel adaptive filter
| (25) |
with matrix-valued FIR filter of order
| (26) |
is in effect generating the learning matrix by dynamically populating the time-dependent FIR coefficients of each sub-system row by row
| (27) |
| (28) |
Note the non-causal learning depicted by the non-zero entries in the upper triangular portion, which is enabled by the preview step .
In step (3), the algorithm uses the filtered error signal from the adapted system inversion as feedforward compensation. While this approach shares similarities with the well-known filtered-x LMS algorithm in adaptive inverse control (Widrow & Walach, 2008), it differs in that the system is LTV and non-causal compensation is feasible due to the offline nature of ILC. The design parameters and determine the performance and convergence of the algorithm, and they will be discussed later in the section. The complete algorithm is summarized in Algorithm 1.
| Algorithm 1 MIMO Data-Driven ILC with Left Adaptive Inverse | |
|---|---|
|
|
Convergence analysis.
Consider the linearized systems and in matrix representations, then from Eq. (9) the convergence of Algorithm 1 is established by
| (29) |
Assumption 1. The adaptive model matching error in Fig. 2 step (2) using Eq. (24) results in a bounded LTI uncertainty , wherein is a stable LTI filter for magnitude uncertainty and is a stable phase uncertainty with . This assumption holds in numerous real-world scenarios where the rate of change in plant parameters is sufficiently slow (Tsakalis & Ioannou, 1993).
Theorem 1. Under Assumption 1, Algorithm 1 monotonically converges if
| (30) |
Proof. If the trajectory length is sufficiently large relative to the pulse response of the LTI system, the finite-time matrix two-norm can be approximated by the infinity norm of the LTI transfer function in the frequency domain (Gray et al., 2006). Thus, from the relationship between time and frequency domain convergence in Eqs. (9) and (10), Eq. (29) is rewritten as
This is true if Eq. (30) holds. □
To examine algorithm convergence using Eq. (30), the adaptation signals in Fig. 2 step (2) is used. The uncertainty is estimated via spectral analysis (Pintelon & Schoukens, 2012) of input and adaptation error :
| (31) |
where is the cross spectrum density of and , and is the power spectrum density of .
Remark 1 (Reference Model ). For good tracking, should have a bandwidth at least matching the reference trajectory’s main frequency but not too high to avoid control saturation and model mismatch. Increasing the preview length reduces adaptation error in Eq. (24) by making the Wiener–Hopf solution’s noncausal terms causal (Haykin, 2002).
Remark 2 (Lowpass Filter ). From Eq. (14), zero tracking error is achieved when and . However, because adaptive model matching is not perfect, namely , an aggressive may violate the condition in Eq. (30). The selection of should aim at balancing the trade-off between tracking performance and robustness.
Remark 3 (Excitation ). The system must be sufficiently excited by up to the bandwidth of for a proper inverse . Ideally, should have a variance above the measurement noise floor but not excessively large relative to the nominal tracking error to maintain the validity of the linearized small-signal model.
Remark 4 (Nonlinearity). The analysis relies on linearizing the nonlinear system, assuming that linear dynamics dominate within the excitation amplitude. This assumption may fail for strongly nonlinear systems, where nonlinearity can be assessed using the coherence spectrum of the I/O signals (Pintelon & Schoukens, 2012) from the cascade.
Multi-channel RLS adaptive filtering.
The adaptation of the system inverse is resolved by minimizing the following squared signal 2-norm in time:
| (32) |
wherein , a forgetting factor, is an exponential weighting, the desired input to be matched, the regressor vector, and the weight matrix to be resolved.
In the context of ILC, adaptive filtering is employed for model matching in step (2) of Fig. 2. By relating the objective in Eq. (24) to adaptive filtering in (32), the desired input and the regressor are constructed from and , respectively. Ideally, the weight matrix , consisting of FIR coefficients , maps the regressor to desired input .
Since the cost (32) is convex in , a closed-form global minimum exists. The optimal solution via the recursive least squares (RLS) algorithm is given below (Haykin, 2002):
| (33) |
| (34) |
| (35) |
| (36) |
| (37) |
The RLS algorithm has fast converging property and a computational complexity of . If weight extraction is not required, there exist “fast” algorithms, such as rotation-based algorithm with lattice filter structure (Yang & Bohme, 1992), which can achieve a linear complexity of with enhanced numerical robustness.
Measurement noise.
In the presence of measurement noise on , the regressor becomes , where is the additive noise. Consequently, the update Eq. (36) modifies as follows:
| (38) |
Noise contributes an extra error term, resulting in misalignment between and the optimal weight . If is zero-mean and white Gaussian process with covariance , then the mean-square deviation of the weight error is proportional to the variance (Haykin, 2002). In this case, the matching error , estimated by Eq. (31), will be large, suggesting that a small learning gain or a conservative low-pass should be used.
4. MIMO data-driven ILC algorithms with right inverse
The direct extension of SISO ILC algorithm implicitly constructs the left inverse , but for better error convergence (Section 2.3), the right inverse should be used when . We introduce an MIMO ILC algorithm that leverages through dedicated experiments and propose a modified approach with filter channel transposition to reduce the experiment count.
4.1. MIMO ILC with through dedicated experiments
To construct the right inverse for enhanced error convergence, it is tempting to minimize by swapping the order of and in Fig. 2 during model matching. However, this disrupts adaptive filtering, as is sandwiched between and , invalidating the original RLS formulation.
The key to circumvent this difficulty is by transpose filtering. Because , one can obtain the right inverse by solving an equivalent transposed problem , such that the RLS formulation is still valid. The transposed system can be written as
| (39) |
where is a static mapping with a value of one in the (, ) entry and zero for all other elements:
| (40) |
The definition of in Eq. (39) suggests that for adaptive filtering can be constructed by dedicated experiments via I/O signal manipulation. To better visualize this process, an example of a two-input-two-output system is presented in Fig. 3.
Fig. 3.

The construction of transpose filtered of a two-by-two system. The superscript denotes the channel number.
The MIMO ILC with right inverse is visualized in Fig. 4. Step (2) corresponds to transpose filtering, from which the acquired transpose-filtered signal is used to adapt the causal right inverse in step (3). The non-causal transposed right inverse is then used for error filtering and subsequently ILC update in step (4). To construct from the adapted , the channels should be copied and transposed. Take a three-input-two-output system for example, the system and its transpose are respectively
Fig. 4.

Multivariate data-driven ILC with right inverse (denoted as Algorithm 2). (1) Tracking experiment. (2) Dedicated experiments for constructing . (3) Offline error filtering. A transposed copy of , namely , is used for error filtering. Note is a right inverse of the linearized system along with respect to , namely . (4) ILC control update.
If there are two FIR coefficients for each subsystem, the weight matrices for and can be visualized below
where denotes the FIR coefficient from the input channel to the output channel.
The MIMO ILC with is summarized in Algorithm 2. The reference model , low-pass filter , and excitation signal have the same effects as discussed in Section 4.1.
| Algorithm 2 MIMO Data-Driven ILC with Right Adaptive Inverse (Exhaustive) | |
|---|---|
|
|
Convergence analysis.
Assuming the linearized system. is slowly time-varying, the cascade of and is approximately LTI under adaptive model matching. Then, per Eq. (10) the convergence can be assessed by:
| (41) |
In practice, the following procedure evaluates the convergence condition at :
Collect the signals and to estimate with spectral analysis (31).
Perform frequency-wise multiplication of and compute the singular values at each .
As in Fig. 5, the signal can be recovered from the transpose filtering experiment by proper selection of output channel and removal of biases. Then, one can obtain the signal by running the adaptive model matching in parallel. If the maximum singular value is smaller than one at all frequencies, algorithm convergence is established.
Fig. 5.

Top: Deploy the obtained (up) for control convergence evaluation (down). Bottom: Retrieving the signal from the transpose filtering experiments in Fig. 4. The blue lines denote the additional signals used.
4.2. Reducing the number of dedicated experiments
While Algorithm 2 constructs the desired right inverse , it requires experiments, which can be time-consuming. The measurement noise and non-smooth effect, such as static friction, may accumulate as the number of experiments increases. Additionally, a rescaling of signals may be needed if the I/O channels are of different physical quantities with different orders of magnitude. To address these issues, this subsection devotes to reducing the number of dedicated experiments by the fast transpose technique in efficient linear MIMO adaptive inverse control (Plett, 2001).
The key idea is to use an estimated signal instead of the exact transpose-filtered signal from (39) for adaptive model matching. The modified algorithm, illustrated in Fig. 6, first collects the excited system response , then identifies . Next, is transposed to adapt the right inverse with respect to , and the adapted is copied and transposed for error filtering. This fast transpose filtering process requires only a single experiment, at the cost of using the estimated . The efficient modification is summarized in Algorithm 3.
Fig. 6.

Multivariate data-driven ILC with right inverse . (1) Tracking experiment. (2) Dedicated experiments for constructing . (3-1) Offline adaptive system identification. (3-2) Offline error filtering. In the upper part, a transposed copy of identified in step (3-1) is used to adapt . In the lower part, a transposed copy of adapted is used for error filtering. Note is a right inverse of the estimated linearized system along with respect to , namely . (4) ILC control update. Right: the construction of transpose filtered of a two-by-two system.
| Algorithm 3 MIMO Data-Driven ILC with Right Adaptive Inverse (Fast Transpose) | |
|---|---|
|
|
Convergence analysis.
Referring to Fig. 6, because and are available in step (2) and step (3), the convergence condition in Eq. (41) can be evaluated using signals and , following similar computations as in Section 4.1.
Table 1 summarizes the three MIMO data-driven ILC algorithms in terms of the minimizing objectives in adaptive model matching, the number of dedicated experiments, as well as the number of offline adaptive filtering.
Table 1.
Characteristics of MIMO data-driven ILC algorithms.
| Method |
Algorithm 1 (Left inverse) |
Algorithm 2 (Right inverse, exhaustive) |
Algorithm 3 (Right inverse, fast transpose) |
|---|---|---|---|
| Objective | |||
| No. experiments | 1 | 1 | |
| No. adaptive filtering | 1 | 1 | 2 |
Note: No. of experiments can be further reduced by freezing filter weights, namely iterating converged weights at a fixed iteration and skipping the system excitation step therein. Details can be found in authors’ previous work (Lee et al., 2022).
5. Simulation and experimental results
5.1. Case study 1: H-Type dual drive gantry system
Shown in Fig. 7 is the dual-drive gantry system for ILC algorithm verification. The configuration is commonly found in additive manufacturing equipment, machining centers, vehicle service load simulators (Wentzel, 2013) and time waveform replication tables (Shen et al., 2011). The vertical position of the gantry is controlled by two axes and while the carriage is driven by another axis. Owing to the variation of mass moment of inertia caused by the change in position and the associated dynamics under rapid movements, the gantry can be regarded as a two-input-two-output system with position-dependent dynamics. The integrated mechatronic system is interfaced with an real-time target cRIO-9024 (National Instruments, Texas, U.S.), operating at a 200 Hz control rate. The motors are TECO TSX series (TSX06401C-3N33). The encoder resolution is 0.036°, corresponding to a linear resolution of 0.002 mm. Each motion axis is stabilized by an heuristically tuned PID controller.
Fig. 7.

Gantry system for experimental validation. The dynamics of the gantry, namely and , are dependent on the carriage position . (b) The reference trajectories of each axis. Only and are compensated by ILC algorithms.
The tracked trajectories for and follow the same jerk-limited motion profile as shown in Fig. 8. Meanwhile, the carriage moves at a constant velocity of mm/s, which is unknown to the ILC algorithm. Correspondingly, there are position-dependent couplings for verifying the MIMO ILC algorithms. The frequency response functions of the PID pre-stabilized system are shown in Fig. 9.
Fig. 8.

The reference trajectories of each axis. Only and are compensated by ILC algorithms.
Fig. 9.

Frequency response functions of the two-input-two-output gantry system.
5.1.1. Algorithm settings
The SISO algorithm (Lee et al., 2022) and three MIMO algorithms in Table 1 will be tested. For fair comparison, the reference model , adaptive filtering parameters, and the low-pass filter are the same for all algorithms. The choice and design guidelines are briefed next. For detailed exposition, readers may refer to the prior work (Lee et al., 2022).
Reference model .
The reference model determines the target performance of the linearized system. Therefore, the bandwidth of is chosen in accordance with the frequency content of the reference trajectory. Here, an 8th-order Butterworth filter with a bandwidth of 9 Hz is chosen in both axes for the jerk-limited profile in Fig. 7(b). For a more dynamic trajectory, a higher bandwidth can be chosen provided the control command stays within actuator limits.
Adaptive filter parameters.
The order of FIR adaptive filters represents the length of unit pulse response of the system inverse. An optimal value for , providing adequate performance with low computational complexity, can be selected by examining the adaptive model matching error with as the independent variable. From this analysis, is selected as 32.
Low-pass .
Following the analysis in Sections 3.2 and 4, the low-pass filter serves to ensure algorithm convergence. In this study, has a bandwidth of 7 Hz. In practice, it is advised to first evaluate the model mismatch from adaptive filtering in the frequency domain. Then, a low-pass can be chosen to ensure that the propagation factor contracts. Note that this can be done safely offline between ILC iterations.
5.1.2. Simulation study
Algorithm convergence.
The signals from adaptive filters are first extracted for the evaluation of convergence. As presented in Fig. 10, both Algorithm 1 (MIMO ) and Algorithm 2 (MIMO , Exhaustive) satisfy the convergence conditions of Eqs. (30) and (41). The results from the SISO algorithm are supplemented to demonstrate that ILC convergence degrades and can even be destroyed when strong dynamic coupling is not accounted for. The singular value plot indicates that the convergence speed of Algorithm 1 (MIMO ) is slightly faster than that of Algorithm 2 (MIMO ). This difference may be attributed to the fact that the left inverse is computed to enhance control convergence, as discussed in Section 2.3.
Fig. 10.

The maximum singular values for evaluating the ILC convergence condition of different algorithms.
Error spectra.
In Fig. 11, the power spectral densities (PSD) of the tracking error for each motion axis are presented. The error signals from ILC iterations and are analyzed to illustrate the error progression in frequency domain. In this case, the error convergence speed of Algorithm 2 (MIMO , Exhaustive) is faster than that of Algorithm 2 (MIMO ). This is because the right inverse is utilized to enhance error convergence, which echos the motivation of choosing as the learning filter for the improved algorithms in Section 4.
Fig. 11.

Simulation results of tracking error PSD for motion axes (left) and (right). Thick lines represent iteration , while thin lines represent iteration , illustrating the progression of errors across the spectrum.
The effect of signal-to-noise ratio.
In this simulation, zero-mean Gaussian white noise is added to the system output, yielding a signal-to-noise ratio (SNR) of 30 dB. As shown in Fig. 12, all three algorithms degrade due to measurement noise, as discussed in Section 3.2. This analysis enables a quantitative assessment of algorithm convergence using only adaptive filter signals. The convergence of Algorithm 2 (MIMO , Exhaustive) deteriorates the most due to noise accumulation over multiple experiments, and this motivates the fast transpose technique of Algorithm 3.
Fig. 12.

The ILC convergence test of different algorithms when SNR is 30 dB. The black dashed line denotes the upper bound for convergence.
The effect of system non-smoothness.
In this simulation, a velocity-dependent friction model with Coulomb and viscous friction is introduced in each axis. Employed with different ILC algorithms, the error PSD from ILC iterations and are presented in Fig. 13. Overall performance degrades for each algorithm due to friction, and the proposed Algorithm 2 (MIMO , Exhaustive) is only slightly better compared to Algorithm 2 (MIMO ). Interestingly, note that the efficient alternative, Algorithm 3 (MIMO , Fast Transpose), shows better error reduction owing to the reduced number of experiments. The accumulation of friction-induced errors in Algorithm 2 (MIMO , Exhaustive) is mitigated by the fast transpose filtering technique discussed in Section 4.2. This is substantiated in Fig. 13, which shows the faster error convergence of Algorithm 3 (MIMO , Fast Transpose). Since real-world mechanical systems exhibit friction in the transmission mechanism, it is expected that similar trends will be seen in physical experiments on the H-Type dual drive gantry system. The simulated convergence plot is supplemented in Fig. 14.
Fig. 13.

Simulation results (with non-smooth friction) of tracking error PSD for motion axes (left) and (right). Thick lines represent iteration. , while thin lines represent iteration , illustrating the progression of errors across the spectrum.
Fig. 14.

Simulated ILC convergence (with non-smooth friction) from tracking the jerk-limited references in Fig. 7(b). The dedicated experiments conducted between ILC iterations are as follows: 2 for SISO , 1 for MIMO , 4 for MIMO (Exhaustive), and 1 for MIMO (Fast Transpose).
5.1.3. Experimental results
Shown in Fig. 15 are the experimental results of error convergence for different multivariate ILC algorithms. As the SISO algorithm (SISO, ) performed the poorest in all simulation studies due to neglecting the strong coupling, its experiment was omitted for system protection. Since all multivariate ILC algorithms converge, it can be concluded that the linearization and adaptive model matching techniques are effective to account for complex system dynamics with non-negligible coupling in ILC tracking. The composite RMS error converges at iteration , and this is comparable to those inversion-based algorithms.
Fig. 15.

Experimental ILC convergence from tracking the jerk-limited references in Fig. 7(b).
The proposed improved MIMO ILC algorithms, Algorithm 2 (MIMO , Exhaustive) and Algorithm 3 (MIMO , Fast Transpose), have faster convergence speeds and are consistent with the theoretical analysis and simulation results. Notably, while dedicated experiments are required for Algorithm 2 (MIMO , Exhaustive), Algorithm 3 (MIMO , Fast Transpose) only requires a single experiment in between ILC iterations. This modification mitigates the friction-induced errors during transpose filtering and saves experiment time and cost, thus making the proposed method more practical. The progressions of time domain tracking error and control correction from Algorithm 3 (MIMO , Fast Transpose) are supplemented in Fig. 16 for completeness.
Fig. 16.

Experimental results (MIMO , Fast Transpose) of axis error and control correction progressions from tracking the jerk-limited references in Fig. 7(b). Iteration denotes PID tracking performance.
Despite the nonlinearities and coupling in the experimental motion platform, the SISO algorithm still converges, and the improvements of right inverse over left inverse is not substantial. However, systems with strong coupling and nonlinearities exhibit notable differences in error and convergence rate, as demonstrated in Lee (2019), where a two-link rotary pendulum was used in the simulation study.
5.2. Case study 2: Simulation example of an over-actuated system
To demonstrate the feasibility of the developed algorithms on nonsquare systems, consider an over-actuated (Zundert, Luijten, & Oomen, 2019), sampled at 200 Hz, where the sub-systems contain NMP zeros:
| (42) |
The goal is for the two-input, one-output system to track the same jerk-limited profile in Fig. 8. The adaptive filter has 20 tap coefficients, and the reference model and low-pass filter use the same design parameters as those in Section 5.1.1.
Fig. 17 presents the convergence plot. As expected, the left inverse exhibits the slowest convergence. The fast transpose method converges slightly slower than the regular transpose method due to the additional system identification error introduced in step (3-1) of Fig. 6. The converged FIR coefficients of the one-input-two-output learning filters are presented in Fig. 18. Since the over-actuated system has a non-unique solution, the right inverse produces the least-norm solution. This is also evident in the converged control signals in Fig. 19, where the control signals for are more active.
Fig. 17.

Simulated ILC convergence of the non-square system in Eq. (42) for tracking the jerk-limited profile.
Fig. 18.

Finite impulse response coefficients of the one-input-two-output learning filters.
Fig. 19.

Converged control signals for both input channels of the non-square system in Eq. (42) while tracking the jerk-limited profile.
6. Conclusion
A novel data-driven ILC framework, which is based on linearization around input and output trajectories, is proposed for MIMO nonlinear dynamical systems. The non-negligible and possibly time-varying coupling dynamics that deteriorate SISO ILC performance and convergence is accounted for through multichannel adaptive filtering and the formulation of model matching. The usage of the multivariate inversion from adaptive filtering renders fast ILC convergence.
Particularly, to facilitate the convergence of tracking error, an improved algorithm incorporating the system’s right inverse in adaptive model matching is proposed for square and over-actuated systems. To overcome difficulties in solving for the system’s right inverse during adaptive filtering, intermediate experiments are designed. Further, to minimize the number of required intermediate experiments and alleviate the accumulated non-smoothness between ILC iterations, an alternative scheme utilizing channel manipulation for adaptive filtering is proposed. The convergence of the proposed framework can be analyzed by I/O signal manipulation and spectral analysis of adaptive filter signals.
After conducting extensive simulation studies and experiments on a H-type dual drive gantry system, as well as an over-actuated numerical example, the proposed method demonstrates enhanced error convergence. These findings are anticipated to be replicable across various applications, given the success of the experiments despite disturbances and non-smoothness such as friction and encoder quantization within the gantry system. The primary benefit of this framework lies in its model-free nature, although this comes with the cost of increased experimentation time. Fortunately, the learning process can accelerated by freezing the learning filter weights across iterations when the nominal trajectory remains largely unchanged (Lee et al., 2022).
Future directions include extending the approach to systems with rapidly varying dynamics and exploring sparse data-driven representations for system inversion.
Acknowledgments
This research is supported by National Science and Technology Council in Taiwan under Grants NSTC113-2628-E-002-031 and NSTC 114-2628-E-002-025, National Taiwan University Excellence Research Program (NTU-CC-113L893901 and NTU-CC-114L892101), as well as National Institutes of Health (R01EY030595 and R01EY029689).
Footnotes
CRediT authorship contribution statement
Yu-Hsiu Lee: Writing – review & editing, Writing – original draft, Visualization, Supervision, Resources, Project administration, Methodology, Funding acquisition, Formal analysis, Conceptualization. Yi-Tai Cheng: Visualization, Validation, Software, Investigation, Formal analysis, Data curation. Kai-Shiang Yuan: Visualization, Validation, Software, Investigation, Formal analysis, Data curation. Tsu-Chin Tsao: Writing – review & editing, Supervision, Resources, Project administration, Funding acquisition, Formal analysis, Conceptualization.
Declaration of competing interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
References
- Afshar Puya, Wang Hong, & Chai Tianyou (2009). An ilc-based adaptive control for general stochastic systems with strictly decreasing entropy. IEEE Transactions on Neural Networks, 20(3), 471–482. [DOI] [PubMed] [Google Scholar]
- Arimoto Suguru, Kawamura Sadao, & Miyazaki Fumio (1984). Bettering operation of robots by learning. Journal of Robotic Systems, 1(2), 123–140. [Google Scholar]
- Bolder Joost, Kleinendorst Stephan, & Oomen Tom (2018). Data-driven multivariable ilc: enhanced performance by eliminating l and q filters. International Journal of Robust and Nonlinear Control, 28(12), 3728–3751. [Google Scholar]
- Freeman Christopher Thomas (2017). Robust ilc design with application to stroke rehabilitation. Automatica, 81, 270–278. [Google Scholar]
- Freeman CT, Lewin PL, & Rogers Eric (2005). Experimental evaluation of iterative learning control algorithms for non-minimum phase plants. International Journal of Control, 78(11), 826–846. [Google Scholar]
- Gray Robert M., et al. (2006). Toeplitz and circulant matrices: A review. Foundations and Trends® in Communications and Information Theory, 2(3), 155–239. [Google Scholar]
- Gunnarsson Svante, & Norrlöf Mikael (2001). On the design of ilc algorithms using optimization. Automatica, 37(12), 2011–2016. [Google Scholar]
- Haykin Simon S. (2002). Adaptive filter theory. Pearson Education India. [Google Scholar]
- He Shaoying, Chen Wenbo, Li Dewei, Xi Yugeng, Xu Yunwen, & Zheng Pengyuan (2021). Iterative learning control with data-driven-based compensation. IEEE Transactions on Cybernetics, 52(8), 7492–7503. [DOI] [PubMed] [Google Scholar]
- Hou Zhongsheng, Chi Ronghu, & Gao Huijun (2016). An overview of dynamic-linearization-based data-driven control and applications. IEEE Transactions on Industrial Electronics, 64(5), 4076–4090. [Google Scholar]
- Huo Benyan, Freeman Chris T., & Liu Yanghong (2020). Data-driven gradient-based point-to-point iterative learning control for nonlinear systems. Nonlinear Dynamics, 102(1), 269–283. [Google Scholar]
- Jiang Zheng, & Chu Bing (2022). Norm optimal iterative learning control: A data-driven approach. IFAC-PapersOnLine, 55(12), 482–487. [Google Scholar]
- Kadam Sujay D., & Palanthandalam-Madapusi Harish J. (2022). A note on invertibility and relative degree of mimo lti systems. IFAC Journal of Systems and Control, 20, Article 100193. [Google Scholar]
- Kim Kyong-Soo, & Zou Qingze (2012). A modeling-free inversion-based iterative feedforward control for precision output tracking of linear time-invariant systems. IEEE/ASME Transactions on Mechatronics, 18(6), 1767–1777. [Google Scholar]
- Leang Kam K., & Devasia Santosh (2006). Design of hysteresis-compensating iterative learning control for piezo-positioners: Application to atomic force microscopes. Mechatronics, 16(3–4), 141–158. [Google Scholar]
- Lee Yu-Hsiu (2019). Adaptive and iterative learning control for robot trajectory tracking. Los Angeles: University of California. [Google Scholar]
- Lee Yu-Hsiu, Hsu Sheng-Chieh, Chi Tien-Yun, Du Yan-Yi, Hu Jwu-Sheng, & Tsao Tsu-Chin (2021). Industrial robot accurate trajectory generation by nested loop iterative learning control. Mechatronics, 74, Article 102487. [Google Scholar]
- Lee Jay H., Lee Kwang S., & Kim Won C. (2000). Model-based iterative learning control with a quadratic criterion for time-varying linear systems. Automatica, 36(5), 641–657. [Google Scholar]
- Lee Yu-Hsiu, Rai Sandeep, & Tsao Tsu-Chin (2022). Data-driven iterative learning control of nonlinear systems by adaptive model matching. IEEE/ASME Transactions on Mechatronics, 27(6), 5626–5636. [DOI] [PMC free article] [PubMed] [Google Scholar]
- Li Ruiqi (2024). Data-driven predictive control: equivalence to model predictive control beyond deterministic linear time-invariant systems (Ph.D. thesis), University of Waterloo. [Google Scholar]
- Li Min, Chen Taotao, Cheng Rong, Yang Kaiming, Zhu Yu, & Mao Caohui (2021). Dual-loop iterative learning control with application to an ultraprecision wafer stage. IEEE Transactions on Industrial Electronics, 69(11), 11590–11599. [Google Scholar]
- Lin T, Owens DH, & Hätönen J. (2006). Newton method based iterative learning control for discrete non-linear systems. International Journal of Control, 79(10), 1263–1276. [Google Scholar]
- Longman Richard W. (2000). Iterative learning control and repetitive control for engineering practice. International Journal of Control, 73(10), 930–954. [Google Scholar]
- Meindl Michael, Bachhuber Simon, & Seel Thomas (2024). Ai-mole: Autonomous iterative motion learning for unknown nonlinear dynamics with extensive experimental validation. Control Engineering Practice, 145, Article 105879. [Google Scholar]
- Minakais Matt, Mishra Sandipan, & Wen John T. (2019). Database-driven iterative learning for building temperature control. IEEE Transactions on Automation Science and Engineering, 16(4), 1896–1906. [Google Scholar]
- Mishra Sandipan, Topcu Ufuk, & Tomizuka Masayoshi (2010). Optimization-based constrained iterative learning control. IEEE Transactions on Control Systems Technology, 19(6), 1613–1621. [Google Scholar]
- Norrlöf Mikael, & Gunnarsson Svante (2002). Time and frequency domain convergence properties in iterative learning control. International Journal of Control, 75(14), 1114–1126. [Google Scholar]
- Pintelon Rik, & Schoukens Johan (2012). System identification: a frequency domain approach. John Wiley & Sons. [Google Scholar]
- Plett Gregory L. (2001). Efficient linear mimo adaptive inverse control. IFAC Proceedings Volumes, 34(14), 89–94. [Google Scholar]
- Shen Gang, Zheng Shu-Tao, Ye Zheng-Mao, Huang Qi-Tao, Cong Da-Cheng, & Han Jun-Wei (2011). Adaptive inverse control of time waveform replication for electrohydraulic shaking table. Journal of Vibration and Control, 17(11), 1611–1633. [Google Scholar]
- Shih Li-Wei, & Chen Cheng-Wei (2022). Model-free repetitive control design and implementation for dynamical galvanometer-based raster scanning. Control Engineering Practice, 122, Article 105124. [Google Scholar]
- Simon Barry (2010). Szego’s theorem and its descendants: spectral theory for l2 perturbations of orthogonal polynomials. Princeton University Press. [Google Scholar]
- Simonelli James Michael (2017). Novel hydrostatic fluid power actuators. Los Angeles: University of California. [Google Scholar]
- Tsakalis Kostas S., & Ioannou Petros A. (1993). Linear time-varying systems: control and adaptation. Prentice-Hall, Inc.. [Google Scholar]
- Volckaert Marnix, Diehl Moritz, & Swevers Jan (2013). Generalization of norm optimal ilc for nonlinear systems with constraints. Mechanical Systems and Signal Processing, 39(1–2), 280–296. [Google Scholar]
- Wang Cong, Zhao Yu, Chen Yubei, & Tomizuka Masayoshi (2015). Nonparametric statistical learning control of robot manipulators for trajectory or contour tracking. Robotics and Computer-Integrated Manufacturing, 35, 96–103. [Google Scholar]
- Wentzel Henrik (2013). Fatigue test load identification using weighted modal filtering based on stress. Mechanical Systems and Signal Processing, 40(2), 618–627. [Google Scholar]
- Widrow Bernard, & Walach Eugene (2008). Adaptive inverse control: a signal processing approach (reissue ed.). [Google Scholar]
- Wu Wenjie, Qiu Lin, Liu Xing, Guo Feng, Rodriguez Jose, Ma Jien, et al. (2022). Data-driven iterative learning predictive control for power converters. IEEE Transactions on Power Electronics, 37(12), 14028–14033. [Google Scholar]
- Xu Jian-Xin, & Tan Ying (2003). Vol. 291, Linear and nonlinear iterative learning control. Springer. [Google Scholar]
- Yang Bin, & Bohme Johann F. (1992). Rotation-based rls algorithms: Unified derivations, numerical properties, and parallel implementations. IEEE Transactions on Signal Processing, 40(5), 1151–1167. [Google Scholar]
- Zhang Dailin, Wang Zining, & Masayoshi Tomizuka (2020). Neural-network-based iterative learning control for multiple tasks. IEEE Transactions on Neural Networks and Learning Systems, 32(9), 4178–4190. [DOI] [PubMed] [Google Scholar]
- Zhang Zezhou, & Zou Qingze (2022). Optimal data-driven difference-inversion-based iterative control: High-speed nanopositioning tracking example. IEEE Transactions on Control Systems Technology, 31(1), 144–154. [Google Scholar]
- Zundert Jurgen van, Luijten Fons, & Oomen Tom (2019). Exact and causal inversion of nonminimum-phase systems: A squaring-down approach for overactuated systems. IEEE/ASME Transactions on Mechatronics, 24(6), 2953–2963. [Google Scholar]
- Zundert Jurgen van, & Oomen Tom (2018). On inversion-based approaches for feedforward and ilc. Mechatronics, 50, 282–291. [Google Scholar]
