INTELIGENŢĂ ARTIFICIALĂ.

ÎNDRUMAR DE
LABORATOR

GRIF Horaţiu Ştefan

1
2
 CUPRINS
LUCRAREA NR. 1.................................................................................................................................... 5

STRUCTURA GENERALA A UNUI NEURON ARTIFICIAL .............................................................. 5

1. SCOPUL LUCRĂRII ................................................................................................................................ 5
2. NOŢIUNI TEORETICE ............................................................................................................................ 5
2.1. Structura generală a unui neuron artificial.................................................................................. 5
2.2. Funcţii Matlab ............................................................................................................................ 8
PROBLEME PROPUSE ................................................................................................................................ 9
LUCRAREA NR. 2.................................................................................................................................. 11

PERCEPTRONUL BINAR..................................................................................................................... 11
1. SCOPUL LUCRĂRII .............................................................................................................................. 11
2. NOŢIUNI GENERALE ........................................................................................................................... 11
2.1 Structura generală a perceptronului binar.................................................................................. 11
2.2 Algoritm de antrenare al perceptronului binar ........................................................................... 12
2.3 Funcţii Matlab........................................................................................................................... 13
PROBLEME PROPUSE .............................................................................................................................. 14
LUCRAREA NR. 3.................................................................................................................................. 17

REŢELE NEURONALE ARTIFICIALE FEEDFORWARD CU STRAT ASCUNS............................ 17

1. SCOPUL LUCRĂRII .............................................................................................................................. 17
2. NOŢIUNI GENERALE ........................................................................................................................... 17
2.1 Structura generală a RNA feedforward multistrat ....................................................................... 17
2.2 Algoritmul iterativ Backpropagation (Delta generalizată) pentru RNA cu un singur strat ascuns. 18
2.3 Funcţii Matlab........................................................................................................................... 19
PROBLEME PROPUSE .............................................................................................................................. 20
LUCRAREA NR. 4.................................................................................................................................. 23

REŢELE NEURONALE ARTIFICIALE CU FUNCŢII DE ACTIVARE RADIALE.......................... 23

1 SCOPUL LUCRĂRII ............................................................................................................................... 23
2 NOŢIUNI TEORETICE ........................................................................................................................... 23
2.1 Structura RNA-RBF ................................................................................................................... 23
2.2 Algoritmul de antrenare al RNA-RBF......................................................................................... 24
2.3 FUNCŢII MATLAB ............................................................................................................................ 24
PROBLEME PROPUSE .............................................................................................................................. 25
LUCRAREA NR. 5.................................................................................................................................. 27

MEMORIA HOPFIELD DISCRETĂ..................................................................................................... 27

1 SCOPUL LUCRĂRII ............................................................................................................................... 27
2 NOŢIUNI TEORETICE ........................................................................................................................... 27
2.1 Arhitectura memoriei Hopfiled discretă...................................................................................... 27
PROBLEMĂ PROPUSĂ ............................................................................................................................. 28
LUCRAREA NR. 6.................................................................................................................................. 31

SISTEME FUZZY................................................................................................................................... 31
1 SCOPUL LUCRĂRII ............................................................................................................................... 31
2 NOŢIUNI TEORETICE ........................................................................................................................... 31
2.1 Structura generală a unui sistem fuzzy........................................................................................ 31
2.2 Variabile, valori şi reguli lingvistice........................................................................................... 32
2.3 Proiectarea unui sistem fuzzy ..................................................................................................... 33
3. FUNCŢII MATLAB .............................................................................................................................. 34
PROBLEMĂ PROPUSE ............................................................................................................................. 36

3
4
 Lucrarea nr. 1

Structura generala a unui neuron artificial

1. Scopul lucrării
Familiarizarea studenţilor cu structura generală a unui neuron artificial.
Crearea primului neuron artificial utilizând funcţia Matlab newlin. Simularea
neuronului creat cu ajutorul funcţiei Matlab sim. Crearea unui perceptron cu funcţia
Matlab newp. Simularea perceptronului folosind diferite funcţii de activare.

2. Noţiuni teoretice

2.1. Structura generală a unui neuron artificial

Modelul general al unui neuron artificial este prezentat în Figura 1.

Figura 1. Modelul general al neuronului artificial

Semnificaţiile notaţiilor şi a blocurilor componente ale neuronului artificial

prezentat în Figura 1 sunt următoarele:
- xi i  1, n  reprezintă intrările în neuron. În cazul integrării neuronului într-o reţea
de neuroni aceste intrări vor reprezenta activările tuturor neuronilor conectaţi la
acest neuron în cauză. Setul celor n intrări x=(x1 x2 …xn) mai este cunoscut şi sub
numele de vector de intrare;
- wi i  1, n  reprezintă ponderarea intrării i. Această pondere determină efectul pe
care îl are semnalul oferit de intrarea i asupra ieşirii neuronului. Ponderile
reprezintă echivalentul joncţiunilor sinaptice întâlnite la reţelele de neuroni
biologici.
- Neuronul “vede” toate intrările ca o intrare generală (totală) y care este calculată
folosind o funcţie de intrare la care se adaugă o valoare de offset sau bias ( ). În
majoritatea cazurilor, funcţia de intrare utilizată este funcţia sumă ponderată a
tuturor intrărilor xi. Expresia matematică de calcul a intrării generale în acest caz
este dată de relaţia:
n
y  Fin  x      xi wi   . (1)
i 1

Alte tipuri de funcţii folosite ca funcţii de intrare:

5
 - funcţia max{xiwi}, i=1…n,
- funcţia min{xiwi}, i=1…n,
- funcţia (xiwi), i=1…n,
- Funcţia de activare stabileşte activarea neuronului. Din cele prezentate în
paragraful anterior, neuronul biologic poate fi activ (excitat) sau nu. Deci prezintă
o “stare de activare”. La fel şi neuronii artificiali pot să aibă, unii, două stări de
activare (cazul perceptronului binar) sau mai multe stări de activare (cazul
“neuronilor artificiali reali”).
Tipuri de funcţii pentru funcţia de activare (Fa) a neuronului artificial:
- funcţia prag (treaptă unitară simetrică)(Figura 2):

 1 daca y  0
Fa ( y )   (2)
 1 daca y  0

Figura 2. Funcţie de activare prag

- funcţia liniară simetrică cu saturaţie(Figura 3):

 1 daca y  1

Fa ( y )   y daca y  1 (3)
 1 daca y  1


Figura 3. Funcţie de activare liniară

- funcţia sigmoid unipolară (Figura 4):

1
Fa ( y )  (4)
1  ey
Figura 4. Funcţie de activare sigmoid
unipolară
- funcţia sigmoid bipolară (Figura 5):

2
Fa ( y)  1 (5)
1  ey
Figura 5. Funcţie de activare sigmoid
bipolară
- funcţia tangentă hiperbolică (Figura 6):

6
 e y  e y
Fa ( y )  tanh( y )  (6)
e y  ey

Figura 6. Funcţie de activare tangentă

hiperbolică
- a reprezintă activarea (ieşirea) neuronului:
a=Fa(y) (7)
adică valoarea oferită de funcţia de activare.

Exemplul 1:
Listing program “lab11.m”
%-----------------------------------------------------------------
% simularea neuron artificial cu doua intrari si functie de
% activare tip treapta unitara
%-----------------------------------------------------------------

%valorile dorite pentru intrarile neuronului artificial

x=[0 1 0 1 %valori pentru prima intrare
0 0 1 1 %valori pentru a doua intrare
1 1 1 1]; %valori pentru intrarea de offset (compensare)
x=x’;

%vectorul de ponderi
w=[-0.8 %ponderea primei intrari
2 %ponderea celei de-a doua intrari
-0.15]; %ponderea intrarii de offset

for i=1:length(d),
%Calculul intrarii totale pentru fiecare set de intrari
y(i)=x(i,:)*w;

%Calculul activarii neuronului, functie de activare

% tip treapta unitara
a(i)=treapta(y(i)); %definitia acestei functi se regaseste
%mai jos, se editeaza într-un alt
%fisier,independent de cel in care se
%regaseste codul acestui program de
%simulare
end

Listing program “treapta.m”

%-----------------------------------------------------------------
%functia de activare "treapta unitara"
%-----------------------------------------------------------------

function [a]=treapta(y)

for i=1:length(y),
if y(i)>=0, a(i)=1;
else a(i)=0;
end
end
7
a=a';

2.2. Funcţii Matlab

În continuare vor fi prezentate funcţii din toolbox-ul nnet al mediului
Matlab ce vor fi utilizate pentru desfăşuarea lucrării:

- newp – creează un perceptron binar (dacă sunt lăsate valorile implicite);

Apelul funcţiei:
RNA = newp(PR,S,TF,LF)
unde:
PR – matrice de dimensiune Rx2 cu valorile minimă şi maximă pentru R intrări;
S – numărul de perceptroni;
TF – funcţia de activare, implicit = 'hardlim' (treaptă unitară);
LF – funcţia de învăţare, implicit = 'learnp';
RNA – reţeaua neuronală artificială creată, compusă din perceptroni binari.

Exemplul 2:
%-----------------------------------------------------------------
% Crearea unei RNA cu un perceptron binar (functie de activare tip
% treapta unitara) cu 2 intrari, valorile minima si maxima pentru
% intrari este: min=0; max=1.
%-----------------------------------------------------------------

%valorile min si max pentru cele 2 intrari

PR=[0 1 % pt. prima intrare
0 1];% pt. a 2-a intrare

% numarul de neuroni
S=1;

%functia de activare
TF='hardlim';

%functia de invatare
LF='learnp';

rna=newp(PR,S,TF,LF);

Observatii
1. Programul din acest exemplu poate fi redus la ultima linie
setând toate valorile dorite chiar în lista de argumente ale
functiei, fara a se mai apela la variabile suplimentare (valorile
pentru argumentele TF si LF fiind cele implicite pot fi omise din
lista de argumente ale functiei):

rna = newp([0 1;0 1], 1);

2. În exemplu nu sunt setate valorile ponderilor de la intrarile

neuronului creat.

8
- sim – simulează o reţea neuronală artificială creată cu o funcţie Matlab (newlin,
newp, etc.). Va calcula pentru valorile prezentate la intrarea RNA ieşirile
corespunzătoare.

Exemplul 3
%-----------------------------------------------------------------
% Simularea RNA creata cu functia ‘newp’ din exemplul 2
%-----------------------------------------------------------------

% Setarea ponderilor neuronului

%ponderile intrarilor
rna.IW{1,1}=[-0.8 2];

%ponderea pentru intrarea de offset (bias)

rna.b{1}=-0.15;

% valorile dorite pentru intrarile perceptronului

F=[0 1 0 1 %pt. prima intrare
0 0 1 1]; %pt. a doua intrare

sim(rna,F)

În Figura 7 sunt prezentate formele pentru diferite tipuri de funcţii de

activare generate cu funcţii Matlab.

Figura 7. Forme de funcţii de activare generate cu funcţii Matlab

Probleme propuse
1. Ţinând cont de Figura 1 şi utilizând relaţiile matematice (1)(6) să se scrie
un program în limbajul Matlab sau limbajul C pentru crearea şi simularea unei

9
reţele neuronale artificiale cu un singur neuron artificial cu două intrări. Setările
reţelei neuronale sunt:
- ponderile intrărilor: [-0.8 2.0];
- ponderea pentru intrarea de offset: -0.15;
- valorile intrărilor:
- prima intare: 0 1 0 1;
- a doua intrare: 0 0 1 1.

2. Folosind Exemplul 2 şi Exemplul 3 se va crea şi simula, folosind funcţiile

de activare prezentate în Figura 8, o reţea neuronală artificială formată dintr-un
perceptron cu două intrări. Setările reţelei neuronale sunt:
- ponderile intrărilor: [-0.8 2.0];
- ponderea pentru intrarea de offset (bias): -0.15;
- funcţia de activare: ‘hardlim’, ‘hardlims’, ‘logsig’, ‘poslin’,
‘purelin’, ‘satlins’, ‘tansig’;
- valorile intrărilor:
- prima intare: 0 1 0 1;
- a doua intrare: 0 0 1 1.

10
 Lucrarea nr. 2

Perceptronul binar

1. Scopul lucrării
Familiarizarea studenţilor cu structura şi antrenarea perceptronului binar.

2. Noţiuni generale

2.1 Structura generală a perceptronului binar

Structura generală a perceptronului binar este prezentată în Figura 1.

Figura 1. Strucura generală a perceptronului binar

Semnificaţia notaţiilor din Figura 1 este urmăatoarea:
- x1, x2, … , xn – intrările perceptronului binar (valori: 0 sau 1);
- n – numărul de intrări ale perceptronului binar;
- 1, 2, … , n,  – ponderi (echivalentul sinapselor neuronului biologic),
intrarea care prezintă ponderea  poartă numele de intrare de offset (bias);
- y - intrarea generală a perceptronului;
- Fa(y) – funcţia de activare a perceptronului binar, este funcţia treaptă unitară
0 daca y  0
Fa  y    (1)
1 daca y  0
- a– ieşirea perceptronului
a = Fa(y)
(2)
O altă formă de reprezentare (mai compactă) a perceptronului binar este
prezentată în Figura 2.

11
 Figura 2. Forma compactă de reprezentare a perceptronului binar
Scopul antrenării (învăţării) perceptronului binar este de a modifica ponderile
i (i=1n),  în vederea realizării transformării dorită T(.):
T(x, ): {0,1}n  {0,1}
(3)
unde:
- x - reprezintă vectorul intrărilor ,
-  - reprezintă vectorul ponderilor.
În continuare se va prezenta algoritmul general de antrenare a unui
perceptron binar cu n intrări.

2.2 Algoritm de antrenare al perceptronului binar

Pas 1:Se alege numărul de intrări ale perceptronului binar. Se aleg aleator
valorile iniţiale (numere reale) ale elementelor vectorului de ponderi. Se alege o
variabilă e pentru memorarea erorii de învăţare a perceptronului. Fie q numărul
vectorilor de instruire (antrenare) disponibili. Un vector de antrenare reprezintă
cuplul de vectori (x, d), unde x reprezintă vector de intrare iar d ieşirea dorită
corespunzătore vectorului de intrare x. Se utilizează o variabilă contor k şi se
iniţializează k=1, valoarea maximă pe care o poate lua k este valoarea lui q.
Pas 2. Se prezintă perceptronului vectorul de intrare x p şi ieşirea corectă
p
d (ieşirea dorită), unde p reprezintă indicele vectorului în cadrul setului de vectori
de antrenare (1  p  q). Vectorii din cadrul setului de vectori de antrenare pot fi
prezentaţi reţelei neuronale în ordine aleatoare (în acest caz p  k; Ex: primul vector
de antrenare este vectorul <3>, al doilea vector va fi vectorul <q-1>, al treilea va fi
vectorul <1>, ş.a.m.d.). Dacă p = k atunci vectorii de antrenare sunt prezentaţi
reţelei neuronale în ordinea crescătoare a poziţiei lor în setul de vectori de antrenare
(Ex: primul vector de antrenare este vectorul <1>, al doilea vector va fi vectorul
<2>, al treilea va fi vectorul <3>, ş.a.m.d.).
Pas 3. Se calculează intrarea totală a perceptronului:
n
y
p

  wj x j
p p
  p

j 1

(4)
unde:
wj – ponderea de pe intrarea j a neuronului
n – numărul de intrări.
12
 Se calculează ieşirea perceptronului:
p
a  F  y
(5)
unde F(.) este funcţia treaptă unitară.

Pas 4. Se calculează eroarea de învăţare:

p p p
e d a
(6)
Pas 5. Se modifică ponderile perceptronului folosind relaţiile:
w j k  1  w j k    w j 
p
 w j k   e  x j 
p p
 w j k    d a   x p
, j  1, n
  j
(7)
 k  1   k     
  k   e  1 
p p
  k    d a 
 
(8)
Pas 6. Se realizează incrementarea k=k+1
Dacă k  q salt la pasul P2, altfel se continuă cu pasul P7
Pas 7. Dacă eroarea de învăţare pentru toţi vectorii de antrenare are valoarea
0, atunci STOP. În caz contrar, salt la pasul P2.

2.3 Funcţii Matlab

În Lucrarea nr. 1 s-au prezentat funcţiile newp(.) şi sim(.) din toolboxul
nnet al mediului Matlab, în continuare se va prezenta funcţia train(.) din
acelaşi toobox. Această funcţie implementează algoritmul de învăţare al
perceptronului binar prezentat în secţiunea 2.2.

train – antrenează o reţea neuronală;

Apelul funcţiei
[net,tr,Y,E] = train(net,P,T)
unde:
net – reţeaua neuronală ce se doreşte a fi antrenată;
P – matrice/vector cu date de intrare de antrenare;
T – vector cu date de ieşire de antrenare;
tr – o structură cu informaţii din timpul antrenării;
Y – ieşirea calculată de reţeaua neuronală;
E – vector eroare de învăţare;

Exemplul1:
%-----------------------------------------------------------------
% Invaţarea unui perceptron cu 2 intrari sa redea funcţia logică
% ŞI, valorile minima si maxima pentru intrari este: min=0; max=1.
%-----------------------------------------------------------------

13
clear;
clc;
%intrari dorite
%(2 intrari intr-o poarta logica)
x=[0 1 0 1 %valori pentru prima intrare
0 0 1 1]; %valori pentru a doua intrare

%valorile de iesire dorite ale neuronului

%(poarta logica SI)
d=[0 0 0 1];

%vectorul de ponderi
w=[ 0.2 %ponderea primei intrari
1]' %ponderea celei de-a doua intrare
teta=-2.15 %ponderea intrarii de offset

%=========== creare perceptron =============

%valorile min si max pentru cele 2 intrari

domMinMax=[0 1;0 1];

nrPtroni=1;
FA='hardlim';
FInv='learnp';
ptron=newp(domMinMax,nrPtroni,FA,FInv);

%=========== setari perceptron =============

%setare ponderi
ptron.IW{1,1}=w;
ptron.b{1}=teta;
%setare nr. epoci
ptron.trainParam.epoch=100;
%setare valoare eroare de finalizare a invatarii
ptron.trainParam.goal=0;

%========= antrenare perceptron ============

[ptron,tr,a,E] = train(ptron,x,d);
a
E

Probleme propuse

Problema 1. Să se realizeze un program în mediul Matlab pentru antrenarea

unui perceptron binar cu două intrări folosind algoritmul de antrenare a unui
perceptron binar prezentat în secţiunea 2.2. Antrenaţi peceptronul binar având ca şi
date de intrare valorile de intrare ale porţii logice ŞI iar date de ieşire, valorile de
ieşire ale porţii logice ŞI corespunzătoare intrărilor porţii logice. Valorile iniţiale ale
ponderilor:
- ponderile intrărilor: [0.2 1];
- ponderea pentru intrarea de offset (bias): -2.15;
Antrenaţi perceptronul, în mod similar porţii logice ŞI, pentru redarea porţilor
logice SAU, ŞI-NEGAT, SAU-NEGAT, SAU-EXCLUSIV.

Problema 2. Să se rezolve Problema 1 utilizând funcţiile newp(.) şi

train(.) din toolbox-ul nnet al mediului Matlab.

14
 Problema 3. Să se realizeze o reţea neuronală cu perceptroni binari, ajutorul
funcţiilor newp şi train din toolboxul nnet al mediului Matlab, pentru
recunoaşterea literelor A, B, …, Z. Literele se reprezintă pe o matrice 5x8 (Figura 1
şi Figura 2a). Numărul de ieşiri este egal cu nr. de litere care se doresc a fi învăţate.
- ieşirea {1,0,0,…,0} are semnificaţia că sa recunoscut litera A
- ieşirea {0,1,0,…,0} are semnificaţia că sa recunoscut litera B
- ieşirea {0,0,1,…,0} are semnificaţia că sa recunoscut litera C
…
- ieşirea {0,0,…,0,1} are semnificaţia că sa recunoscut litera Z

Figura 1 – Configuraţia reţelei neuronale (24 de iesiri = nr. de litere)

a) b)
Figura 2 – Exemple de litere ale alfabetului reprezentate pe o matrice de 5x8 celule:
a) litere corecte; b) litere eronate

Literele din Figura 2a (care reprezintă setul de vectori de învăţare de intrare)

sunt salvate în fişierul alfabet.mat sub forma matricei ALFABET. Numărul de
coloane este dat de numărul de intrări (40 de elemente). Pe prima linie a acestei
matrice este reprezentată litera A, pe a doua linie litera B, ş.a.m.d.. Vectorii de ieşire
de învăţare se generează cu ajutorul funcţiei eye(.) (corespunzător celor 12 litere
din Figura 2a se generează o matrice identitate de dimensiune 12x12, utilizând
eye(12), ). Prima coloană, acestei matrice reprezintă vectorul de învăţare de
ieşire corespunzător literei A, a doua coloană reprezintă vectorul de învăţare de
ieşire corespunzător literei B, ş.a.m.d..

15
 Setul de ponderi ale intrarilor precum şi al ponderilor de offset se generează
aleator în intervalul [-0.5, 0.5] sau în intervalul [-1,1] folosind funcţia rand(.)
din mediul Matlab.
După finalizarea învăţarii, să se testeze calitatea învăţării folosind mai întâi
caracterele salvate corespunzător Figurii 1 în matricea ALFABET din fişierul
alfabet.mat, apoi se testează reţeaua de perceptroni binari folosind caracterele
salvate corespunzător Figurii 1 în matricea ALFABETERONAT din fişierul
litEronate.mat. Literele eronate sunt reprezentate în Figura 2b.
Să se comenteze rezultatele obţinute.

Funcţii ajutătoare:
- afisareAlfabet(matrice)- afişează toate literele salvate conform
Figurii 1 în liniile matricei matrice (ex. afisareAlfabet(ALFABET) va
afişa toate caracterele din matricea ALFABET);
- afisareLitera(vector) – afişează litera reprezentată conform Figurii 1
in vectorul vector (ex. afisareLitera(ALFABET(2,:)) determină
afişarea literei B);
- square(x,y,latime,inaltime,culoare) – afişează un dreptunghi la
coordonatele (x,y) de dimensiune latime x inaltime şi de culoare
culoare (‘w’-alb,‘r’-roşu). Funcţia este folosită de funcţiile de afişare
afisareAlfabet(.) şi afisareLitera(.).
- ALFABETRECUNOSCUT=generareAlfabetRNA(a_test,ALFABET) –
este folosită pentru a verifica recunoaşterea de către reţeaua de perceptroni
binari a unui set de litere eronate. Funcţia generează literele pe carele recunoaşte
reţeaua neuronală, dacă nu recunoaşte un caracter, linia respectivă a matricei de
ieşire are elementele setate pe zero.

16
 Lucrarea nr. 3

Reţele neuronale artificiale feedforward cu strat ascuns

1. Scopul lucrării
Familiarizarea studenţilor cu structura şi antrenarea reţelelor neuronale
artificiale (RNA) cu strat ascuns.

2. Noţiuni generale

2.1 Structura generală a RNA feedforward multistrat

Din punct de vedere topologic se disting două tipuri de reţele neuronale
artificiale:
- reţele neuronale feedforward
- reţele neuronale recurente
RNA feedforward sau cu propagarea înainte a semnalelor sunt reţele de
neuroni care nu conţin conexiuni inverse, adică conexiuni de la ieşiri către intrările
neuronilor din acelaşi strat sau către intrările unor neuroni din straturile anterioare.
Astfel transmisia de date se face într-un singur sens, de la neuronii din stratul de
intrare spre neuronii din stratul de ieşire. În contrast cu reţelele feedforward, reţelele
neuronale recurente conţin conexiuni inverse de la neuronii din stratul de ieşire la
neuronii din straturile anterioare (conexiuni feedback).
Intr-o RNA feedforvard multistrat neuronii sunt organizaţi pe straturi, astfel
că reţeaua neuronală prezintă următoarele tipuri de straturi:
- un strat de intrare,
- unul sau mai multe straturi ascunse
- un strat de ieşire

Figura 1 Structura generală a unei RNA multistrat feed-forward

Toţi neuronii mai puţin cei din stratul de intrare au ca funcţie de activare o
funcţie care îndeplineşte următoarele condiţii: este continuă, diferenţiabilă,
monotonă şi neliniară. În neuronii din stratul de intrare nu se efectuează nici un fel
de procesare a, ei având rolul de a distribui valoarea de la intrarea lor la intrările
neuronilor din stratul de imediat următor. În continuare se va prezenta algoritmul
iterativ de antrenare a reţelelor neuronale artificiale cu un singur strat ascuns.

17
Regula de învăţare folosită de acest algoritm este cunoscut în literatura de
specialitate sub numele de regula Delta generalizată sau Backpropagation.

2.2 Algoritmul iterativ Backpropagation (Delta generalizată) pentru RNA

cu un singur strat ascuns
Algoritmul de antrenare este pentru o reţea neuronală ai cărei neuroni au ca
funcţie de activare funcţia sigmoid.
P1. Se iniţializează ponderile cu valori subunitare.
Se fixează rata de învăţare (pozitivă).
Fie n numărul vectorilor de instruire disponibili. Se pune p=1.
Se iniţializează eroarea totală E=0.
P2. Se prezintă reţelei vectorul de intrare x p şi ieşirea corectă d p (ieşirea
dorită).
P3. Se calculează ieşirea reţelei:
xi p   wij a j p  i
j
p
ai  F ( xi p )
(1)
P4. Se calculează eroarea pătratică:
1 N0
E p
  (d p  ai p ) 2
2 i 1 i
(2)
P5. Se adaptează vectorul pondere, folosind regula Delta generalizată:
ij ( p  1)  ij ( p )  ij  ij ( p )     a j   i  ,
(3)
unde  i este dat de următoarele relaţii:
ai
 i  di  ai  , i  1, N e , pentru stratul de ieşire
yi
(4)
Ne
a
i  i   j ji , i  1, N h , pentru stratul ascuns
yi j 1
(5)
unde:
- Ne reprezintă numărul de neuroni din stratul de ieşire;
- Nh reprezintă numărul de neuroni din stratul ascuns;
- j este dat de relaţia (4);
a
-  Fa ( y ) este derivata funcţiei de activare a neuronului.
y
P6. Se pune p=p+1; Pentru p < n salt la pasul P2.
P7. Dacă E <  (  este valoarea admisibilă a erorii), atunci STOP. În caz
contrar, salt la pasul P2.

18
 2.3 Funcţii Matlab
Pentru crearea unei reţele neuronale artificiale toolbox-ul nnet al mediului
Matlab oferă funcţia newff al cărei apel este de forma:

rna=newff(x,d,structRNA,{Fa1,Fa2,…,Fan},funcAntr)
unde:
rna – structură ce descrie reţeau neuronală.
x – vetorul/matricea cu date de antrenare de intrare.
d – vectorul/matricea cu date de antrenare de ieşire.
structRNA – este un vector linie care are ca elemente numărul de neuroni pentru
fiecare strat (mai puţin stratul de intrare). De exemplu se doreşte
crearea unei RNA 2 straturi ascunse cu 5 neuroni în primul strat
ascuns 3 în al doilea strat ascuns şi 2 neuroni în stratul de ieşire
atunci structRNA=[5 3 2]. Dacă se doreşte crearea unei RNA
cu un singur strat ascuns si un singur neuron în stratul de ieşire
atunci este de ajuns ca în variabile structRNA să se pună ca
valoare doar numărul de neuroni din stratul ascuns, valoarea 1
pentru numărul de neuroni în stratul de ieşire este valoare implicită.
Fa1,Fa2,…,Fan – reprezintă funcţiile de activare ale neuronilor din straturile
RNA pornind de la primul strat ascuns până la stratul de ieşire.
Valorile pentru aceste variabile sunt nume de funcţii de
activare prezentate în Lucrarea nr.1.
funcAntr – indică regula de învăţare folosită pentru antrenarea RNA. Pentru a
indica regula Delta generalizată se foloseşte funcAntr=’traingd’.
Pentru antrenarea reţelei neuronale creată cu funcţia newff se utilizează
funcţia train prezentată în Lucrarea nr. 2.

Exemplul 1: Antrenarea unei RNA cu un singur strat ascuns în vederea

reproducerii funcţiei XOR. In stratul ascuns sunt 2 neuroni, funcţia de activare a
neuronilor din stratul ascuns este sigmoid unipolara, iar a neuronilor din stratul de
ieşire este funcţia liniară

Programul “lab4_1.m”
%date de intrare de antrenare
x= [-1 1 -1 1;
-1 -1 1 1];
%date de iesire de antrenare
d=[-1 1 1 -1];

%ponderi strat ascuns

w1=[ 0.2 -0.15
-0.7 0.3];
teta1=[ 0.8
-0.1];

%ponderi strat iesire

w2=[0.1 -1];
teta2= 1.2;

%structura RNA:

19
% - 2 neuroni in stratul ascuns
% - 1 neuron in stratul de iesire
% pt. stratul de iesire 'newff' pune automat 1 neuron daca nu este
% specificat nr. de neur. in stratul de iesire

structuraRNA=2;

%creare RNA
% ‘logsig’- functia de activare tip sigmoid unipolara
% ‘purelin’- functia de activare tip liniara
rna=newff(x,d,structuraRNA,{'logsig','purelin'},'traingd');

%setare ponderi RNA

rna.IW{1,1}=w1; %ponderi intrari strat ascuns
rna.b{1}=teta1; %ponderi bias-uri strat ascuns
rna.LW{2,1}=w2; %ponderi strat iesire
rna.b{2}=teta2; %bias strat iesire

%setare nr epoci
rna.trainParam.epochs=1;
e=10^(-3); %epsilon
rna.trainParam.goal = e;
gama=0.25; %rata de invatare
rna.trainParam.lr=gama;

disp('Va rugam sa asteptati, RNA invata!!!')

[rna,tr] = train(rna,x,d);

a=sim(rna,x)
d

Probleme propuse

Problema 1. Să se studieze programul din cadrul exemplului 1. Să se

utilizeze pentru neuronii din stratul ascuns funcţia tangentă hiperbolică (“tansig”).
Să se comenteze rezultatele obţinute.
Problema 2. . Să se utilizeze pentru neuronii din stratul ascuns precum si
pentru cei din stratul de ieşire ale RNA utilizate în cazul problemei 1 funcţia
sigmoid unipolară. Să se specifice modificările necesare pentru ca învăţarea să aibă
loc. Să se comenteze rezultatele obţinute.
Problema 3. Folosind algoritmul Backpropagation prezentat în secţiunea 2.2
să se scrie un program ce realizează antrenarea unei RNA cu 2 neuroni în stratul
ascuns în vederea reproducerii funcţiei XOR. Datele de antrenare, valorile
ponderilor, rata de învăţare şi funcţiile de activare ale neuronilor se consideră cele
utilizate în cadrul exemplului 1.
Problema 4. Să se utilizeze pentru neuronii din stratul ascuns ale RNA
utilizate în cazul Problemei 3 funcţia tangentă hiperbolică. Să se comenteze
rezultatele obţinute.
Problema 5. Utilizând funcţiile din toolbox-ul nnet al mediului Matlab să
se antreneze o RNA cu un strat ascuns, o intrare şi o ieşire. Datele de antrenare de
intrare şi ieşire se regăsesc în fişierul “datePr3.mat” sub numele de x şi d. Valorile
variabilelor x şi d sunt în intervalul [0 , 255]. Se recomandă normalizarea datelor de
antrenare şi test în domeniul [-1,1]. Normalizarea se realizează utilizând relaţia:
20
 xn max  x n min .............................. xr max  xr min
xn  xn min .............................. xr  x r min
( xn max  xn min )  ( xr  xr min )
xn   xn min
( xr max  xr min )
unde:
xn – valoare normalizată, xn  [1,1] ;
xr – valoare reală, x r  [0 , 255] ;
xnmin  1 , xnmax  1 ;
xrmax  0 , xrmax  255 .
După antrenare să se testeze calitatea antrenării RNA pentru diferite valori
impuse ale erorii minime globale de învăţare folosind vectorul cu date de intrare de
învăţare x. Pentru toate cazurile se porneşte de la acelaşi set de valori iniţiale pentru
ponderile RNA. Pentru valoarea 0.001 a erorii maxime globale admise de învăţare
să se testeze calitatea învăţării folosind datele de test: x_test – date de intrare şi
d_test – date de ieşire dorite. Să se comenteze rezultatele obţinute. Să se studieze
calitatea învăţării a RNA pentru diferite valori ale: valorii erorii globale maxime
admisibile, ratei de învăţare.

21
22
 Lucrarea nr. 4

Reţele neuronale artificiale cu funcţii de activare radiale

1 Scopul lucrării
Familiarizarea studenţilor cu structura, proiectarea şi utilizarea reţelelor
neuronale artificiale cu funcţii de activare radiale cunoscute în literatura de
specialitate sub denumirea de reţele neuronale artificiale RBF (Radial Basis
Functions).

2 Noţiuni teoretice

2.1 Structura RNA-RBF

Structura generală a unei RNA-RBF (Figura 1) este asemănătoare cu cea a
unei RNAFF cu trei straturi.

Figura 1. Structura generală a unei RNA-RBF

Acest tip de RNA prezintă următoarele setări:
- funcţia de intrare tip sumă ponderată a neuronilor din stratul ascuns este
înlocuită cu funcţia normă, (de obicei este aleasă norma Euclidiană), a diferenţei
dintre vectorii de intrare şi vectorul pondere corespunzător fiecărui neuron în
parte;
- neuronii din stratul ascuns au ca funcţie de activare o funcţie radială (de obicei
tip gaussian);
- neuronii din stratul de ieşire au ca funcţie de activare funcţia liniară;
În lucrarea de faţă pentru neuronii din stratul ascuns se vor lua în considerare
următoarele tipuri de funcţii de activare:
- tip liniară
Fa ( y )  y (1)
- tip gaussian
y2

Fa ( y)  e 2 2 (2)
unde
1
y  x  i , (3)

23
unde i1 este vectorul de ponderi asociate intrărilor neuronului i din stratul ascuns.
Din relaţia (3) se observă că intrarea totală a fiecărui neuron din stratul
ascuns este funcţia normă. Pentru cazul de faţă se consideră norma euclidiană, adică
1
x   i  ( x1  i11 ) 2  ( x2  i12 ) 2  ...  ( xN  iN
0
1
)20
(4)
unde
- N0 - numărul de neuroni din stratul de intrare;
- x  [ x1 , x2 , ..., x N 0 ]T - vector de intrare;

-  1i  [i11 , i12 , ..., iN1 ]T - vector de ponderi corespunzător neuronului i.

1

Observaţie Dacă în cazul unei probleme date, numărul vectorilor de antrenare nu

este mare, se poate seta numărul de neuroni artificiali din stratul ascuns ca fiind egal
cu numărul vectorilor de antrenare de intrare.

2.2 Algoritmul de antrenare al RNA-RBF

Algoritmul de învăţare (instruire) a RNA-RBF presupune două etape
[Dum1996]:
1. Stabilirea vectorilor de ponderi (vectorii centru) corespunzătoare intrărilor în
neuronii din stratul ascuns precum şi a parametrilor funcţiei de activare radiale,
alese pentru aceşti neuroni. De exemplu, dacă numărul vectorilor de antrenare de
intrare nu este mare, valorile componentelor acestori vectori pot fi atribuite
ponderilor din stratul ascuns. Astfel, valorile componentelor primului vector de
intrare vor fi atribuite ponderilor primului neuron artificial din stratul ascuns,
valorile componentelor celui de-al doilea vector de intrare vor fi atribuite
ponderilor celui de-al doilea neuron artificial din stratul ascuns, s.a.m.d.
2. Determinarea printr-o metodă de învăţare (de ex. regula Delta) a ponderilor
neuronilor din stratul de ieşire.

2.3 Funcţii Matlab

Pentru crearea unei RNA-RBF mediul Matlab oferă două funcţii:
rna = newrbe(x,d,sigma)
rna = newrb(x,d,err_max,sigma)
unde
rna – structură ce descrie reţeau neuronală;
x – vectorul/vectorii de date de intrare de învăţare;
d – vectorul/vectorii de date de ieşire de învăţare;
sigma – dispersia funcţiei de activare tip gaussian;
err_max – eroarea de învăţare maximă admisă, valoare pentru care se consideră
ce RNA asigură un răspunsul acceptabil.
Funcţia newrbe creează o RNA-RBF a cărui număr de neuroni din stratul
ascuns este egal cu numărul de vectori de antreanare.
Funcţia newrb creează iterativ o RNA-RBF. Această funcţie va adăuga câte
un nou neuron în stratul ascuns în fiecare iteraţie. În fiecare iteraţie, pentru vectorul
de date de intrare care generează cea mai mare eroare de învăţare se ataşează un nou
neuron în stratul ascuns. Ponderile din stratul de ieşire sunt actualizate până când

24
eroarea de învăţare are o valoare mai mică decât valoarea maximă admisă (adică
răspunsul reţelei este satisfăcător). Dacă eroarea de învăţare a RNA pentru fiecare
vector de intrare de învăţare este mai mică decât err_max, atunci se consideră
finalizată construcţia RNA-RBF în caz contrar se adaugă un nou neuron pentru
vectorul de intrare de antrenare ce generează cea mai mare eroare. Procedura se
repetă până ce eroarea de învăţare a RNA-RBF pentru toţi vectorii de antrenare este
mai mică decât err_max sau s-a atins numărul maxim de neuroni.
Probleme propuse
Problema 1. Să se creeze şi să se antreneze folosind algoritmul de antrenare
prezentat în secţiunea 2.2, o RNA-RBF pentru a reda comportarea unei porţi logice
XOR cu două intrări. (Sugestii: să se construiască tabelul de adevăr echivalent al
porţii logice XOR folosind valori bipolare (-1 şi 1) în locul valorilor binare (0 şi 1);
să se utilizeze pentru neuronului din stratul de ieşire funcţia de activare liniară cu
limitare).
Problema 2. Utilizând datele de antrenare de intrare şi ieşire din fişierul
“datePr3.mat” să se creeze RNA-RBF cu ajutorul funcţiilor newrbe, newrb. Să
se testeze calitatea învăţării cu ajutorul datelor de test. Să se modifice valoarea
dispersiei funcţiilor de activare gaussiene. Să se interpreteze rezultatele obţinute.

25
26
 Lucrarea nr. 5

Memoria Hopfield discretă

1 Scopul lucrării
Familiarizarea studenţilor cu structura, proiectarea şi utilizarea reţelelor
neuronale tip memorie Hopfield discretă.

2 Noţiuni teoretice

2.1 Arhitectura memoriei Hopfiled discretă

Memoria Hopfield este o reţea neuronală care derivă din clasa memoriilor
asociative bidirecţionale (MAB). În Figura 1 sunt prezentate arhitecturile unei
memorii autoasociative bidirecţionale (MAB autoasociativă) şi a unei memorii
Hopfield discretă.

a) b)
Figura 1 Arhitecturi de memorii asociative: a) arhitectura MAB autoasociativă cu un singur
strat; c) arhitectura memoriei Hopfield
Arhitectura memoriei Hopfield din Figura 1b prezintă următoarele diferenţe faţă de
arhitectura MAB autoasociativă din Figura 1a, şi anume:
- nu necesită prezenţă la nivelul fiecărui neuron a conexiunii inverse, de la ieşire
la intrare;
- prezenţa unei intrări externe Ii ( i  1, n ), ceea ce implică următoarea relaţie
pentru intrarea totală a fiecărui neuron
n
yi   x jij  I i , (1)
j 1
sau în forma vectorială, vectorul cu intrările totale ale neuronilor din stratul ascuns este dat de relaţia

y xI , (2)
unde x este vector (coloană) de date de intrare, I este vectorul (coloană)
intrărilor externe, iar  este matricea de ponderi a cărei relaţie de calcul este
prezentată la sfârşitul acestei secţiuni;
- memoria Hopfield în forma s-a originală memorează vectori binari şi nu
bipolari, ca urmare funcţia de activare va genera valori binare şi este de tipul
funcţiei treaptă modificată conform relaţiei
 1, dacă yi  U i

ai (k  1)  Fa ( yi )  ai (k ), dacă yi  U i ; (3)
 0, dacă yi  U i

- pentru ca matricea de ponderi a memoriei Hopfield să fie calculată cu vectori
bipolari (vectori ce au elementele în mulţimea {-1,1}) ca şi în cazul MAB

27
 autoasociativă atunci vectorii binari de intrare, notaţi cu vi ( i  1, n ), în reţeaua
neuronală vor fi transformaţi în vectori bipolari, notaţi cu xi ( i  1, n ), conform
relaţiei
x i  2  vi 1 , (4)
unde 1 este un vector ce are toate componentele egale cu valoarea 1 iar
dimensiunea vectorului este egală cu dimensiunea lui vi.
Utilizând relaţia (3) şi relaţia de calcul a matricei de ponderi a MAB autoasociativă
relaţia de calcul a matricei de ponderi a unei memorii Hopfield este
N N
  xi x ti   2  vi  1  2  vi  1t , (5)
i 1 i 1
unde elementele de pe diagonala principală a matricei de ponderi au valoarea 0.
2.2 Procesarea în memoria Hopfield
Odată ce matricea de ponderi a fost construită, memoria Hopfield poate fi
folosită pentru a extrage informaţii. Dacă informaţia prezentată la intrarea memoriei
Hopfield este cunoscută doar parţial în avans sau este afectată de zgomot, memoria
este capabilă să completeze informaţia.
Pentru a extrage informaţie dintr-o memorie Hopfield, se efectuează
următorii paşi:
1. Se aplică un vector de date de intrare iniţial pe intrările Ii ( i  1, n ) ale neuronilor
memoriei;
2. Se actualizează ieşirile (se calculează activările) neuronilor;
3. Se propagă informaţia actualizată de la ieşiri spre intrările memoriei;
4. Se repetă paşii 2 şi 3 până când nu vor mai fi modificări în ieşirile memoriei.
Observaţie Intrările Ii se iau în considerare doar o singură data, şi anume, în primul
pas.

Problemă propusă
Utilizând relaţiile (1)(5) să se construiască o memorie Hopfield pentru
memorarea formelor prezentate în Figura 2. Se va considera valoarea 0 pentru toate
pragurile pragurile Ui din relaţia (2).

Figura 2 Forme corecte

După construirea memoriei să se testeze calitatea învăţării folosind formele

din Figura 2 precum şi formele din Figura 3.

Figura 3 Forme afectate de zgomot

28
 Pentru afişarea formelor se va utiliza funcţia afisareGr.m al cărei apel are
forma
afisareGr(vectorForma,nrCeluleLinie,dimX,dimY)
unde
vectorForma – reprezintă forma de intrare dorită, scrisa sub forma unui
vector linie;
nrCeluleLinie – reprezintă numărul de celule pe o linie afişata (pentru cazul

de faţa are valoarea 8, formele sunt reprezentate pe o grilă 8 x 8 celule);

dimX, dimY – reprezintă dipensiunile careului plin sau gol folosit pentru
afişarea formelor (pentru formele din figurile 2 şi 3 s-au
utilizat dimX=dimY=10)
Formele de intrare de antrenare precum şi cele de test (prezentate în figurile 2
şi 3) se regăsesc în fişierul “VectoriAntrenareSiTest.m”

29
30
 Lucrarea nr. 6

Sisteme fuzzy

1 Scopul lucrării
Familiarizarea studenţilor cu structura, proiectarea şi utilizarea sistemelor
fuzzy.

2 Noţiuni teoretice

2.1 Structura generală a unui sistem fuzzy

Structura generală a unui sistem fuzzy cu n intrări şi m ieşiri este prezentată
în Figura 1.

Figura 1 Structura generală a unui sistem fuzzy

Din Figura 1 se observă că un sistem fuzzy este format din patru blocuri
principale: blocul de fuzzyficare, blocul de decizie, baza de reguli şi blocul de
defuzzyficare.
Blocul de fuzzificare este responsabil de transformarea intrărilor crisp în
mulţimi fuzzy.
Baza de reguli conţine setul de reguli lingvistice de forma
DACĂ...ATUNCI... definite pe variabilele lingvistice fuzzy. Ea conţine informaţii
despre universul de discurs al variabilelor precum şi, informaţii despre mulţimile
fuzzy ataşate valorilor lingvistice ale variabilelor fuzzy.
Blocul de decizie este răspunzător de, determinarea influenţei fiecărei legi în
concluzia finală precum, şi de generarea concluziei finale a sistemului fuzzy.
Concluzia finală va fi o valoare fuzzy în cazul în care sistemul fuzzy are o singură
ieşire şi, va fi un vector de valori fuzzy, dacă sistemul fuzzy va avea mai multe
ieşiri (fiecare element al acestui vector va corespunde unei singure ieşiri a
sistemului fuzzy).
Blocul de defuzzificare are rolul de a converti concluzia fuzzy finală într-o
valoare reală (crisp) sau într-un vector de valori reale în funcţie de numărul de ieşiri
pe care le are sistemul fuzzy. În cazul unui regulator fuzzy valoarea/vectorul de
valori crisp obţinută/obţinut va reprezenta comanda/vectorul de comandă pentru
procesul condus.

31
 2.2 Variabile, valori şi reguli lingvistice
Universul de discurs
Intrările sistemul fuzzy sunt notate cu xi ( i  1, n ), unde xi Xi, iar ieşirile sunt
notate cu yj ( j  1, m ), unde yj Yj. Intrările şi ieşirile sunt valori crisp (numere
reale) şi nu mulţimi fuzzy. Mulţimile Xi ( i  1, n ) respectiv Yj ( j  1, m ) reprezintă
domeniile de variaţie pentru variabilele xi respectiv yj. În literatura de specialitate
domeniul de variaţie al unei variabile mai poartă numele de universul de discurs al
variabilei respective. În practică, universul de discurs al unei variabile este
mulţimea numerelor reale dar din considerente tehnice el se restricţionează la
intervale continue finite.
Variabile lingvistice
După cum se va vedea mai târziu, în această secţiune, expertul uman va
utiliza o “descriere lingvistică” a regulilor ce vor forma baza de reguli. Din această
cauză, pentru descrierea intrărilor şi ieşirilor sistemului fuzzy, se vor utiliza
“variabile lingvistice”. O variabilă lingvistică ataşată unei intrări sau ieşiri a
sistemului fuzzy este o descriere simbolică (folosind cuvinte ale limbajului uman) a
ceea ce reprezintă valorile reale variabile în timp ce apar la intrarea/ieşirea
respectivă a sistemului fuzzy.
Pentru descrierea intrării xi a sistemului fuzzy din Figura 1 se va utiliza
variabila lingvistică notată cu ~xi iar, pentru ieşirea yj se va utiliza variabila
lingvistică notată cu ~y j .
Exemplu:
Pentru regulatorul fuzzy, utilizat de un sistem de reglare automată a iluminării pe suprafaţa unui
birou (planul de lucru), s-au ales ca intrări eroarea de reglare, notată cu e, şi variaţia erorii de
reglare, notată cu e. Pentru aceste două intrări sau ataşat variabilele lingvistice ~e = “eroarea de
reglare” şi ~e =“variaţia erorii de reglare”. Ieşirea regulatorului fuzzy este variaţia comenzii u.
~
Pentru ieşire s-a ataşat variabila lingvistică u = “variaţia comenzii”.
Exemplu:
Pentru cazul unui sistem de estimare a preţului unui laptop se consideră intrările: anul de
fabricaţie, notat cu a, şi dotările laptopului, notate cu d. Ieşirea sistemului fuzzy este preţul
laptopului notat cu p. Pentru aceste variabile de intrare/ieşire se pot ataşa variabilele lingvistice:
~
a~ = “anul de fabricaţie”, d = “dotări laptop” şi ~
p = “preţ laptop”.
Valori lingvistice
Simiar cu variabilele crisp xi şi yj, care iau diferite valori din domeniile de
variaţie Xi şi Yj, şi variabilele lingvistice ~xi şi ~y j vor lua diferite “valori lingvistice”
ce vor fi utilizate pentru a descrie caracteristicile variabilelor.
~
Se va nota cu X ik valoarea lingvistică k a variabilei lingvistice ~xi definită pe
domeniul X i . Dacă se consideră că există mai multe valori lingvistice definite pe
X i atunci variabila ~ xi va lua valori din mulţimea de valori lingvistice notată cu:
~ ~
 
X i  X ik : k  1, 2,..., N i ,
unde Ni reprezintă numărul de valori lingvistice ale variabilei lingvistice ~xi .
~
În mod similar pentru variabilele lingvistice de ieşire notaţia Y jl semnifică
valoarea lingvistică l a variabilei lingvistice ~y j definită pe domeniul Yj. Dacă se

32
consideră că există mai multe valori lingvistice definite pe Yj atunci variabila ~y j va
lua valori din mulţimea de valori lingvistice notată cu:
~ ~
Y j  {Y jl : l  1, 2, ..., M j } ,
unde Mj reprezintă numărul de valori lingvistice ale variabilei lingvistice ~y j .
Valorile lingvistice sunt în general termeni descriptivi cum sunt: “mare”,
“mic”, “mediu”, “lung”, “scurt”, “slab”, “pozitiv mediu”, “zero”, “negativ mare”.
Exemplu:
Se presupune că ~
x1 descrie variabila lingvistică “iluminare”. Astfel dacă se ataşează
~ ~ ~
valorile lingvistice X 11 =“slabă”, X 12 =“standard”, X 13 =“mare” atunci ~
x1 va avea valori în
~
~ ~ ~

mulţimea X 1  X 11 , X 12 , X 13 .
Exemplu:
În cazul sistemului fuzzy de estimare a preţului unui laptop considerăm că, lingvistic,
preţul laptopului poate fi caracterizat prin: “mic”, “rezonabil” şi “mare”. Astfel putem ataşa
~ ~ ~
valorile lingvistive: P1 = “mic”, P 2 = “rezonabil” şi P 3 = “mare”. În acest caz variabila
lingvistică ~
~
~ ~ ~

p va avea valori în mulţimea P  P 1 , P 2 , P 3 . În practică, când numărul de valori
lingvistice ataşate unei variabile lingvistice este mic, se preferă notarea intuitivă a acestor valori,
pentru citirea mai uşoară de către expertul uman a tabelelor de reguli. Astfel în cazul acestui
exemplu cele trei valori lingvistice se pot nota: Mi = “mic”, R = “rezonabil” şi Ma = “mare”,
~
astfel mulţimea valorilor lingvistice este: P  Mi, R, Ma .
Reguli lingvistice
“Funcţia” ce leagă intrările de ieşirile sistemului fuzzy este caracterizată de
un set de reguli de tipul condiţie→acţiune sau în forma modus ponens
(DACĂ...ATUNCI...)
DACĂ premiză ATUNCI consecinţă. (1)
De obicei, intrările sistemului fuzzy sunt asociate cu premize, iar ieşirile,
sunt asociate cu consecinţe. Aceste reguli DACĂ...ATUNCI... pot fi reprezentate în
multe forme. În continuare vor fi prezentate doar două forme standard:
- forma “multe-intrări multe-ieşiri” cunoscută în literatura de specialitate sub
denumirea de forma MIMO (Multi-Input Multi-Output)
~ ~ ~
DACĂ ~x1 este X 1j şi ~x2 este X 2k şi ... şi ~xn este X nl
~ ~ ~
ATUNCI ~y1 este Y1 p şi ~y2 este X 2r şi ... şi ~xm este X ms ; (2)
- forma “multe-intrări o singură -ieşire” cunoscută în literatura de
specialitate sub denumirea de forma MISO (Multi-Input Single-Output)
~ ~ ~
DACĂ ~x1 este X 1j şi ~x2 este X 2k şi ... şi ~xn este X nl
~
ATUNCI ~yq este Yq p . (3)

2.3 Proiectarea unui sistem fuzzy

Proiectarea unui sistem fuzzy presupune parcurgerea următorilor paşi:
1. Stabilirea variabilelor (reale) de intrare şi ieşire ale sistemului fuzzy
precum şi a domeniilor de variaţie ale acestora;
2. Ataşarea variabilelor lingvistice de intrare şi ieşire ale sistemului fuzzy;
3. Stabilirea pentru fiecare variabilă lingvistică a numărului de valori
lingvistice;
4. Atasarea la valorile lingvistice ale fiecărei variabile lingistice a funcţiilor
de apartenenţă corespunzătoare;

33
 5. Stabilirea bazei de reguli a sistemului fuzzy;
6. Stabilirea conectorilor lingvistici între termenii lingvistici; stabilrea
operatorilor utilizaţi pentru evaluarea conexiunilor (stabilirea operatorilor
va determina modul de decizie al sistemului fuzzy);
7. Stabilirea metodei de defuzzyficare.

3. Funcţii Matlab
Pentru construirea rapidă a unui sistem fuzzy cu ajutorul toolbox-ului de
logică fuzzy a mediului Matlab se recomandă utilizarea intrefeţelor grafice utlizator
(prescurtare eng.GUI’s). Mediul Matlab oferă cinci unelte primare de tip GUI
utilizate pentru creare, editare şi observare a sistemelor fuzzy. Aceste interfeţe sunt
prezentate în Figura 2.

Figura 2 Cele cinci interfeţe utilizate pentru construirea, editarea şi vizualizarea unui sistem
fuzzy

Pentru a deschide fereastra de editare utilizată la crearea unui sistem fuzzy se

lansează în execuţie în linia de comandă a mediului Matlab comanda fuzzy. În
urma acestei execuţii se deschide fereastra din Figura 3. În această figură sunt
prezentate semnificaţiile diferitelor elemente din interfaţă.

34
 Figura 3 Interfaţa principală a editorului sistemului fuzzy
Interfaţa şi semnificaţia elementelor componente ale editorului funcţiilor de
apartenţă sunt prezentate în Figura 4.

Figira 4 Interfaţa editorului funcţiilor de apartenţă

Interfaţa şi semnificaţia elementelor componente ale editorului funcţiilor de
apartenţă sunt prezentate în Figura 5.

35
 Figura 5 Interfaţa editorului de reguli

Problemă propuse
Să se construiască un sistem fuzzy pentru estimarea preţului unui laptop
având ca intrări anul de fabricaţie, notat cu a, şi dotările laptopului, notate cu d, iar
ca ieşire preţul laptopului notat cu p. Domeniul de variaţie al variabilei a este
intervalul [2005, 2009] unitatea de măsură fiind [an calendaristic], domeniul de
variaţie al variabilei d este intervalul [1,10] unitatea de măsură fiind [puncte].
Domeniul de variaţie al variabilei de ieşire p fiind [500, 4500] unitatea de măsură
fiind [lei]. Valorile lingvistice pentru: variabila a fiind {“vechi”, “actual”, “nou”},
pentru variabila d fiind {“slabe”, “acceptabile”, “bune”} iar pentru variabila p fiind
{“mic”, “mediu”, “mare”}. Să se stabilească şi să se editeze baza de reguli a
sistemului fuzzy. Să se verifice comportarea sistemului pentru diferite forme a
funcţiilor de aparteneţă ataşate valorilor lingvistice ale variabilelor lingvistice de
intrare şi ieşire a sistemului fuzzy lăsând funcţiile de decizie şi de defuzzyficare cele
implicite.

36