CATEDRA DE CALCULATOARE

IMPLEMENTAREA REELELOR NEURONALE FOLOSIND TEHNOLOGIA FPGA

Student: Popa Bogdan gr. 30232 ndrumtor: prof.dr.ing. Baruch Zoltan Francisc

Cuprins
1. Rezumat .................................................................................................................................................... 1 2. Introducere ............................................................................................................................................... 2 2.1. Conceptul de retea neuronala artificiala ........................................................................................ 2 2.2. Retele neuronale pe FPGA ................................................................................................................. 2 3. Fundamentare teoretica ........................................................................................................................... 3 3.1. Neuronul artificial .............................................................................................................................. 3 3.2. Arhitectura unei retele neuronale ..................................................................................................... 4 3.3. Algoritmul de invatare ....................................................................................................................... 5 3.4. Modelarea functiei XOR ..................................................................................................................... 6 4. Proiectare si implementare....................................................................................................................... 6 4.1. Proiectarea sistemului ....................................................................................................................... 6 4.2. Structura unui neuron........................................................................................................................ 7 4.3. Interfata utilizator .............................................................................................................................. 9 5. Rezultate experimentale ......................................................................................................................... 10 6. Concluzii .................................................................................................................................................. 11 Bibliografie .................................................................................................................................................. 12 Anexa A ....................................................................................................................................................... 13

1. Rezumat
Retelele neuronale reprezinta un subiect de actualitate in inteligenta artificiala, datorita spectrului larg de aplicatii la care se preteaza si potentialului mare (si inca incomplet exploatat) pe care il prezinta. Datorita structurii paralele a unei astfel de retele, am incercat o implementare pe FPGA, un astfel de dispozitiv fiind indicat pentru calculul paralel. Cel mai important factor de luat in vedere a fost precizia unei astfel de implementari, aceasta decizie afectand in mod direct performantele de timp si spatiu ocupat. Pe langa limbajul VHDL standard, am utilizat o biblioteca care permite calcule in virgula fixa, acesta fiind modul de reprezentare ales pentru valorile numerice utilizate. Pentru testare, am folosit o placa Digilent Nexys 3. Proiectul implementat simuleaza problema XOR, foarte cunoscuta in lumea retelelor neuronale.

2. Introducere
2.1. Conceptul de retea neuronala artificiala
O retea neuronala este un model computational, de inspiratie biologica, alcatuit din mai multe elemente de procesare interconectate dupa o anumita arhitectura, care functioneaza in paralel. Elementele de procesare se numesc neuroni artificiali. Reteaua contine unul sau mai multe straturi de elemente de procesare, in functie de topologia aleasa. Caracteristica retelelor neuronale care le diferentiaza de alte sisteme de calcul paralel este capacitatea acestora de a de a invata si de a se adapta mediului inconjurator, folosindu-se de experienta anterioara pentru a-si imbunatati performantele. Aceasta caracteristica le incadreaza in zona inteligentei artificiale. Dintre aplicatiile unde retelele neuronale sunt folosite cu succes, amintim: aproximarea functiilor, recunoastere de forme, predictoare, simulatoare si memorii asociative.

2.2. Retele neuronale pe FPGA

Proiectul de fata se doreste a fi o comparatie in termeni de cost si eficienta cu o implementare experimentala de retele neuronale care foloseste aplicatia FloPoCo si formatul de reprezentare in virgula mobila. Ambele implementari exploateaza paralelismul descrierilor hardware concurente, o astfel de abordare fiind mult mai eficienta decat una software, in care operatiile se executa secvential. Castigul este unul real din punct de vedere al timpului mai ales cand se pune problema antrenarii unei retele neuronale. Aceasta are nevoie de seturi mari de date pentru a atinge rata de precizie necesara aplicatiei respective, iar aplicarea unui algoritm de invatare este, in acest caz, realmente costisitoare. Printr-o implementare paralela, acest timp se poate reduce de la cateva ore pana la cateva minute sau chiar secunde, daca luam in considerare faptul ca durata rularii unui set de date pentru antrenare este de ordinul microsecundelor(cateva sute de cicluri de ceas).
2

Din considerente de spatiu, reteaua implementata are in componenta trei neuroni si simuleaza implementarea functiei XOR. Aceasta este o problema des intalnita in literatura de specialitate, deoarece functia XOR prezinta cateva particularitati(detaliate in capitolul 3) care nu permit implementarea ei folosind un singur neuron, cum este cazul functiilor AND, OR, NOR si NAND. Totodata, o privire strict teoretica asupra retelelor neuronale poate fi consultata tot in capitolul urmator, iar alte detalii referitoare la metodele de implementare se gasesc in capitolele 4 si 5.

3. Fundamentare teoretica
3.1. Neuronul artificial
Fiecare element de procesare din cadrul unei retele abstractizeaza functionarea unui neuron biologic. Neuronii artificiali pot avea una sau mai multe intrari si o singura iesire, calculata in functie de valorile intrarilor primite. Fiecare intrare are atribuita o valoare numerica drept pondere. Optional, se poate atasa inca o intrare, cu valoare constanta egala cu 1 si pondere variabila, numita bias. Totodata, neuronul este caracterizat de o functie de activare f(x) = y, unde x reprezinta suma valorilor de la intrare inmultite cu ponderile corespunzatoare intrarii respective. Functia de activare este aleasa in corespondenta cu aplicatia unde va fi folosita reteaua. De exemplu, pentru aproximarea functiilor, foarte des intalnita este functia sigmoid:

( )
Alte functii folosite: tan-sigmoid, functia treapta(Heaviside), etc. Pentru neuronii aflati pe ultimul strat al unei retele, se poate folosi si f(x) = x (functie liniara). Figura 1 ilustreaza structura unui neuron artificial.

Legenda: pi - valorile de intrare wi - ponderile intrarilor - bloc de calcul al sumei ponderate x - rezultatul sumei ponderate (x) - functia de activare y - valoarea iesirii

Fig. 1 - Structura unui neuron artificial

3.2. Arhitectura unei retele neuronale

Retelele neuronale sunt formate prin interconectarea elementelor de procesare dupa anumite reguli. Se formeaza astfel o retea de calcul paralel. In functie de topologia aleasa, retelele pot fi: unistratificate, pluristratificate sau pot prezenta o topologie speciala(cum este cazul retelelor circulare, folosite pentru implementarea memoriilor asociative). Fluxul de date parcurge reteaua de la intrari spre iesiri, strat cu strat. Neuronii de pe acelasi strat sunt parcursi simultan. Nu exista interconexiuni intre neuronii aflati pe acelasi strat, ci doar intre straturi. Intrarile retelei reprezinta intrarile primului strat, apoi iesirile acestuia reprezinta intrarile stratului urmator s.a.m.d., iesirile ultimului strat fiind chiar iesirile retelei. Figura 2 prezinta o astfel de arhitectura.

Fig. 2 - Arhitectura unei retele neuronale

Intrari

Strat 1

Strat 2

3.3. Algoritmul de invatare

Capacitatea de invatare a retelei consta in posibilitatea fiecarui neuron de a-si modifica ponderile wi ale intrarilor, intarind sau slabind astfel legatura cu neuronul precedent, asemenea retelelor neuronale biologice la nivel sinaptic. Spre deosebire de acestea din urma, unde procesul de invatare este continuu, asupra retelelor neuronale artificiale se aplica algoritmul de invatare pana cand rezultatele obtinute sunt satisfacatoare din punct de vedere al corectitudinii si preciziei rezultatului. In urma invatarii, reteaua este pregatita pentru un nou set necunoscut de date. Metoda de invatare trebuie aleasa in concordanta cu aplicatia unde este folosita reteaua neuronala. De exemplu, metoda invatarii nesupervizate este indicata daca reteaua este folosita pentru a incadra entitati sau obiecte in diferite categorii, initial necunoscute, in functie de anumite proprietati comune (asanumitele clusters). Metoda invatarii supervizate pentru retele neuronale are la baza algoritmul backpropagation. Cunoscandu-se datele de intrare si datele asteptate de iesire, se parcurge reteaua de la intrari spre iesiri, apoi se compara datele de iesire obtinute cu cele asteptate, se calculeaza eroarea, care apoi se propaga succesiv, din strat in strat si tinand cont de ponderi, de la iesire spre intrari, corectand ponderile fiecarui neuron in parte dupa o formula matematica cunoscuta. Dupa rularea unui numar suficient de mare de seturi de date, reteaua obtine o performanta satisfacatoare si poate fi folosita si pe un nou vector de intrare necunoscut.
5

3.4. Modelarea functiei XOR

Din reprezentarea functiei AND ilustrata in Figura 3a, se observa ca intreg spatiul de reprezentare este impartit in doua semiplane, acestea reprezentand valoarea de iesire a functiei, 0 sau 1. O astfel de functie poate fi modelata si de un sigur neuron artificial.

Fig. 3a - Graficul functiei AND

Fig. 3b - Graficul functiei XOR

In contrast cu aceasta, functia XOR apare alcatuita din 3 semiplane, de aceea nu poate fi modelata folosind un singur neuron. In acest sens, se pot folosi 3 neuroni, rezultand XOR prin compunerea functiilor AND si NOR sau OR si NAND.

4. Proiectare si implementare
4.1. Proiectarea sistemului
Dupa cum este precizat in Introducere, scopul proiectului este de a compara cele doua metode de implementare a retelelor neuronale, cea in virgula mobila, folosind aplicatia FloPoCo, si cea in virgula fixa, folosind biblioteca ieee_proposed. Reteaua urmeaza a fi folosita pentru aproximarea unor functii de patru variabile, de aceea arhitectura aleasa este 4-8-1. Referitor la precizia folosita, implementarea in virgula mobila este pe 32 de biti, iar cea in virgula fixa pe 16 biti (1 bit de semn, 7 biti partea intreaga, 8 biti partea fractionara). Totusi, din cauza capacitatii limitate a placii Nexys 3, arhitectura a fost redusa la 2-2-1, fara posibilitate de antrenare (ponderile sunt specificate in codul VHDL). Functia
6

modelata este XOR.Ponderile atribuite fiecarei intrari si bias-urile au fost obtinute utilizandu-se Matlab, care permite simularea si antrenarea diferitelor modele de retele. Arhitectura este prezentata in Figura 4.

Fig. 4 - Arhitectura retelei implementate (functia XOR)

4.2. Structura unui neuron

Fiecare neuron (Figura 5) are doua intrari si o iesire, toate pe cate 16 biti. Functia de activare folosita este sigmoid, prezentata in capitolul 3. Blocurile care intra in componenta unui neuron sunt: 2 inmultitoare (mul) 3 sumatoare (add) 1 impartitor (div) 1 bloc pentru calcului lui e-x (exp)

Componenta mul realizeaza produsul a doua numere cu semn, pe cate 16 biti, reprezentate in complement fata de 2,iar rezultatul este returnat tot pe 16 biti, trunchiindu-se produsul real, pe 32 de biti. Din aceasta cauza, componenta mul se poate folosi doar pentru calcule cu numere mici, nerespectarea acestei prevederi dand nastere unor erori de calcul. Rezultatul returnat este tot un numar cu semn, in complement fata de 2. Pentru implementarea efectiva a operatiei de

inmultire, se foloseste biblioteca ieee_proposed, care permite folosirea tipului de date sfixed, ce suporta numerosi operatori matematici:+,-,*,/, modul, etc. Componenta add calculeaza suma a doua numere cu semn, pe cate 16 biti, reprezentate in complement fata de 2, rezultatul fiind trunchiat de la 17 biti la 16. Restrictia pentru numere mari se aplica si in cazul componentei add. Asemanator lui mul este realizata componenta div, care realizeaza impartirea a doua numere in virgula fixa. Din nou, se foloseste biblioteca ieee_proposed. Conventia de dimensiune se mentine, rezultatul fiind tot pe 16 biti. Componenta exp este implementata sub forma unui sistem multi-cycle. Daca semnalul rst este 1 logic, intrarea x este memorata in registrul de deplasare (dupa executarea unor procesari prealabile - complementare fata de 2, daca este cazul), se reseteaza contorul de stare si registrul acumulator se initializeaza cu valoarea 1 in virgula fixa. Valoarea functiei e-x se calculeaza secvential, descompunand bit cu bit exponentul. Daca valoarea ultimului bit din registrul de deplasare este 1, trebuie efectuata inmultire. Din memoria componentei, se extrage valoarea corespunzatoare indicelui la care s-a ajuns. In functie de semnul numarului x, se alege intre valoarea furnizata de memoria de valori pozitive (x este numar pozitiv), respectiv valori negative (x este numar negativ), apoi se efectueaza inmultirea intre registrul acumulator si valoarea extrasa. In continuare, se deplaseaza registrul la dreapta si se incrementeaza contorul de stare. Daca ultimul bit al registrului de deplasare este 0, nu se efectueaza inmultire, ci numai deplasare la dreapta. Executia se termina dupa 15 pasi, adica dupa ce au fost parcursi toti bitii din registrul de deplasare, mai putin bitul de semn. Rezultatul obtinut este cel din registrul acumulator. Schema bloc a componentei exp poate fi consultata in Anexa A. Pentru imbunatatirea rezultatelor, s-au introdus registre pipeline intre toate componentele elementelor de procesare.Acestea sunt ilustrate in Figura 5.

Fig. 5 - Structura unui element de procesare implementat Nota:liniile punctate separa etajele de pipeline

4.3. Interfata utilizator

Pentru a facilita comunicarea cu utlizatorul, sistemul este prevazut cu un controller UART, implementat in modulul principal, care permite citirea si scrierea registrilor de intrare p1 si p2, precum si citirea iesirii z. Sistemul functioneaza la o rata de transfer de 19200 baud, data fiind frecventa de ceas a placii Nexys 3 de 100MHz. Acesta este construit sub forma unui automat de stari finite, putand fi controlat de catre utilizator cu ajutorul aplicatiilor tip hiperterminal. Pentru a afisa continutul registrului de intrare p1, se utilizeaza tasta h. Imediat, se va afisa starea acestuia. pentru modificarea valorii lui p1, se utilizeaza tasta y, care asteapta patru caractere in hexazecimal, pentru a fi memorate in registrul respectiv. La introducerea unui caracter gresit, se scrie valoarea f pe pozitia respectiva. La fel se procedeaza si cu registrul p2, dar folosind tastele u pentru scriere, respectiv j pentru citire. In final, pentru citirea rezultatului, se apasa tasta q.

5. Rezultate experimentale
Implementarea a fost realizata cu succes folosind mediul de dezvoltare al firmei Xilinx, ISE Project Navigator, versiunea 13.4, in limbajul VHDL. Simularea diferitelor module, inclusiv a intregului proiect, a fost facuta in iSim, versiunea 13.4, folosind bancuri de test generate si configurate in acelasi mediu de dezvoltare. Placa FPGA folosita, Digilent Nexys 3, face parte din familia Xilinx Spartan-6, care dispune de facilitati de comunicare UART cu ajutorul unui cablu USB - Micro USB. Frecventa ceasului propriu este de 100 MHz. Proiectul foloseste direct Mai intai, am testat fiecare neuron in simulator, pentru a verifica daca functiile de activare sunt corecte. Valorile actuale ale ponderilor si bias-ului pentru neuronul N1 indica faptul ca el modeleaza functia AND, in vreme ce neuronii N2 si Nf modeleaza functia NOR. Prin compunerea acestor trei neuroni, rezulta functia XOR. Apoi a urmat simularea intregului sistem, folosind un banc de proba. Cu ajutorul acestuia, se atribuie diferite valori succesive vectorilor de intrare p1 si p2, acestea fiind mentinute o perioada de cel putin 25 de semnale de ceas, pentru a parcurge intreg sistemul de la intrare spre iesiri. Simularea intregii retele - in iSim, ilustrata in Figura 6:

Fig. 6 - Simularea retelei

Testarea efectiva a retelei s-a realizat folosind aplicatia tip hiperterminal PuTTY. Parametrii de comunicare cu placa FPGA se specifica manual (19200 baud, 8 biti de date, fara paritate, fara control al fluxului de date). Rezultatele obtinute au fost corecte matematic si in concordanta cu cele obtinute prin simulare.
10

6. Concluzii
Sistemul prezentat rezolva problema XOR a retelelor neuronale, folosind o implementare hardware in virgula fixa, folosind o biblioteca predefinita de operatori matematici. Per total, sistemul ocupa o mare parte din placa de dezvoltare Nexys 3, motiv pentru care designul initial a si fost redus la 3 neuroni. Folosirea numerelor in virgula fixa, desi pare mai naturala decat reprezentarea in virgula mobila, prezinta cateva dezavantaje importante. In primul rand, precizia operatiilor este scazuta, in primul rand din cauza trunchierilor efectuate de-a lungul executiei, pentru a mentine datele in limita a 16 biti. In al doilea rand, folosirea numerelor in virgula mobila ar asigura un numar constant de biti, indiferent de operatia efectuata, nefiind necesare trunchieri. Totodata, ar elimina constrangerile de functionare pentru numere mari, nemaiexistand riscul aparitiei erorilor aritmetice aberante. Implementarea unei retele neuronale cere, inainte de toate, precizie de calcul cel putin medie, daca nu chiar ridicata, pe un interval numeric mare. Un astfel de obiectiv este foarte greu de atins folosind numere in virgula fixa, dar pare tangibil folosind virgula mobila. Pentru realizarea unei retele competitive, este necesar un compromis intre precizie si numarul de neuroni din sistem, iar aceasta proportie castigatoare nu poate fi determinata decat experimental. De aici, apare dorinta continuarii proiectului, si anume realizarea unui generator dinamic si modular de retele neuronale, care ar permite o usurinta de testare si reconfigurare asemanatoare sistemelor software, dar care ar invinge net in competitia de viteza datorita implementarii paralele in hardware, obtinuta folosind tehnologia FPGA.

11

Bibliografie
[1] de Dinechin, F., FloPoCo User Manual, INRIA FloPoCo Project, 2012, http://flopoco.gforge.inria.fr/flopoco_user_manual.html [2] Baruch, Z.F.,Structura sistemelor de calcul, Editura Albastra, Cluj-Napoca, 2004 [3] Bernacki,M.,Wodarczyk,P., Principles of training multi-layer neural network using backpropagation, Virtual Laboratory of Artificial Intelligence, 2004, http://galaxy.agh.edu.pl/~vlsi/AI/backp_t_en/backprop.html [4] Bishop,D.,Kodak,E., Fixed- and floating-point packages for VHDL 2005, in Design & Verification Conference & Exhibition(DVCon), 2003

12

Anexa A
Schema bloc a componentei exp

13