Universitatea VALAHIA din Targovite Facultatea de Inginerie Electric Specializarea Automatica si Informatica Aplicata

PROIECT
Disciplina: Inteligenta artificiala
Student

Specializarea Automatica Anul IV

Detecia prezenei feelor umane n imagini folosind reele neuronale.

Implementare n MATLAB

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

Retele neuronale

n tiina inteligenei artificiale, reelele neurale caracterizeaz ansambluri de elemente de procesare simple, puternic interconectate i opernd n paralel, care urmresc s interacioneze cu mediul nconjurtor ntr-un mod asemntor creierelor biologice i care prezint capacitatea de a nva. Nu exist o definiie general acceptat a acestor tipuri de sisteme, dar majoritatea cercettorilor sunt de acord cu definirea reelelor artificiale ca reele de elemente simple puternic interconectate prin intermediul unor legturi numite interconexiuni prin care se propag informaie numeric. Originea acestor reele trebuie cutat n studierea reelelor bioelectrice din creier formate de neuroni i sinapsele acestora. Principala trstur a acestor reele este capacitatea de a nva pe baz de exemple, folosindu-se de experiena anterioar pentru a-i mbunti performanele. Caracteristici Reelele 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 legturilor (algoritmii de nvare). Modele ale neuronului artificial

Sunt mai multe criterii de clasificare a modelelor neuronului elementar, ce implic: domeniul de definiie a semnalelor folosite, natura datelor folosite, tipul funciei de activare, prezena memoriei. Dar cel mai utilizat model este modelul aditiv. Arhitecturi Exist numeroase modaliti de interconectare a neuronilor elementari, dar pot fi identificate dou clase de arhitecturi:

cu propagare a informaiei numai dinspre intrare spre ieire, reele de tip feedforward reele recurente (cu reacie).

Un dezavantaj al reelelor neurale l constituie lipsa teoriei care s precizeze tipul reelei i numrul de neuroni elementari, precum i modalitatea de interconectare. Exist cteva tehnici de tip pruning sau de tip learn and grow, dar acestea sunt n intense cercetri.

Perceptronul Multistrat
Perceptronul multistrat este o reea 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; cunoscnd 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.

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, intro 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.

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.

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 I I = 50;

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); v(column+(row-1)*total_columns,2) = B(row,column,2); v(column+(row-1)*total_columns,3) = B(row,column,3); 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);

% R % G % B

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];

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=1 x(:,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=0 x(:,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); else w = w0; end; % ponderile aleatoare.

% Algoritmul Levenberg-Marquad for 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. 2. 3. 4. 5.

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

21