APLICAŢIA NR.

Algoritmi rapizi de antrenament pentru RNA de tip MLP

1. Introducere

Se vor investiga câteva metode, detaliate în [7] şi [8], care conduc la

accelerarea procesului de antrenament al unei RNA – MLP:
- metoda Darken-Moody;
- regula delta-delta;
- adaptarea fuzzy a ratei de învăţare;
- metode bazate pe calculul gradientului conjugat (Fletcher-Reeves, Polak-
Ribière);
- metoda Levenberg-Marquardt.

2. Metoda Darken-Moody

Denumita şi metoda “caută apoi converge”, propune ajustarea ratei de învăţare

într-un mod simplu dar care aduce un spor considerabil în ceea ce priveşte viteza de
convergenţă a algoritmului de antrenament.
Se propune o rată de învăţăre de forma:
"0
" ( n) $ (5.1)
n
1#
!
în care η0 reprezintă rata de învăţăre iniţială, τ o constantă de timp iar n numărul
epocilor de antrenament.
Variaţia η de-alungul epocilor de antrenament este ilustrată în fig. 5.1. În epoci
timpurii, algoritmul se comportă similar celui standard, rata de învăţare menţinându-se
- 46 - Aplicaţia nr. 5

ridicată şi relativ constantă. Pe măsură ce procesul de antrenament avansează, η este

micşorată.

8
Rata de invatare

2
0 1 2 3
10 10 10 10
Nr. de epoc i

Fig. 5.1 Forma de variaţie a η de-alungul epocilor de antrenament.

Ca dezavantaj al acestei metode este considerată imposibilitatea alegerii apriorice a

valorilor optime pentru constantele η0 şi τ.

3. Regula delta-delta

Considerând valoarea criteriului (atributului) de performanţă (MSE, SSE, etc.)

notată cu perf(w(n)), regula de modificare a ratei de învăţare este în acest caz:

(c1 * " (k ) 1), if perf ( w(k )) , perf ( w(k ) 1)

%
" (k ) $ 'c 2 * " (k ) 1), if perf ( w(k )) + c3 * perf ( w(k ) 1) (5.2)
%" (k ) 1), altfel
&
în care coeficienţii au următoarele valori tipice: c1 = 1,05, c2 = 0,7, c3 = 1,04.
În cazul în care η(n) = η(n-1), noile valori calculate pentru w(n) şi perf(w(n)) vor avea
valoarea w(n-1) respectiv perf(w(n-1)).
 Algoritmi rapizi de antrenament pentru RNA de tip MLP - 47 -

4. Adaptarea fuzzy a ratei de învăţare

Dezavantajul metodei precedente constă din faptul că parametrii c1 şi c2 sunt

constanţi de-alungul etapei de învăţare şi, în consecinţă, impiedică o variaţie rapidă a
ratei de învăţare.
Controlerul fuzzy [9] primeşte drept intrări valoarea relativă a atributului de
performanţă:
perf (n)
p ( n) $ (5.3)
perf (n ) 1)
şi variaţia relativă a p(n):
perf (n) perf (n ) 1)
-p(n) $ ) (5.4)
perf (n ) 1) perf (n ) 2)
Ieşirea controlerului de tip Mamdami reprezintă un coeficient “c” care multiplică rata
de învăţare:
" (n) $ c * " (n ) 1) (5.5)
Suprafaţa de reglare a controlerului este prezentată în fig. 5.2.

5. Metode bazate pe calculul gradientului conjugat

Metodele de antrenament prezentate până în acum pot fi circumscrise în clasa

metodelor de ordinul întâi ale gradientului descendent deoarece iau în considerare
prima derivată a funcţiei de cost (funcţie criteriu). În cazul acestor metode, direcţia
vectorului de-alungul căruia se face ajustarea ponderilor reprezintă negativul
gradientului.
Metoda gradientului conjugat evită oscilaţiile în jurul soluţiei finale,
considerând o relaţie, relativ complicată, între direcţia şi gradientul vectorului.
Fie p(n) vectorul direcţie. Ponderile reţelei vor fi adaptate după următoarea
regulă:
- 48 - Aplicaţia nr. 5

w (n # 1) $ w (n) # " (n) p(n) (5.6)

Iniţial:
p(0) $ ) g (0) (5.7)

Fig. 5.2 Suprafaţa de reglare a controlerului fuzzy.

în care g(n) reprezintă vectorul gradient. Ceilalţi vectori direcţie vor fi calculaţi ca o
combinaţie liniară a vectorului gradinet curent şi a vectorului direcţie anterior:
p(n # 1) $ ) g (n # 1) # . (n) p(n) (5.8)
Există numeroase moduri de exprimare a parametrului β(n):
a) Formula Fletchr-Reeves:

g (n # 1) T g (n # 1)
. ( n) $ (5.9)
g ( n) T g ( n)
b) Formula Polak-Ribière:

g (n # 1) T [ g (n # 1) ) g (n)]
. ( n) $ (5.10)
g ( n) T g ( n)
În cazul ec. (5.6) η(n) este definit după cum urmează:
" (n) $ arg min{E av ( w (n) # "p(n))} (5.11)

adică presupune o căutare liniară pentru găsirea valorii particulare η care minimizează
funcţia de cost.
 Algoritmi rapizi de antrenament pentru RNA de tip MLP - 49 -

6. Metoda Levenberg-Marquardt (LM)

Metoda LM derivă din metoda Newton de minimizare a unei funcţii [8] şi

presupune însumarea hessianului H (matrice cu elemente derivate de ordinul doi ale
indicelui de performanţă) cu un termen de forma νI (ν constantă pozitivă, I matricea
identică) în scopul eliminării cazurilor pentru care H-1 nu există:
/E /E
-w $ )" )1
$ )" 2 (5.12)
H [/ E # 0I ])1
Când indicele (funcţia) de performanţă este o sumă de pătrate (cazul RNA
feedforward) matricea hessiană poate fi aproximată prin JT J iar gradientul prin JT e
unde J reprezintă jacobianul RNA (matrice cu elemente derivate de ordinul I ale
indicelui de performantă) şi e reprezintă vectorul eroare al RNA [10].

J Te
-w $ )" (5.13)
[J T J # 0I ])1
De menţionat faptul că ν poate să fie modificat adaptiv, pentru el fiind recomandată o
valoare cât mai mică.
Metoda LM reprezintă cea mai rapidă metodă de antrenament dar viteza de
converganţă poate să scadă dramatic dacă dimensiunile RNA cresc.

7. Probleme

7.1 Pentru cazul problemei de interpolare formulată în Aplicaţia nr. 4, pct. 4.2,
verificaţi comparativ viteza de convergenţă pentru algoritmul BP standard şi cele 6
metode prezentate în cadrul acestei lucrări.
Rezolvare:

% Comparatie intre diversi algoritmi de antrenament

% cazul interpolarii unei functii
% Catalin-Daniel Caleanu, 2000

clear all
- 50 - Aplicaţia nr. 5

close all
clc
% definirea perechilor de vectori
% intrare (P,pattern) - iesire (T, target)
% pentru datele de antrenament (P,T) si test (Ptest, Ttest)
P = 0:0.1:1;
T = 0.2 + 0.8*(P + 0.7*sin(2*pi*P));
Ptest=0:0.01:1;
Ttest=0.2 + 0.8*(Ptest + 0.7*sin(2*pi*Ptest));

% se implementeaza 4 RNA-MLP identice cu:

% 1 intrare, 9 neuroni ascunsi, 1 neuron de iesire
% antrenate cu 4 algoritmi diferiti
net1= newff(minmax(P),[9 1],{'tansig' 'logsig'},'traingdm');
net1.trainParam.lr=3;
net1.trainParam.mc=0.3;
net1.trainParam.min_grad=1e-10;
net1.trainParam.show = 1;
net1.trainParam.epochs = 60;
net1.trainParam.goal = 0.001;
t1 = clock;
[net1,tr1]= train(net1,P,T);
time1=etime(clock,t1);

net2= newff(minmax(P),[9 1],{'tansig' 'logsig'},'traingdx');

net2.trainParam.lr = net1.trainParam.lr;
net2.trainParam.mc = net1.trainParam.mc;
net2.trainParam.min_grad = net1.trainParam.min_grad;
net2.trainParam.show = net1.trainParam.show;
net2.trainParam.epochs = net1.trainParam.epochs;
net2.trainParam.goal = net1.trainParam.goal;
t2 = clock;
[net2,tr2]= train(net2,P,T);
time2=etime(clock,t2);
net3= newff(minmax(P),[9 1],{'tansig' 'logsig'},'trainfuzzy');
net3.trainParam.lr = net1.trainParam.lr;
net3.trainParam.mc = net1.trainParam.mc;
net3.trainParam.min_grad = net1.trainParam.min_grad;
net3.trainParam.show = net1.trainParam.show;
net3.trainParam.epochs = net1.trainParam.epochs;
net3.trainParam.goal = net1.trainParam.goal;
t3 = clock;
[net3,tr3]= train(net3,P,T);
time3=etime(clock,t3);

net4= newff(minmax(P),[9 1],{'tansig' 'logsig'},'trainlm');

net4.trainParam.lr = net1.trainParam.lr;
net4.trainParam.mc = net1.trainParam.mc;
net4.trainParam.min_grad = net1.trainParam.min_grad;
net4.trainParam.show = net1.trainParam.show;
net4.trainParam.epochs = net1.trainParam.epochs;
net4.trainParam.goal = net1.trainParam.goal;
 Algoritmi rapizi de antrenament pentru RNA de tip MLP - 51 -

t4 = clock;
[net4,tr4]= train(net4,P,T);
time4=etime(clock,t4);

y1test = sim(net1,Ptest);
y2test = sim(net2,Ptest);
y3test = sim(net3,Ptest);
y4test = sim(net4,Ptest);
y1antr = sim(net1,P);
y2antr = sim(net2,P);
y3antr = sim(net3,P);
y4antr = sim(net4,P);

% calcul eroare test, antrenament si timp de executie

er1test=(sum(sum(abs(Ttest-y1test))))/length(Ttest);
er2test=(sum(sum(abs(Ttest-y2test))))/length(Ttest);
er3test=(sum(sum(abs(Ttest-y3test))))/length(Ttest);
er4test=(sum(sum(abs(Ttest-y4test))))/length(Ttest);
ertest=[er1test er2test er3test er4test];

er1antr=(sum(sum(abs(T-y1antr))))/length(T);
er2antr=(sum(sum(abs(T-y2antr))))/length(T);
er3antr=(sum(sum(abs(T-y3antr))))/length(T);
er4antr=(sum(sum(abs(T-y4antr))))/length(T);
erantr=[er1antr er2antr er3antr er4antr];

time=[time1 time2 time3 time4]

% reprezentarea grafica a rezultatelor

clf;
figure
title('Aproximare functiei 0.2 + 0.8*(x + 0.7*sin(2*pi*x))');
hold
plot(Ptest,Ttest,'linewidth', 2)
plot(Ptest,y1test,'-');
plot(Ptest,y2test,':r');
plot(Ptest,y3test,'-.g');
plot(Ptest,y4test,'--m');
xlabel('x');
legend('original','traingdm', 'traingdx', 'trainfuzzy',
'trainlm',0);
hold off
figure
hold
semilogy(tr1.epoch,tr1.perf,'-');
semilogy(tr2.epoch,tr2.perf,':r');
semilogy(tr3.epoch,tr3.perf,'-.g');
semilogy(tr4.epoch,tr4.perf,'--m');
title('EPM versus numar de epoci');
xlabel('Numar de epoci');
legend('traingdm', 'traingdx', 'trainfuzzy', 'trainlm',0)
hold off
- 52 - Aplicaţia nr. 5

figure
bar((ertest)*100);
ylabel('Eroare aproximare test [%]');
xlabel('traingdm 1 traingdx 2 trainfuzzy 3 trainlm 4')
figure
bar((erantr)*100);
ylabel('Eroare aproximare antrenament [%]');
xlabel('traingdm 1 traingdx 2 trainfuzzy 3 trainlm 4')
figure
barh(time,'r');
xlabel('Timp prelucrare [s]');
ylabel('traingdm 1 traingdx 2 trainfuzzy 3 trainlm 4')
hold off
ertest=[er1test er2test er3test er4test]*100
erantr=[er1antr er2antr er3antr er4antr]*100

7.2 Repetaţi verificarea de la punctul 7.1 pentru cazul unei probleme de clasificare a
unor tipare de dimensiuni mari (baza de date ORL).

7.3 Completaţi tabelul de mai jos (tab.5.1), pe baza rezultatelor simulării de la pct. 7.1
şi 7.2. Care sunt concluziile desprinse în urma rulării acestor algoritmi de antrenamet ?

Rezolvare:
Concluziile experimentelor conduc la ideea că algoritmii de antrenament se
clasează, în ordinea crescătoarea a vitezei de convergenţă, conform tab.5.1, adică cel
mai lent algoritm este algoritmul gradientului descendent iar cel mai rapid
Levenberg-Marquardt.
Trebuie ţinut cont însă de faptul că cerinţele de memorie şi putere de calcul
sunt practic proporţionale cu viteza de convergenţă. Spre exemplu, probleme care
implică vectori de intrare de dimensiuni mari (sute de elemente) sunt imposibil de
abordat cu metoda Levenberg-Marquardt şi greu de abordat cu metodele bazate pe
gradientul conjugat (Fletcher-Reeves, Polak-Ribière).
 Algoritmi rapizi de antrenament pentru RNA de tip MLP - 53 -

6 4
Eroare aproximare antrenament [%]
Eroare aproximare test [%]

3
4
2

2
1

0 0
1 2 3 4 1 2 3 4
traingdm 1 traingdx 2 trainfuzzy 3 trainlm 4
traingdm 1 traingdx 2 trainfuzzy 3 trainlm 4

Fig.5.1 Grafice rezultate în urma rulării programului aferent pct.7.1.

- 54 - Aplicaţia nr. 5

TIP PROBLEMĂ
INTERPOLARE CLASIFICARE
EPM Nr. Timp EPM Nr. Timp
METODĂ [%] de de [%] de de
epoci calcul epoci calcul
[s] [s]
1. BP momentum
(traingdm)
2. delta-delta
(traingdx)
3. η fuzzy
(trainfuzzy)
4. Fletcher-Reeves
(traincgf)
5. Polak-Ribière
(traincgp)
6. Levenberg-Marquardt
(trainlm)

Tab. 5.1 Rezultate comparative pentru diverşi algoritmi de antrenament ai RNA MLP.

Metodele backpropagation cu rata variabilă de învăţare (traingdx, trainfuzzy)

oferă cel mai bun raport viteză de convergenţă / cerinţe de memorie.