Universitatea VALAHIA din TargovişteFacultatea de Inginerie ElectricăSpecializarea Automatica si Informatica Aplicata

PROIECT

Disciplina:Inteligenta artificiala

Student

SpecializareaAutomatica

Anul IV

Detecţia prezenţei feţelor umane în imagini folosind reţele neuronale.

Implementare în MATLAB

2

Cuprins

Retele neuronale.............................................................................................................4Perceptronul Multistrat...................................................................................................5Algoritmul Levenberg-Marquard...................................................................................6Implementarea in Matlab................................................................................................7Coduri sursa ale functiilor necesare detectiei prezentelor fetelor umane in imagine.....8Coduri sursa ale functiilor necesare antrenarii retelei neuronale..................................11Rezultate ale aplicatiei in Mamtlab...............................................................................16Concluzii .......................................................................................................................20Bibliografie....................................................................................................................21

3

Retele neuronale

În ştiinţa inteligenţei artificiale, reţelele neurale caracterizează ansambluri de elemente de procesare simple, puternic interconectate şi operând în paralel, care urmăresc să interacţioneze cu mediul înconjurător într-un mod asemănător creierelor biologice şi care prezintă capacitatea de a învăţa. Nu există o definiţie general acceptată a acestor tipuri de sisteme, dar majoritatea cercetătorilor sunt de acord cu definirea reţelelor artificiale ca reţele de elemente simple puternic interconectate prin intermediul unor legături numite interconexiuni prin care se propagă informaţie numerică.

Originea acestor reţele trebuie căutată în studierea reţelelor bioelectrice din creier formate de neuroni şi sinapsele acestora. Principala trăsătură a acestor reţele este capacitatea de a învăţa pe bază de exemple, folosindu-se de experienţa anterioară pentru a-şi îmbunătăţi performanţele.

Caracteristici

Reţelele neurale artificiale se pot caracteriza pe baza a 3 elemente:

modelul adoptat pentru elementul de procesare individual, structura particulară de interconexiuni (arhitectura) mecanismele de ajustare a legăturilor (algoritmii de învăţare).

Modele ale neuronului artificial

Sunt mai multe criterii de clasificare a modelelor neuronului elementar, ce implică: domeniul de definiţie a semnalelor folosite, natura datelor folosite, tipul funcţiei de activare, prezenţa memoriei. Dar cel mai utilizat model este modelul aditiv.

Arhitecturi

Există numeroase modalităţi de interconectare a neuronilor elementari, dar pot fi identificate două clase de arhitecturi:

cu propagare a informaţiei numai dinspre intrare spre ieşire, reţele de tip feedforward reţele recurente (cu reacţie).

Un dezavantaj al reţelelor neurale îl constituie lipsa teoriei care să precizeze tipul reţelei şi numărul de neuroni elementari, precum şi modalitatea de interconectare. Există câteva tehnici de tip pruning sau de tip learn and grow, dar acestea sunt în intense cercetări.

4

Perceptronul Multistrat

Perceptronul multistrat este o reþea neuronalã cu propagare înainte (.feed-forward.) cu unul sau mai multe straturi ascunse

Un strat de intrare Unul sau mai multe straturi ascunse / intermediare Un strat de iesire

Perceptronul multistrat pemite clasificarea in mai mult de doua clase cu conditia ca aceastea sa fie liniar separabile. Din punct de vedere al arhitecturi, perceptronul multiplu este o retea care contine un nivel de m unitati functionale total conectate cu cele N+1 unitati de intrare.

Ponderile conexiunilor dintre unitatile de intrare si cele funtionale (care sun totodata unitati de iesire pot fi organizate intr-o matrice W, cu M lini si N+1 coloane (pentru a cuprinde si unitatea fictiva asociata pragului unitatilor functionale).

Perceptron multistrat cu 2 straturi ascune

Calcule se realizeazã numai în neuronii din straturile ascunse si din stratul de iesire.Semnalele de intrare sunt propagate înainte succesiv prin straturile relelei.Un strat ascuns îsi ascunde iesirea doritã; cunoscând corespondenta intrare-iesire a retelei

(cutie neagrã), nu se poate deduce care trebuie sa fie iesirea dorita a unui neuron dintr-un strat ascuns.

Retelele neuronale comerciale au de obicei unul sau doua straturi ascunse. Fiecare strat poate contine 10-1000 neuroni.

Retele neuronale experimentale pot avea 3 sau 4 straturi ascunse, cu milioane de neuroni.

5

Algoritmul Levenberg-Marquard

Algoritmul Levenberg-Marquardt este un algoritm de invatare supervizata care a fost proiectat pentru atinge o viteza de antrenare de ordinul doi, fara a fi necesara calcularea matricei Hessiene. Cand functia de performanta are forma unei sume de patrate (caracteristic pt. retelele cu transmitere inainte), atunci matricea Hessiana poate fi aproximata astfel: H = J TJ, iar gradientul poate fi calculat astfel: g = J T e , unde J este matricea Jacobiana care contine primele derivate ale erorilor retelei (adica a functiei de performanta) in raport cu ponderile si deplasarile, iar e este vectorul erorilor retelei. Matricea Jacobiana poate fi calculata printr-o tehnica standard de propagare inversa (care este mult mai putin complicata decat calcularea matricii Hessiene).

Algoritmul Levenberg-Marquardt foloseste aceasta aproximare pt. matricea Hessiana, intr-o recurenta asemanatoare cu metoda Newton:

Cand scalarul μ este zero, aceasta este chiar metoda Newton, folosind matricea Hessiana aproximativa. Cand μ este mare, aceasta devine “gradientul descendent”, cu un pas mic. Metoda Newton este mai rapida si mai precisa in privinta minimului erorii, astfel ca ideea este de a ne deplasa catre metoda lui Newton, cat mai repede posibil. Ca atare, μ este micsorat dupa fiecare pas realizat cu succes (care face o reducere in functia de performanta) si este marit doar, cand in urma pasului, creste functia de performanta. In acest fel, functia de performanta va fi intotdeauna redusa la fiecare iteratie a algoritmului.

In general, la problemele de aproximare a unei functii, pentru retelele care contin pana la cateva sute de ponderi, algoritmul L-M va avea convergenta cea mai rapida. Acest avantaj este observabil in special daca se cere o mare precizie a antrenarii. In multe cazuri, L-M poate obtine o eroare medie patratica mai mica decat oricare alt algoritm. Totusi, pe masura ce numarul ponderilor din retea creste, avantajul lui L-M scade. In plus, performanta lui L-M este relativ slaba in problemele de “recunoastere a formelor”. Cererile de memorie pt.L-M sunt mai mari decat pt. alti algoritmi.

Pentru retele de dimensiuni mici si medii, usual se utilizeaza antrenarea Levenberg-Marquardt, daca se dispune de memorie suficienta. Daca memoria este o problema, atunci exista o varietate de alti algoritmi rapizi. Pentru retele mari se va folosi algoritmii cu gradient conjugat sau propagarea inversa flexibila.

6

Implementarea in MATLAB

Pentru a rula aplicatia se tasteaza in linia de comanda din Matlab comanda rgb_forward(‘nume_imagine.jpp’). Functia rgb_forward, care, la finalul ei va afisa imaginea alaturi de fistogramele RGB si probabilitatea ca imaginea sa contina o fata umana, apeleaza functia img2rgbhist care intoarce un vector continand valorile histogramelor RGB.

Dupa calcularea histogramelor RGB, functia rgb_forward incarca din fisierul rgb_weights matricea w ce contine ponderile neuronilor din reteaua neuronala. Apoi apeleaza functia forward in care este implementata reteaua neuronala de tip perceptron multistrat si in care se calculeaza folosind functia sigmoid iesirea retelei neuronale adica probabilitatea ca imaginea sa contina o fata umana.

Daca iesirea y este mai mare de 0.5 atunci imaginea contine o fata umana altfel.Pentru antrenarea retelei se apeleaza functia rgb_trainall care ca avea parametrii

(N,p,toggle), N find numarul de nivele din histograma, p numarul de noduri din stratul ascuns, iar toggle=0 v-a incepe antrenarea retelei cu valori aleatoare pentru ponderi. Functia rgb_trainall apeleaza img2rgbhist pentru a incarca histograma imaginilor din setul imaginilor de antrenare, apoi apeleaza functia levmar care contine algoritmul Levenberg-Marquard care calculeaza ponderile neuronilor pe baza histogramelor imaginilor din setul de antrenare.

7

Coduri sursa ale functiilor necesare detectiei

prezentelor fetelor umane in imagine

Functia rgb_forward

function [y] = rgb_forward (file_name) % rgb_forward.m % Foloseste histogramele RGB ale imagini pentru a detecta% prezenta fetelor umane in imagini.% Primeste ca parametru de intrare calea unei imagini% si intorce probabilitatea ca imaginea sa contina o fata umana % Ca parametru de iesire intoarce y% y > 0.5 pentru existenta unei fete umane in imagini% y<0.5 pentru lipsa fetelor umane din imagini% Ponderile rezultate in urma antrnari trbuie sa fie % stocate in rgb_weights.mat x = image2rgbhist (file_name, 20);load rgb_weights w;y = forward (x, 1, 20 , w); subplot (3,1,1);imshow(file_name);subplot(3,1,2);bar(x);xlabel('R:1-20 G:21-40 B:41-60');axis([1,60,0,max(x)+0.01]);ylabel('Color frequency')title('RGB histogram')subplot(3,1,3);plot(y, '+');axis([0.5, 1.5, 0, 1]);xlabel(y);

Functia img2rgbhist

function [x] = image2rgbhist (file_name, N) % Calculeaza histograma R,G, B a imagini.% Fiecare histograma are N de nivle.% In vectorul x se memoreaza histogramele in ordinea R,G,B .% Se face o scalare a lui x la sfarsit astfel incat % toate intrarile sa fie intre 0 si 1.% Aceasta scalare est necesara pentru a folosi % vectorul x ca intrare in reteaua neuronala.% Operatia resize_matrix presupune ca imaginea este % de cel putin 50X50 pixeli. % Calculeaza centrul nivelelor histogramei.for i=1:N Bins(i,1) = i/N - 1/(2*N);end; %Factorul de interpolare II = 50;

8

A = double(imread(file_name));B = resize_matrix(A,I,I);B = B/260;[total_rows total_columns three] = size(B); for row = 1:total_rows for column = 1:total_columns v(column+(row-1)*total_columns,1) = B(row,column,1); % R v(column+(row-1)*total_columns,2) = B(row,column,2); % G v(column+(row-1)*total_columns,3) = B(row,column,3); % B end;end; total_hist = hist(v,Bins); hist_R = total_hist(:,1);hist_G = total_hist(:,2);hist_B = total_hist(:,3); x=[hist_R;hist_G;hist_B];x = x / (I^2);

Functia resize_matrix

function [B] = resize_matrix (A, r, c) % Redimensioneaza matricea A legand pixeli.% Matricea B rezultanta va avea r lini si r coloane .% Fiecarea pixel va avea 3 valori: RGB. [rows columns three] = size(A); row_sample = floor (rows/r);column_sample = floor (columns/c); for i=1:r for j=1:c B(i,j,:) = A(i*row_sample, j*column_sample, :);end;end;

Functia forword

function [y] = forward (x, n, p ,w) % forward.m % Calculeaza iesirea pentru elementele de intrare cu ponderile w.% x vectorul corespondent intrarilor% n este numarul de neuroni in stratul de intrare% p numarul de neuroni in stratul ascuns% w vectorul ponderilor% y vectorul corespondent iesirilor m=length(x); xp=[x;1]; tem=w(1:p*(m+1)); W1=reshape(tem,p,m+1); tem=w(p*(m+1)+1:p*(m+1)+n*(p+1)); W2=reshape(tem,n,p+1); a=W1*xp; z=sigmoid(a); zp=[z;1];

9

y=W2*zp;

Functia sigmoid

function s=sigmoid(t)s=1./(1+exp(-t)); % Alternativ% s=(exp(t)-exp(-t))./(exp(t)+exp(-t));

10

Coduri sursa ale functiilor necesare

antrenarii retelei neuronale

Functia rgb_trainall

function [x, outputs] = rgb_trainall(N,p, toggle) % Foloseste pentru antrenare imaginile din directorul images.% Se introduc numele fisierelor din director.% N numarul de nivele din histograma.% P numarul de neuroni din stratul ascuns.% Daca toggle = 0, atunci se porneste cu ponderi initiale aleatoare.% Altfel folosim ca ponderi initiale elementele matricei w din fisierul% rgb_weights.mat warning off; %Rata de invatare lamda.lam = 0.1; %Numarul de iterarii.itMAX = 10; % Imagini cu fete umane: y=1x(:,1) = image2rgbhist ('images/santosa.jpg', N);y(1,1) = 1.0; x(:,2) = image2rgbhist ('images/shen.jpg', N);y(1,2) = 1.0; x(:,3) = image2rgbhist ('images/arthur.jpg', N);y(1,3) = 1.0; x(:,4) = image2rgbhist ('images/banks.jpg', N);y(1,4) = 1.0; x(:,5) = image2rgbhist ('images/carter.jpg', N);y(1,5) = 1.0; x(:,6) = image2rgbhist ('images/matt.jpg', N);y(1,6) = 1.0; x(:,7) = image2rgbhist ('images/donna.jpg', N);y(1,7) = 1.0; x(:,8) = image2rgbhist ('images/friedman.jpg', N);y(1,8) = 1.0; x(:,9) = image2rgbhist ('images/gulliver.jpg', N);y(1,9) = 1.0; x(:,10) = image2rgbhist ('images/park.jpg', N);y(1,10) = 1.0;

11

% Imagini fara fete umane: y=0x(:,11) = image2rgbhist ('images/dusty.jpg', N);y(1,11) = 0.0; x(:,12) = image2rgbhist ('images/feet.jpg', N);y(1,12) = 0.0; x(:,13) = image2rgbhist ('images/toaster.jpg', N);y(1,13) = 0.0; x(:,14) = image2rgbhist ('images/watch.jpg', N);y(1,14) = 0.0; x(:,15) = image2rgbhist ('images/hand.jpg', N);y(1,15) = 0.0; x(:,16) = image2rgbhist ('images/glove.jpg', N);y(1,16) = 0.0; x(:,17) = image2rgbhist ('images/pez.jpg', N);y(1,17) = 0.0; x(:,18) = image2rgbhist ('images/chair.jpg', N);y(1,18) = 0.0; x(:,19) = image2rgbhist ('images/snowglobe.jpg', N);y(1,19) = 0.0; x(:,20) = image2rgbhist ('images/mouse.jpg', N);y(1,20) = 0.0; % Se apeleaza algoritmul Levenberg-Marquad.if toggle == 0 w=0;else load rgb_weights w;end; [w,res] = levmar (x, y, p, w, lam, itMAX);save rgb_weights w; for i=1:20 outputs(i) = forward(x(:,i),1,p,w); overall_res(i) = outputs(i) - y(1,i);end; plot(outputs);title('Network outputs');

Functia levmar

12

function [w, res] = levmar (X, T, p, w0, lam, itMAX) % levmar -- Algoritlum Levenberg-Marquad % Intrari% X vectorul neuronilor de intrare% T vectorul neuronilor de iesire% p numarul de neuroni din stratul ascuns% w0 ponderile initiale% lam rata de invatare initiala% itMAX numarul de iteratii % Iesiri% w ponderile finale% res erorile pentru fiecare iteratie % Calculam numarul de necunoscute: nunk.[m, nex] = size(X);[n, nex] = size(T);nunk = p*(m+1) + n*(p+1); if w0 == 0 w = 3*rand(nunk,1); % ponderile aleatoare.else w = w0;end; % Algoritmul Levenberg-Marquadfor it = 1:itMAX [Etot, Gtot, Jtot, R] = etot (X,T,p,w,1); An = Jtot' * Jtot + lam * eye (nunk, nunk); dw = An \ (Jtot' * reshape(R, n*nex, 1) ); wtst = w - dw; [Etst, Gtot, Junk, R] = etot(X,T,p,wtst,0); if Etst <= Etot w = wtst; lam = lam / 10; else lam = lam * 10; end res(it) = Etot; end

Functia etot

function [Etot,Gtot,Jtot,R]=etot(X,T,p,w,toggle)% Calculeaza eroarea toatala% Etot eroare totala% Gtot gradientul erori totale in funtie de pondere% R matricea rezidurilor, fiecare coloana este vector rezidual% Jtot matricea jacobiana a rezidurilor in funtie de pondere% toggle == 1 calculeaza matricea jacobiana% [m,nex]=size(X); [n,nex]=size(T);

13

Etot=0; Gtot=zeros(size(w)); Jtot=[]; for k=1:nex x=X(:,k); t=T(:,k); [E,G,y,J]=eone(x,t,p,w,toggle); Etot=Etot+E; Gtot=Gtot+G; Jtot=[Jtot;J]; R(:,k)=y-t; end

Functia eone

function [E,G,y,J] = eone(x,t,p,w,toggle)%% Genereaza eroare si gradientul erori data find o % pereche intrare iesire%% x vectorul intrarilor% t vectorul iesirilor tinta% p numarul de neuroni in stratul ascuns% w vectorul ponderilor% y vectorul iesirilor% E scalar pentru norma (t-y)% G gradient de E fata de w% J matricea jacobiana de y fata de w% toggle = 1 -> calculeaza matricea jacobiana% m=length(x); n=length(t); xp=[x;1]; tem=w(1:p*(m+1)); W1=reshape(tem,p,m+1); tem=w(p*(m+1)+1:p*(m+1)+n*(p+1)); W2=reshape(tem,n,p+1); a=W1*xp; z=sigmoid(a); zp=[z;1]; y=W2*zp; E=0.5*norm(t-y)^2; % gradient with respect to W2 del=y-t; tem=del*zp'; g2=reshape(tem,n*(p+1),1); % gradient with respect to W1 q=W2(:,1:p)'*del; tem=(sigmoid(a).*q)*xp'; g1=reshape(tem,p*(m+1),1); G=[g1;g2]; J=[]; if toggle ==1 % jacobian with respect to W2 J2=[]; for l=1:p+1 J2=[J2 zp(l)*eye(n,n)]; end % jacobian with respect to W1

14

J1=[]; for l=1:m+1 J1=[J1 W2(:,1:p).*(ones(n,1)*sigmoid(a'))*xp(l)]; end J=[J1 J2]; end

Rezultate ale aplicatiei in Mamtlab

rgb_forward('oana.jpg')

15

y = 0.8651

rgb_forward('obama1.jpeg')

y = 0.6422

rgb_forward('papusa.jpg')

y = 0.6899

16

rgb_forward('nietzsche.jpg')

y = 0.3210

rgb_forward('basescu.jpg')

y = 0.5074

17

rgb_forward('cana.jpg')

y = -1.5489

rgb_forward('tricicleta.jpg')

18

y = -0.5937

Concluzii

19

Pentru aplicatiile de detectie cheia nu este reteaua neuronala folosita si preprocesarea datelor. Detectia este o problema de clasificare deci poate fi folosita orice retea neuronala adecvata problemelor de clasificare. Preprocesarea datelor joaca insa un rol definitoriu in aplicatiile de detectie.

De exemplu pentru o aplicatie de detectie a intrusilor cuntificarea actiunilor utilizatorul neautorizat respectiv utilizatorului autorizat permite retelei sa clasifice utilizatori in intrusi respectiv autorizati si deci sa detecteze intrusi.

Pentru aplicatia de fata preprocesarea imaginilor joaca un rol esential, fara crearea unui model pe baza histogramelor RGB a imaginilor care contin fete umane reteaua nu poate clasifica imaginea ca avand fete umane sau nu si deci nu poate detecta prezenta unei fete umane. Folosind histogramele RGB se creaza un model bazat pe tonurile de culoare ale fetelor umane, model care este folosit pentru detectia imaginilor care contine fete umane.

Bibliografie

20

1. http://ro.wikipedia.org/wiki/Retea_neuronala 2. http://eureka.cs.tuiasi.ro/~fleon/Curs_IA/IA11_RN1.pdf3. http://web.info.uvt.ro/~dzaharie/cursnn3-4.pdf4. http://www.math.umn.edu/~wittman/faces/main.html5. http://www.mrm.ugal.ro/Balan_site/E-books/MIASSM-pdf/Cap.1.pdf

21