Concurrent learning for convergence in adaptive control without persistency of excitation
Zhao Zhao
  2022-08-16 22:03:06 2022-08-16 22:03    

Chowdhary, G., & Johnson, E. (2010, December). Concurrent learning for convergence in adaptive control without persistency of excitation. In 49th IEEE Conference on Decision and Control (CDC) (pp. 3674-3679). IEEE.

ADAPTIVE CONTROL WITHOUT PERSISTENCY OF EXCITATION

A. Model Reference Adaptive Control

Consider the following system where the uncertainty can be linearly parameterized: A reference model can be designed that characterizes the desired response of the system: Control law: With an appropriate choice of such that , the tracking error dynamics are found to have the form Hence for any positive definite matrix , a positive definite solution exists to the Lyapunov equation Assumption 1: The uncertainty can be linearly parameterized, that is, Letting denote the estimate the adaptive element is chosen as . For this case it is well known that the adaptive law For this baseline adaptive law, it is also well known that a necessary and sufficient condition for guaranteeing is that (t) be persistently exciting.

B. Proof of Stability

Theorem: Consider the system, the control law , the case of structured uncertainty, and the following weight update law: and assume that the stored data points satisfy , then the zero solution of tracking error dynamics is globally exponentially stable and exponentially.

Consider the following positive definite and radially unbounded Lyapunov candidate Then, we have

Also, we have Then, establishing the exponential stability of the zero solution .

  • The above proof shows exponential convergence of tracking error e(t) and parameter estimation error to 0 without requiring persistency of excitation in the signal . The only condition required is to guarantee that the matrix is positive definite.

  • For evaluating the adaptive law the term is required for the th data point where . The model error can be observed by noting that

  • The rate of convergence is determined by the spectral properties of , and , the first three are dependent on the choice of the linear gains and the learning rates, and the last one is dependent on the choice of the stored data.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
%  This code implements the concurrent learning to store and determine the
%  stored data, including the add and delete using SVD

function oCL = ConcurrentLearningSVD(epsilon, pmax, Wstar)
% epsiloin--value to determine whether added the points
% pmax--max point to store

nbg=0;   % initial number of the stored data
Xbg=Wstar*0;  % initial \Phi,  the same size as sigma
Delta_bg = [ ] ; % store the Delta
Timebg = [ ] ; % store the add time
last_point = [ ]; % the index of the last point in the store
oldrank=[ ] ;
old_eig=[ ];
XbgOld = [ ] ;


oCL.process = @process;
oCL.adaptiveCL = @adaptiveCL;
oCL.get = @oCL_get;

% process the data
    function process(sigma, deltaErr, add_new_points, t)
        % sigma--current regressor
        % deltaErr--current Delta
        oldrank = rank(Xbg*Xbg') ;
        old_eig=min(sqrt(eig(Xbg(:,1:nbg)*Xbg(:,1:nbg)')));
        if add_new_points==1    % turn on the stored data
            if nbg==0   % the first point is added
                nbg = nbg +1;
                Xbg(:,nbg)=sigma;  % the first column
                Timebg(nbg)=t;
                Delta_bg(:,nbg)=deltaErr;
                last_point=nbg;
            elseif norm(sigma-Xbg(:, nbg))/norm(sigma)>= epsilon % add new data from the second data
                nbg = nbg +1; % add the new data
                last_point=nbg;
                XbgOld=Xbg;   % before add the new data sigma and deltaErr
                Xbg(:,nbg)=sigma;
                Delta_bg(:,nbg)=deltaErr;
                Timebg(nbg)=t;
            end
            if nbg>pmax   % the store is full
                [Xbg,Delta_bg,nbg,I]=data_remover_SVD(XbgOld,Delta_bg,sigma,old_eig,deltaErr,nbg);
                if norm(Xbg(:,1:nbg)-XbgOld)>0
                    Timebg(I)=t;
                end
                last_point=nbg;
            end
        end
    end

% do concurrent learning
    function [Wb, PhiPhi] = adaptiveCL(gammaWbkk, W)
        Wb = W.*0 ;
        PhiPhi=0;
        for kk=1:nbg
            Wb=-gammaWbkk*(W'*Xbg(:, kk)-Delta_bg(kk))*Xbg(:,kk)+Wb;
            PhiPhi =Xbg(:,kk)*Xbg(:,kk)'+PhiPhi;
        end
    end

% get the data
    function mval = oCL_get(mfield)
        
        switch(mfield)
            case {'Xbg'}
                mval = Xbg;
            case {'Delta_bg'}
                mval = Delta_bg;
            case {'Timebg'}
                mval = Timebg;
            case {'nbg'}
                mval = nbg;
        end     
    end
end