Skip to content
Back to search results

Iterative Learning Control

Introduced by
Suguru Arimoto
Year
1984
Type
algorithm
Family
Adaptive Control
Font size

What does it do?

Iterative Learning Control (ILC) is a control method for systems that perform the same task repeatedly (trajectory tracking over a fixed time interval).

The key idea is to use error information from previous trials to update the input for the next trial, progressively improving tracking accuracy. Pioneered by Arimoto et al. in 1984, ILC is ideal for robotic manufacturing, semiconductor processing, and any application where the same motion must be repeated many times with high precision.

The intuition behind the method

ILC exploits the structure of repetitive tasks: the task is well-defined (a target trajectory over a fixed time horizon), and the system is deterministic (same initial conditions each trial). The algorithm measures the tracking error in trial k, uses this error to compute an updated input u_{k+1} for trial k+1, and repeats. The key mechanism is learning from error: if the system undershoots at a certain time in trial k, increase the input magnitude at that time in trial k+1. Over many trials, accumulated corrections drive the error to zero. This differs from adaptive control (which adapts in real-time) and from feedback control (which reacts to current error); ILC proactively prepares inputs based on past trials.

History

Arimoto introduced ILC in 1984 for robotic manipulators performing repeated tasks, motivated by motor learning in biological systems. Moore developed comprehensive theory in the early 1990s, establishing convergence conditions for various learning laws. Xu and colleagues extended ILC to nonlinear systems, time-delay systems, and multidimensional systems. Modern variants include iterative learning control with feedback (ILFC), ILC for networks of agents, and stochastic ILC for handling random disturbances. ILC has seen significant industrial adoption in semiconductor manufacturing and precision robotics.

When to use it

Use ILC when your system performs a well-defined, repetitive task with the same initial conditions each iteration. It is ideal for robotics (pick-and-place, assembly lines), semiconductor manufacturing (wafer scanning, lithography), and precision motion tasks. ILC shines when a small number of trials (10-100) can achieve very high accuracy (submicron precision). Avoid ILC if the task is non-repetitive, if initial conditions vary unpredictably, or if real-time responsiveness to disturbances is critical (use feedback control instead).

Limitations and considerations

  • Requires repetition of the exact same task; if task parameters vary, learning must restart.
  • Convergence is slow at the beginning (early trials have large errors); significant investment in commissioning time.
  • Sensitive to initial condition variations; if trial k starts at a different state than trial k-1, learning degrades.
  • Learning rule design is problem-dependent; no universal rule works for all systems.
  • Non-repetitive disturbances are not handled well; only periodic errors are learned.

Source conditions do not replace independent scientific review or validation by an analysis engine.

Strengths

  • Achieves high accuracy (often submicron) in repetitive tasks through progressive learning over multiple trials.
  • Simple implementation; learning rule is often just proportional to accumulated error.
  • Handles open-loop learning (no feedback needed during the trial), useful when sensors are expensive or unavailable.
  • Can combine with feedback to handle random disturbances while maintaining iterative improvement.
  • Robust to periodic disturbances that repeat each trial; the learning mechanism naturally rejects them.

Applications

  • Robotics: Precise trajectory tracking in pick-and-place operations, welding robot programming, assembly line motion optimization.
  • Semiconductor manufacturing: Wafer scanning in lithography tools, wafer stage alignment, electron-beam lithography positioning.
  • Printing and paper industry: Web positioning, color registration across multiple passes, thickness control.
  • Material processing: Laser cutting of repetitive patterns, multi-pass surface finishing with precise tool paths.
  • Industrial machinery: High-precision milling with repeated cuts, injection molding with cycle-by-cycle learning.

How it works

How it works

1

Define the reference trajectory, set initial control input u_0 (often zero or a feedforward estimate), and initialize tracking error e_0.

2

Apply input u_k to the system and execute the task (e.g., robot motion) for the fixed time interval from t=0 to t=T.

3

Measure system output y_k and compute tracking error e_k(t) = y_desired(t) − y_k(t) over the entire trial interval.

4

Use the error to compute updated input u_{k+1} = u_k + L(e_k), where L is the learning rule (proportional, integral, or higher-order).

Common pitfalls

  • Choosing too aggressive a learning gain; this can cause oscillation and divergence instead of convergence.
  • Ignoring higher-order dynamics and causality; the learning rule must account for system bandwidth and delays.
  • Assuming perfect repeatability; small variations in initial conditions or plant parameters compound over trials.
  • Not monitoring closed-loop stability; aggressive learning can excite unmodeled dynamics and destabilize the system.

Frequently asked questions

What is the simplest learning rule and how do I tune it?

The simplest rule is proportional: u_{k+1}(t) = u_k(t) + γ·e_k(t), where γ > 0 is the learning gain. For convergence, γ must be small enough (typically < 0.5 for discrete-time systems). Start with γ = 0.1 and increase gradually while monitoring for oscillation or divergence. The learning rate affects convergence speed: larger γ converges faster but risks instability.

How many trials do I need to achieve convergence?

This depends on the learning gain, system dynamics, and desired accuracy. For typical systems, 10-50 trials achieve high accuracy; for very precise applications (semiconductor), 100-500 trials may be needed. Early trials usually show rapid improvement, then convergence slows (exponential convergence pattern).

Can ILC handle disturbances?

ILC alone cannot reject non-repetitive disturbances that vary between trials. However, combining ILC with feedback control (Hybrid ILC/ILFC) enables rejection of both: feedback handles random disturbances in real-time, while ILC progressively reduces systematic errors. Another approach is stochastic ILC, which models disturbances probabilistically.

What happens if initial conditions are not perfectly repeatable?

Small initial condition errors cause learning errors to accumulate, degrading convergence. In practice, use a resetting mechanism (e.g., mechanical stops, sensor-based reset) to ensure consistent initial conditions. Alternatively, use robust ILC methods designed to tolerate small initial condition variations.

Related methods

Sources

  1. Arimoto, S., Kawamura, S., & Miyazaki, F. (1984). Bettering operation of robots by learning. Journal of Robotic Systems, 1(2), 123-140.

    Open DOI reference
    Copied.
  2. Moore, K. L. (1993). Iterative learning control for trajectory tracking. Advances in Industrial Control, Springer-Verlag.

    Open publication reference
    Copied.
  3. Bien, Z., & Xu, J. X. (2007). Iterative Learning Control: Analysis, Design, Integration and Applications. Kluwer Academic Publishers.

    Open publication reference
    Copied.