LUCRARE DE LABORATOR NR. 5 x2k16kp

SIMULAREA SOFTWARE
A RETELELOR NEURONALE MLP ( II ) 1. SCOPUL LUCRARII
In aceasta lucrare se studiaza o retea neuronala multi-layer perceptron ( MLP ), antrenata pentru recunoasterea de forme, care are intrari analogice. Reteaua este antrenata cu sabloanele salvate intr-un fisier text, dupa care ea este testata cu date de intrare noi, diferite de cele pe care le-a invatat. De asemenea, se studiaza caracteristicile generale ale simulatoarelor de retele neuronale.

2. BREVIAR TEORETIC
In general, o retea neuronala poate fi implementata in trei moduri distincte:
-simulata soft, pe un calculator secvential
-simulata soft pe un calculator paralel (un sistem cu mai multe procesoare)
-implementata hard
In privinta utilizarii simulatoarelor, pentru rezolvarea unei aplicatii concrete, trebuie avute in vedere urmatoarele aspecte:
-Alegerea tipului de retea neuronala
Majoritatea retelelor neuronale utilizate practic sunt de tipul perceptron multistrat ( MLP ) si utilizeaza algoritmul de backpropagation pentru invatare. Algoritmul de backpropagation foloseste eroarea intre iesirile actuale (rezultate prin calcul, propagand inainte valorile de pe intrari, specificate de sabloane) si iesirile asteptate (cele impuse de sablonul curent), pentru a ajusta fiecare pondere. Ajustarea ponderilor se face secvential, plecand de la ultimul strat (cel de iesire), spre primul strat (cel de intrare).
-Alegerea intrarilor (numarul si tipul lor)
In general alegerea intrarilor este o problema dificila. Iesirile retelei sunt mai clar impuse de problema concreta analizata, pe cand intrarile nu. O regula empirica de alegere a intrarilor este urmatoarea: "cu cat mai multe date, cu atat mai bine!" Aceasta regula se aplica atat la numarul intrarilor unei retele, ca si la numarul sabloanelor de antrenare.
Intrarile suplimentare nu afecteaza acuratetea rezultatelor furnizate de retea in problema concreta rezolvata, chiar daca anumite intrari se dovedesc a fi neimportante in determinarea iesirii corecte. Totusi, toate simulatoarele au o limita superioara de neuroni pe care-i suporta, si deci si de intrari.
Trebuie ca atunci cand se strang date si se definesc intrarile retelei, sa nu se furnizeze retelei 2 vectori similari de intrari, care sa dea la iesire rezultate conflictuale. Spre exemplu, o retea ce recunoaste diverse fructe, ar putea sa identifice "mar" sau "pruna" (deci conflictual), bazat pe intrarile "rotund" si "rosu". Pentru a rezolva conflictul, trebuie introduse intrari aditionale ( marime, gust, etc.).
La fel de importanta ca si strangerea unui numar suficient de date de intrare este si modalitatea de prezentare a acestora, retelei. Marea majoritate a simulatoarelor existente accepta intrari ce variaza intre 0 si 1, sau intre -1 si +1. De aceea, datele reale trebuie sa fie preprocesate pentru a fi aduse in aceasta gama. Cele mai multe simulatoare realizeaza chiar ele aceasta preprocesare. Modul cum se aleg intrarile semnificative pentru retea si modul de setare al parametrilor in simulator, au drept rezultat obtinerea unei retele neuronale performante sau nu.
Se pot utiliza 2 tipuri de baza pentru intrari in retele neuronale:
-intrari booleene (de tipul TRUE/FALSE)
Astfel, pentru o imagine alb-negru ce trebuie recunoscuta de retea, intrarile ( “0” - pixel alb, “1” - pixel negru ) sunt de tip boolean. Aceste intrari se mai cheama si intrari binare.
-intrari analogice sunt cele care iau valori continue intre o valoare minima si una maxima. De exemplu, intre 0 si 1. Pentru datele de pe intrari de tip analogic, se recomanda ca gama lor de variatie sa nu fie prea mare (diferenta intre valoarea maxima asteptata si valoarea minima asteptata). In acest scop, daca o intrare analogica are o plaja mare de valori, poate fi eventual inlocuita cu o alta intrare ce foloseste diferenta intre valoarea analogica curenta si cea anterioara. In acest fel, aplicand diferenta, gama scade.
Cele mai multe retele ce rezolva probleme reale au atat intrari binare cat si intrari analogice. Tipul de intrare folosit (binara sau analogica) poate afecta performantele retelei.
Numarul de intrari corespunde numarului de neuroni din stratul de intrare.
-Alegerea iesirilor
In general, numarul iesirilor este direct impus de aplicatie. Sunt necesari un numar de neuroni de iesire egal cu numarul de clase distincte pe care trebuie sa le recunoasca reteaua. De exemplu, o retea neuronala care trebuie sa recunoasca cifrele zecimale, va avea la iesire 10 neuroni. O retea ce trebuie sa recunoasca literele mari ale alfabetului, la iesire va avea 27 de neuroni.
Unele din regulile ce se aplica intrarilor, se aplica si pentru iesiri. De exemplu, o retea neuronala ce face o predictie asupra rezultatului unui joc sportiv, ofera rezultate mai bune daca la iesiri nu se asteapta valoarea absoluta a scorului, ci un rezultat de tipul invingator / egal / invins.
-Alegerea numarului de strate ascunse si a numarului de neuroni din ele
O alta decizie care trebuie facuta in proiectarea unei retele neuronale pentru o aplicatie concreta, este alegerea numarului de straturi ascunse si alegerea numarului de neuroni din fiecare strat ascuns. In probleme de clasificare (si nu de aproximare sau de modelare), cand la iesire reteaua recunoaste o clasa dintr-un set finit de clase posibile ( spre exemplu, recunoaste cifra 1 din 10 cifre posibile ), este suficient un singur strat ascuns. Se pot folosi eventual si mai multe straturi ascunse (desi este rar acest caz), pentru ca reteaua sa poata fi antrenata mai rapid.
Nu exista o formula dupa care sa se calculeze numarul de neuroni necesari intr-un strat ascuns. Acest numar se determina experimental. De aici, si necesitatea folosirii simulatoarelor, care permit modificarea numarului de neuroni folositi. In general cel mult 2 straturi ascunse sunt suficiente pentru marea majoritate a aplicatiilor.
-Antrenarea retelei
Pentru a simplifica procesul de antrenare, un simulator ar trebui sa permita si antrenarea in trepte a retelei. Initial, eroarea de invatare a sabloanelor se seteaza cu o valoare mare. De exemplu, pentru o retea ce trebuie sa invete sabloanele cu o toleranta finala de 1%, pentru a micsora timpul de antrenare, putem fixa initial eroarea la 10%. In acest fel , se castiga incredere ca reteaua converge. Apoi putem micsora aceasta eroare ( in trepte ), si sa reluam antrenarea cu ponderile gasite de la treapta precedenta. Repetam, pana cand se atinge eroarea impusa de 1%. Prin aceasta metoda de antrenare in trepte, adesea retelele neuronale converg mai rapid si generalizeaza mai bine.
In cazul in care dupa o alegere atenta a arhitecturii retelei, ea totusi nu converge sau generalizeaza prost, trebuie in general reanalizate sabloanele de antrenare folosite, modificandu-le. Se poate insa reantrena reteaua cu aceleasi sabloane, dar prezentate in alta ordine. Sau se poate antrena reteaua in modul "batch": ajustarea ponderilor nu se mai face dupa fiecare sablon, ci, dupa prezentarea intregului set de sabloane.
De asemenea, atunci cand sunt probleme de convergenta sau de generalizare, se poate incerca folosirea mai multor retele neuronale interconectate, in loc de una singura.

3. DESFASURAREA LUCRARII

Se va edita si apoi executa programul descris in continuare, care simuleaza o retea neuronala cu intrari analogice.
Se prezinta ca date de intrare pentru reteaua neuronala, 10 valori numerice, numere reale pozitive. Ele reprezinta valorile ordonatelor unor puncte (pe axa Oy). Abscisele acestor puncte sunt egal distantate. Cele 10 valori, reprezentate grafic, determina o curba. Reteaua neuronala trebuie sa clasifice curba de pe intrarile ei, intr-una din urmatoarele clase:
-linie dreapta de panta zero (clasa 0)
-linie dreapta de panta pozitiva (clasa 1)
-linie dreapta de panta negativa (clasa 2)
-curba cu concavitate pozitiva (clasa 3)
-curba cu concavitate negativa (clasa 4)
In vederea rezolvarii problemei propuse, am folosit o retea neuronala MLP, cu 10 neuroni in stratul de intrare, un singur strat ascuns cu 5 neuroni, si 5 neuroni in stratul de iesire. Cele 5 iesiri (Y0,Y1,Y2,Y3,Y4) sunt atribuite fiecare, uneia din cele 5 clase de curbe. Reteaua a fost antrenata cu 15 sabloane (cate 3 pentru fiecare clasa de iesire).
Pentru valori numerice mari pe intrarile retelei, datorita functiei exponentiale din expresia functiei de transfer a unui neuron, se pot obtine ca rezultate intermediare numere foarte mari, si deci erori de depasire (overflow), la executia programului. De aceea valorile numerice de intrare (fie cele din sabloanele de antrenare, fie cele folosite la testarea retelei antrenate) se preproceseaza prin scalare, prin aducerea lor in gama 0..1. Astfel , intrarile neuronilor din primul strat sunt numere reale cuprinse in intervalul a0,1i. Formula de scalare folosita in cazul acestei aplicatii de clasificare curbe, este: xScalat=(x-min)/(max-min), unde max si min sunt, respectiv, cea mai mare si cea mai mica din cele 10 valori numerice asteptate pe intrari.

Listingul programului import java.util.*; import java.io.*; class RNLiniiA static final int NR_NEURONI_IN=10; static final int NR_NEURONI_OUT=5; static final int NR_NEURONI_HIDDEN=10; static final int NR_TOTAL_SABLOANE=3*NR_NEURONI_OUT; static final double EROARE_IMPUSA=0.01; static final int NR_MAXIM_EPOCI=20000; static double sabloaneInaiai= new doubleaNR_TOTAL_SABLOANEiaNR_NEURONI_INi; static double sabloaneOutaiai= new doubleaNR_TOTAL_SABLOANEiaNR_NEURONI_OUTi; static double w1aiai= new doubleaNR_NEURONI_HIDDENiaNR_NEURONI_INi; static double w2aiai= new doubleaNR_NEURONI_OUTiaNR_NEURONI_HIDDENi;

public static void main(String argsai)
A boolean converge;
ConsoleReader cr=new ConsoleReader(System.in); char c,raspuns; doA
System.out.print("a (antrenare) sau t (testare) ? aa/ti : "); c=cr.readChar();
Swhile((c!='a')&&(c!='t')); switch(c)A case 'a'://antrenare initPonderi(); incarcaSabloane(); converge=antrenare(); if(!converge)System.out.println("Nu a convers in nr. de epocii specificat !"); elseA
System.out.println("A convers. !"); afisareExtremePonderi();
System.out.print("Salvare ponderi in fisier ? ad/ni : "); raspuns=cr.readChar(); if(raspuns=='d')salvare(); for(;;)A
System.out.print("Testare ? ad/ni : "); raspuns=cr.readChar(); if(raspuns=='d')testare(); else break;
S//for
S//else a convers break; //antrenare case 't': //testare incarcaPonderi(); for(;;)A testare();
System.out.print("Testare ? ad/ni : "); raspuns=cr.readChar(); if(raspuns=='n')break;
S//for break;//testare
S//switch
S//main

private static void initPonderi()
A int i,j;
Random r=new Random();
//initializare primul strat de ponderi: for(i=0;i<NR_NEURONI_HIDDEN;i++) for(j=0;j<NR_NEURONI_IN;j++)
w1aiiaji=r.nextDouble()-0.5;
//initializare strat al doilea de ponderi: for(i=0;i<NR_NEURONI_OUT;i++) for(j=0;j<NR_NEURONI_HIDDEN;j++)
w2aiiaji=r.nextDouble()-0.5;
S

private static void incarcaSabloane()
A tryA
FileReader fp=new FileReader("L5_1_sabloane.txt");
BufferedReader fpBuf=new BufferedReader(fp);
//Stim ca fisierul contine 2 * NR_TOTAL_SABLOANE de linii.
//(pentru fiecare sablon, sunt 2 linii: linia cu intrarile sablonului
// si linia cu iesirile sablonului.) for(int ex=0;ex<NR_TOTAL_SABLOANE;ex++)A
//pt. fiecare sablon ex, citim 2 linii:
String linieCrt=fpBuf.readLine();
//S-a citit linia cu intrarile sablonului ex. if(linieCrt==null)A
System.out.println("Structura fisierului de sabloane nu este corecta!");
System.exit(1);S
//Citim valorile din sablon, pt. fiecare neuron de intrare:
/*Pentru a separa un string in articolele sale componente (separator implicit este caracterul blank), se foloseste clasa StringTokenizer si metoda nextToken( ).*/
StringTokenizer st=new StringTokenizer(linieCrt); for(int i=0;i<NR_NEURONI_IN;i++)A

//double x=Double.parseDouble(st.nextToken());
//Nu exista Double.parseDouble() in JDK 1.1.6 double x=Double.valueOf(st.nextToken()).doubleValue();
//Double.valueOf(string) scoate un obiect Double.
//Extragem tipul primitiv double din Double,
// cu: Double.doubleValue();
//Cea mai mare valoare din fisierul de sabloane: 10.0
//Cea mai mica valoare din fisierul de sabloane: 0.0 x=(x-0.0)/(10.0-0.0);//scalare in plaja 0.0, 1.0 sabloaneInaexiaii=x;S
//Citim linia cu iesirile sablonului ex: linieCrt=fpBuf.readLine(); if(linieCrt==null)A
System.out.println("Structura fisierului de sabloane nu este corecta!");
System.exit(1);S
//Citim valorile din sablon, pt. fiecare neuron de iesire: st=new StringTokenizer(linieCrt); for(int i=0;i<NR_NEURONI_OUT;i++) sabloaneOutaexiaii=
Double.valueOf(st.nextToken()).doubleValue();
S//for ex fpBuf.close();
Scatch(IOException e)A
System.out.println(e);
System.exit(1);S
S

private static boolean antrenare()
A double yHiddenai=new doubleaNR_NEURONI_HIDDENi; double yOutai=new doubleaNR_NEURONI_OUTi; double eroareIesireSablonCrtai= new doubleaNR_TOTAL_SABLOANEi; double eroareTotala; int nrEpoci=0; boolean converge=false; boolean stop=false; int i,ex;
while(!stop)A for(ex=0;ex<NR_TOTAL_SABLOANE;ex++)A calculIesiriNeuroni(yHidden,yOut,ex); eroareIesireSablonCrtaexi=0; for(i=0;i<NR_NEURONI_OUT;i++) eroareIesireSablonCrtaexi+=0.5*(yOutaii sabloaneOutaexiaii)*(yOutaii-sabloaneOutaexiaii); modificaPonderi(yOut,yHidden,ex);
S//for nrEpoci++; eroareTotala=0; for(ex=0;ex<NR_TOTAL_SABLOANE;ex++) eroareTotala+=eroareIesireSablonCrtaexi;
System.out.println("Epoca nr: "+nrEpoci+
" eroare totala= "+eroareTotala); if(eroareTotala <= EROARE_IMPUSA)
Aconverge=true;stop=true;S if(nrEpoci > NR_MAXIM_EPOCI)stop=true;
S//while return converge;
S

private static void calculIesiriNeuroni(double yHiddenai, double yOutai,int ex)
A int i,j; double xTotal_i; for(i=0;i<NR_NEURONI_HIDDEN;i++)A xTotal_i=0; for(j=0;j<NR_NEURONI_IN;j++) xTotal_i=xTotal_i+sabloaneInaexiaji*w1aiiaji; yHiddenaii=1/(1+Math.exp(-xTotal_i));
S//for i

for(i=0;i<NR_NEURONI_OUT;i++)A xTotal_i=0; for(j=0;j<NR_NEURONI_HIDDEN;j++) xTotal_i=xTotal_i+yHiddenaji*w2aiiaji; yOutaii=1/(1+Math.exp(-xTotal_i));
S//for i
S

private static void modificaPonderi(double yOutai, double yHiddenai,int ex)
A double deltaOutai=new doubleaNR_NEURONI_OUTi; double deltaHiddenai=new doubleaNR_NEURONI_HIDDENi; int i,j,k; double sumaPonderataDeltaFii; double alfa=1.0; double eta=1.0; for(i=0;i<NR_NEURONI_OUT;i++) deltaOutaii=(yOutaii-sabloaneOutaexiaii)*
(1-yOutaii)*yOutaii; for(i=0;i<NR_NEURONI_OUT;i++) for(j=0;j<NR_NEURONI_HIDDEN;j++)
w2aiiaji=alfa*w2aiiaji-eta*deltaOutaii*yHiddenaji;

for(i=0;i<NR_NEURONI_HIDDEN;i++)A sumaPonderataDeltaFii=0; for(j=0;j<NR_NEURONI_OUT;j++) sumaPonderataDeltaFii+=w2ajiaii*deltaOutaji; deltaHiddenaii=sumaPonderataDeltaFii*
(1-yHiddenaii)*yHiddenaii;
S for(i=0;i<NR_NEURONI_HIDDEN;i++) for(j=0;j<NR_NEURONI_IN;j++)
w1aiiaji=alfa*w1aiiaji-eta*deltaHiddenaii*sabloaneInaexiaji;
S//modificaPonderi

private static void afisareExtremePonderi()
A int i,j; double wMax,wMin;
wMax=w1a0ia0i;
wMin=w1a0ia0i; for(i=0;i<NR_NEURONI_HIDDEN;i++) for(j=0;j<NR_NEURONI_IN;j++)
A if(w1aiiaji > wMax)wMax=w1aiiaji; if(w1aiiaji < wMin)wMin=w1aiiaji;
S for(i=0;i<NR_NEURONI_OUT;i++) for(j=0;j<NR_NEURONI_HIDDEN;j++)
A if(w2aiiaji > wMax)wMax=w2aiiaji; if(w2aiiaji < wMin)wMin=w2aiiaji;
S
System.out.println("Ponderea maxima="+wMax+
" ponderea minima="+wMin);
S

private static void testare()
A int i;
//iesiri neuroni din strat hidden: double yHiddenai=new doubleaNR_NEURONI_HIDDENi;
//iesiri neuroni din strat aut (cele calculate): double yOutai=new doubleaNR_NEURONI_OUTi; double valoriCurbaai=new doublea10i; double max,min;

System.out.println("Dati cele 10 valori pozitive ale curbei:");
//In timp ce le citim, aflam si minimul si maximul dintre ele,
// pentru a face scalarea:
ConsoleReader cr=new ConsoleReader(System.in);
System.out.print("Valoarea curbei in punctul 0 : "); valoriCurbaa0i=cr.readDouble(); max=valoriCurbaa0i; min=valoriCurbaa0i;
//Celelalte 9 valori: for(i=1;i<10;i++)A
System.out.print("Valoarea curbei in punctul "+i+" : "); valoriCurbaaii=cr.readDouble(); if(valoriCurbaaii > max)max=valoriCurbaaii; if(valoriCurbaaii < min)min=valoriCurbaaii;
S//for
//Metoda calculIesiriNeuroni(), calculeaza iesirile din retea,
//avand ca date la intrari, datele din sabloaneInaiai
//De aceea, incarcam datele citite in sabloaneIna0iai: if(max!=min)//pt. a nu avea impartire cu 0: for(i=0;i<10;i++) sabloaneIna0iaii=(valoriCurbaaii-min)/(max-min); else for(i=0;i<10;i++) sabloaneIna0iaii=1; calculIesiriNeuroni(yHidden,yOut,0);

System.out.println("Dreapta, panta 0 : "+yOuta0i);
System.out.println("Dreapta, panta poz. : "+yOuta1i);
System.out.println("Dreapta, panta neg. : "+yOuta2i);
System.out.println("Dreapta, concav. poz. : "+yOuta3i);
System.out.println("Dreapta, concav. neg. : "+yOuta4i);
S//testare

private static void salvare()
A
StringBuffer nume=new StringBuffer("L5_1_ponderi.");
System.out.println("Numele fisierului in care salvam ponderi este:
L5_1_ponderi.xxx ");
System.out.println("Extensia (xxx) a numelui, este variabila.
Exemplu de nume fisier: ");
System.out.println("L5_1_ponderi.001");
System.out.print("Introduceti extensia numelui fisierului: ");
ConsoleReader cr=new ConsoleReader(System.in);
String extensie=cr.readLine(); nume.append(extensie);
String numeF=nume.toString(); int i,j; tryA
FileWriter fp=new FileWriter(numeF);
BufferedWriter fpBuf=new BufferedWriter(fp); for(i=0;i<NR_NEURONI_HIDDEN;i++)A for(j=0;j<NR_NEURONI_IN;j++)A
String s=w1aiiaji+" "; fpBuf.write(s,0,s.length());S fpBuf.newLine();
S
//fpBuf.newLine(); st.nextToken() da erore pe linie goala! for(i=0;i<NR_NEURONI_OUT;i++)A for(j=0;j<NR_NEURONI_HIDDEN;j++)A
String s=w2aiiaji+" "; fpBuf.write(s,0,s.length());S fpBuf.newLine();
S fpBuf.close();
Scatch(IOException e)A
System.out.println(e);
System.exit(1);S
S

private static void incarcaPonderi()
A
StringBuffer nume=new StringBuffer("L5_1_ponderi.");
System.out.println("Numele fisierului din care citim ponderile este: L5_1_ponderi.xxx ");
System.out.print("Introduceti extensia numelui fisierului: ");
ConsoleReader cr=new ConsoleReader(System.in);
String extensie=cr.readLine(); nume.append(extensie);
String numeF=nume.toString(); int i,j; tryA
FileReader fp=new FileReader(numeF);
BufferedReader fpBuf=new BufferedReader(fp);
//Citim ponderile w1: for(i=0;i<NR_NEURONI_HIDDEN;i++)A
//Toate ponderile neuronului hidden i, sunt scrise pe o linie text.
//Toate ponderile neuronului hidden i+1 sunt scrise pe linia
// urmatoare.
String linieCrt=fpBuf.readLine(); if(linieCrt==null)A
System.out.println("Structura fisierului de ponderi nu este corecta!");
System.exit(1);S
StringTokenizer st=new StringTokenizer(linieCrt); for(j=0;j<NR_NEURONI_IN;j++)
w1aiiaji=Double.valueOf(st.nextToken()).doubleValue();
S//for i
//Citim ponderile w2: for(i=0;i<NR_NEURONI_OUT;i++)A
String linieCrt=fpBuf.readLine(); if(linieCrt==null)A
System.out.println("Structura fisierului de ponderi nu este corecta!");
System.exit(1);S
StringTokenizer st=new StringTokenizer(linieCrt); for(j=0;j<NR_NEURONI_HIDDEN;j++)
w2aiiaji=Double.valueOf(st.nextToken()).doubleValue();
S//for i fpBuf.close();
Scatch(IOException e)A
System.out.println(e);
System.exit(1);S
S//end incarcaPonderi
S//class

Fisierul de sabloane, L5_1_sabloane.txt se editeaza cu editorul Notepad si are urmatoarea structura:

2 2 2 2 2 2 2 2 2 2
1 0 0 0 0
5 5 5 5 5 5 5 5 5 5
1 0 0 0 0
7 7 7 7 7 7 7 7 7 7
1 0 0 0 0
1 2 3 4 5 6 7 8 9 10
0 1 0 0 0
2.5 3 3.5 4 4.5 5 5.5 6 6.5 7
0 1 0 0 0
0.5 1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5
0 1 0 0 0
10 9 8 7 6 5 4 3 2 1
0 0 1 0 0
7 6.5 6 5.5 5 4.5 4 3.5 3 2.5
0 0 1 0 0
9.5 8.5 7.5 6.5 5.5 4.5 3.5 2.5 1.5 0.5
0 0 1 0 0
10 8 6 4 2 2 4 6 8 10
0 0 0 1 0
9.5 7.5 5.5 3.5 1.5 1.5 1.5 4 6 8
0 0 0 1 0
9 7 5 3 2 2.5 4 5 7 8
0 0 0 1 0
2 4 6 8 9 9 8 6 4 2
0 0 0 0 1
1 3 5 7 8 9 8.5 8 6 4
0 0 0 0 1
3 3.5 5 7 7.5 8 7 6 5 2
0 0 0 0 1

Tema
1. Sa se antreneze reteaua completand fisierul de sabloane cu altele noi.
2. Sa se modifice programul astfel incat datele cu care se testeaza reteaua sa nu fie introduse direct de la tastatura, ci sa se citeasca dintr-un fisier text de test.
3. Modificati programul astfel incat sa se realizeze o antrenare in trepte a retelei neuronale.
4. Sa se dezvolte un program de simulare a unei retele neuronale care recunoaste 2 forme de semnal: semnal dreptunghiular si semnal triunghiular.