POLITECHNIKA RZESZOWSKA

Wydział Elektrotechniki i Informatyki

Katedra Informatyki i Automatyki

SZTUCZNA INTELIGENCJA

Projekt

Temat: Zrealizować sieć neuronową (learnbpm) uczącą się odwzorowania $z = \frac{1}{x^{2} + y^{2}}$ dla x i y zmieniających się od -1 do 1.

Wykonał:

Rafał Ciurej

II FD, P02

Spis treści

1. Wstęp............................................................................................................................3

2. Opis teoretyczny……………………………………………………………………..4

2.1. Sieć neuronowa………………………………………………………….……4

2.2. Opis metody………………………………………………………….…….…6

2.3. Metoda „momentum”………………………………………………………..7

3. Przedstawienie problemu……………………………………………………………8

4. Rozwiązanie problemu………………………………………………………………9

4.1. Dobranie odpowiednich parametrów…………………………….…………9

4.2. Eksperymenty……………………………………………………………….11

5. Testowanie sieci neuronowej……………………………………………………….16

5.1. Wpływ parametru „momentum (mc)” na zdolność uczenia się sieci neuronowej…………………………………………………………………...16

5.2. Wpływ ilości przejść na zdolność uczenia się sieci neuronowej…………..17

6. Podsumowanie……………………………………………………………………….18

1. Wstęp

Niniejsza dokumentacja jest słownym opisem działań, jakie zostały wykonane w celu zrealizowania zagadnienia z przedmiotu Sztuczna Inteligencja p.t.: „Zrealizować sieć neuronową (learnbpm) uczącą się odwzorowania $z = \frac{1}{x^{2} + y^{2}}$ dla x i y zmieniających się od -1 do 1”. Do wykonania tego projektu został użyty program firmy MathSoft – Matlab w wersji: 7.0.0.19920 (R14).

1. Opis teoretyczny

   1. Sieć neuronowa

Do przedstawienia problemu została użyta trójwarstwowa sieć neuronowa.

Sieć neuronowa (sztuczna sieć neuronowa) – ogólna nazwa struktur matematycznych i ich programowych lub sprzętowych modeli, realizujących obliczenia lub przetwarzanie sygnałów poprzez rzędy elementów, zwanych sztucznymi neuronami, wykonujących pewną podstawową operację na swoim wejściu. Oryginalną inspiracją takiej struktury była budowa naturalnych neuronów oraz układów nerwowych, w szczególności mózgu.

Czasem nazwą sztuczne sieci neuronowe określa się interdyscyplinarną dziedzinę wiedzy zajmującą się konstrukcją, trenowaniem i badaniem możliwości tego rodzaju sieci.

Źródło: pl.wikipedia.org/wiki/Sieć_neuronowa

Wielowarstwowa sieć neuronowa zbudowana jest z neuronów. Dane wejściowe zostają pomnożone w neuronie przez odpowiednio przypisane im wagi (w₁, w₂, …, w_i, …, w_n), a następnie sumowane i przekazane na wyjście. Poniższy rysunek przedstawia model sztucznego neuronu.

Poniższy rysunek ilustruje trójwarstwową sieć neuronową.

Sieć ta posiada trzy warstwy. Występuje tutaj połączenie typu każdy z każdym. Dane wejściowe podawane są do warstwy wejściowej neuronów, których wyjścia stanowią sygnały źródłowe dla kolejnej warstwy.

Każda warstwa neuronów posiada swoją macierz wag w, wektor przesunięć b, funkcje aktywacji f i wektor sygnałów wyjściowych y. Aby je rozróżniać w dalszych rozważaniach do każdej z wielkości dodano numer warstwy, której dotyczą. Na przykład dla warstwy drugiej (ukrytej) macierz wag oznaczana będzie symbolem w(2) . Działanie każdej z warstw można rozpatrywać oddzielnie. I tak np. warstwa druga posiada: L = K1 sygnałów wejściowych, K = K2 neuronów i macierz wag w = w(2) o rozmiarach K2 K1 ´ . Wejściem warstwy drugiej jest wyjście warstwy pierwszej x = y(1) , a wyjściem y = y(2) . Działanie poszczególnych warstw dane jest przez

y(1) = f(1)(w(1)x + b(1) ),

y(2) = f(2)(w(2)y(1) + b(2) ),

y(3) = f(3)(w(3)y(2) + b(3) ).

Działanie całej sieci można więc opisać jako

y(3) = f (3) (w(3)f (2) (w(2)f (1) (w(1)x + b(1) )+ b(2) )+ b(3) ).

Sieci jednokierunkowe wielowarstwowe wykorzystują najczęściej w warstwach wejściowej i ukrytej funkcje aktywacji typu sigmoidalnego. Typ funkcji aktywacji w warstwie wyjściowej zależy od przeznaczenia sieci. W pewnych praktycznych zastosowaniach (np. w sieciach używanych do sterowania) zastosowanie funkcji aktywacji typu sigmoidalnego może być niekorzystne. Istotne znaczenie ma tutaj zbyt wąski zakres (-1,1) sygnału wyjściowego. W związku z tym, w wielu zastosowaniach używa się funkcji liniowej w warstwie wyjściowej, która nie posiada takich ograniczeń.

Źródło: PRz, KIiA, Sztuczna inteligencja, Laboratorium, Ćw9 Sieć jednokierunkowa wielowarstwowa, Roman Zajdel

1. Opis metody

Metoda wstecznej propagacji błędu jest to podstawowy algorytm uczenia nadzorowanego wielowarstwowych jednokierunkowych sieci neuronowych. Podaje on przepis na zmianę wag w_ij dowolnych połączeń elementów przetwarzających rozmieszczonych w sąsiednich warstwach sieci. Oparty jest on na minimalizacji sumy kwadratów błędów uczeni z wykorzystaniem optymalizacyjnej metody największego spadku. Dzięki zastosowaniu specyficznego sposobu propagowania błędów uczenia sieci powstałych na jej wyjściu, tj. przesyłania ich od warstwy wyjściowej do wejściowej, algorytm propagacji wstecznej stał się jednym z najskuteczniejszych algorytmów uczenia sieci.

W trakcie procesu uczenia sieci można wykorzystać dowolną liczbę wzorców uczących. W praktyce do uczenia używa się zazwyczaj stosunkowo niewielu wzorców, a przy pomocy pozostałych sprawdza się, czy nauczona sieć realizuje prawidłowe odwzorowanie. Zbiór wzorców dzielony jest więc faktycznie na dwa zbiory: uczący oraz testujący.

Jeśli sieć będzie pracowała z danymi zakłóconymi, to część wektorów uczących powinna być również "wzbogacona" o zakłócenia. Wiąże się to ze zdolnością sieci do uogólniania. Często niewielkie zaburzenie sygnałów wzorcowych powoduje przyspieszenie zbieżności procesu uczenia, pomimo, że w rzeczywistym układzie pracy zaburzony sygnał nigdy się nie pojawi.

Zdolność sieci typu propagacji wstecznej do uogólnień polega na tym, że przy danym zbiorze uczącym sieć znajduje pewne wspólne cechy wektorów uczących. Podanie wektora wejściowego, który nie był prezentowany w czasie uczenia, powoduje zakwalifikowanie go do jednej z określonych klas wektorów, a wyjście sieci powinno być zbliżone do wyjścia odpowiadającego najbliższemu wzorcowi w przestrzeni wejść. Sieć typu propagacji wstecznej nie dokonuje jednak ekstrapolacji. Nie można właściwie przyporządkować danego wektora wejściowego, jeśli klasa, do której należy, nie miał swojej reprezentacji w zbiorze wektorów uczących. Należy zatem poprzez odpowiedni dobór wektorów uczących zapewnić w miarę możliwości pokrycie całej przestrzeni stanów wejściowych. Istotna jest też kolejność prezentacji wzorców uczących. Należy unikać sytuacji, kiedy prezentowane są wzorce najpierw jednej klasy, potem drugiej, itd., ponieważ sieć "zapomina" wzorce wcześniej zapamiętane. Najskuteczniejsza jest losowa kolejność prezentacji wzorców, podobnie jak w przypadku perceptronu prostego.

Źródło: http://www.neuron.kylos.pl/pliki/jednokier/jednokier4.html

1. Metoda „momentum”

W przypadku uczenia pod nadzorem pojedynczej warstwy sieci reguła uczenia z momentum może wyglądać następująco:

$w_{\text{ij}}\left( t + 1 \right) = w_{\text{ij}}\left( t \right) + \left( 1 - \eta \right)\left( {\hat{y}}_{i}\left( t \right) - y_{i}\left( t \right) \right)\frac{\partial y_{j}\left( t \right)}{\partial z_{j}}x_{i}\left( t \right) + \eta M_{\text{ij}}\left( t \right)$,

gdzie momentum M_ij(k) jest wyliczane z zależności

M_ij(t) = w_ij(t) − w_ij(t−1),

η∈[0,1] jest współczynnikiem uczenia momentum. Jeżeli η = 1, to nowa waga jest równa ostatniej zmianie wagi. Jeżeli η = 0, to zmiana wagi oparta jest tylko na składowej gradientowej. Najczęściej przyjmuje się η = 0.95. Wprowadzenie składnika momentum zdecydowanie wpływa na zwiększenie szybkości uczenia.

Źródło: PRz, KIiA, Sztuczna inteligencja, Laboratorium, Ćw10 Przyśpieszanie procesu uczenia, Roman Zajdel

2. Przedstawienie problemu

Problemem stawianym przed jednokierunkową wielowarstwową siecią neuronową jest jej nauczenie odwzorowania $z = \frac{1}{x^{2} + y^{2}}$ dla x i y zmieniających się od -1 do 1 przy pomocy wyżej opisanej metody wstecznej propagacji błędu przyspieszoną metodą momentu w programie Matlab.

2. Rozwiązanie problemu

Funkcja odpowiadająca nauczaniu wielowarstwowej sieci neuronowej ze wsteczną propagacją błędu przyspieszoną metodą momentum w programie MatLab nosi nazwę learnbpm.

Wywołanie:

[dW,dB] = learnbpm (P,D,LR,MC,dW,dB)

Argumenty:
P - macierz wektorów wejściowych (wymiar R*Q, R - liczba wejść warstwy, Q -
ilość wektorów),
D - macierz pochodnych błędów warstwy (wymiar S*Q, S - liczba neuronów w
warstwie),
LR - współczynnik prędkości uczenia,
MC - wartość stałej momentum,
dW - macierz przyrostów współczynników wagowych warstwy w poprzednim kroku (wymiar S*R),
dB - wektor przyrostów współczynników progowych warstwy w poprzednim kroku (wymiar S*1)
Wielkości zwracane:
dW - nowa macierz przyrostów współczynników wagowych warstwy (wymiar S*R),
dB - nowa macierz przyrostów współczynników progowych warstwy (wymiar S*1)

Źródło: http://ssn.elektrotechnika.ip.pwsz.edu.pl/nnt/nnt1.php

1. Dobranie odpowiednich parametrów

W celu jak najlepszego doboru parametrów został napisany kod w Matlab, którego zadaniem było wybranie wartości lr, mc, S1 i S2, tak, aby błąd SSE posiadał jak najmniejszą wartość. Poniżej znajduje się skrypt.

clear all;

nntwarn off;

X=-1:.3:1;

Y=-1:.3:1;

Z=zeros(length(X), length(Y));

XX = [];

YY = [];

ZZ = [];

for i = 1 : length(X),

for j = 1 : length(Y),

XX = [XX X(i)];

YY = [YY Y(j)];

Z(i, j) = (1/(X(i)^2 + Y(j)^2));

ZZ = [ZZ Z(i, j)];

end

end;

P = [XX; YY];

[R, Q] = size(P);

S1 = 150;

S2 = 37;

[S3, Q] = size(ZZ);

disp_freq = 10;

max_epoch = 5000;

err_goal = 2e-20;

lr = .001;

mc = .9;

error = [];

[W1, B1] = nwtan (S1, R);

[W2, B2] = nwtan (S2, S1);

[W3, B3] = rands (S3, S2);

dW1 = zeros (size (W1));

dB1 = zeros (size (B1));

dW2 = zeros (size (W2));

dB2 = zeros (size (B2));

dW3 = zeros (size (W3));

dB3 = zeros (size (B3));

A1 = tansig (W1*P, B1);

A2 = tansig (W2*A1, B2);

A3 = purelin (W3*A2, B3);

E = ZZ - A3;

SSE = sumsqr (E);

for epoch = 1 : max_epoch, % pętla uczenia

if SSE < err_goal, epoch = epoch - 1;

break;

end

D3 = deltalin (A3, E);

D2 = deltatan (A2, D3, W3);

D1 = deltalin (A1, D2, W2);

[dW1, dB1] = learnbpm (P, D1, lr, mc, dW1, dB1);

[dW2, dB2] = learnbpm (A1, D2, lr, mc, dW2, dB2);

[dW3, dB3] = learnbpm (A2, D3, lr, mc, dW3, dB3);

W1 = W1 + dW1; B1 = B1 + dB1;

W2 = W2 + dW2; B2 = B2 + dB2;

W3 = W3 + dW3; B3 = B3 + dB3;

A1 = tansig (W1*P, B1);

A2 = tansig (W2*A1, B2);

A3 = purelin (W3*A2, B3);

E = ZZ - A3;

SSE = sumsqr(E);

error = [error, SSE];

if (rem (epoch, disp_freq) == 0),

epoch

SSE

A3_ = zeros (size (Z));

error_ = zeros (size (Z));

for i = 1 : length(X),

for j = 1 : length(Y),

A1_ = tansig(W1*[X(i); Y(j)], B1);

A2_ = tansig(W2*A1_, B2);

A3_(i, j) = purelin(W3*A2_,B3);

error_(i,j)=Z(i,j)-A3_(i,j);

end

end

figure (1)

subplot (1, 2, 1), mesh (X, Y, Z);

subplot (1, 2, 2), mesh (X, Y, A3_);

figure (2)

mesh (X, Y, error_);

pause (1e-200);

end

end

Na początku wyżej zaprezentowanego kodu zostaje ustalony zakres dla X i Y zmieniających się od -1 do 1 oraz krok przechodzenia – 0.3. Następnie odbywa się wypełnianie zerami macierzy Z oraz inicjalizacja macierzy XX, YY i ZZ. Pętla for wypełnia macierze XX oraz YY danymi, do Z wpisywany jest wzór od odwzorowania, tworzony jest wektor celu. Później wczytywane są dane do zmiennych odpowiadających za wejście (P). Następnie ustalany jest rozmiar wejścia (R) i liczba neuronów w poszczególnych warstwach (S1 – warstwa pierwsza , S2 – warstwa druga, S3 – warstwa trzecia). Kolejnym zadaniem jest wylosowanie odpowiednich wag (W1, W2, W3), oraz biasów (B1, B2, B3) poszczególnych warstw. Następnym krokiem jest wyzerowanie macierzy poprawek wag (dW1, dW2, dW3) oraz biasów (dB1, dB2, dB3). W tym momencie kodu ustalana jest częstotliwość wyświetlania danych (disp_freq), liczba przejść epok (max_epoch), błąd, który chcemy osiągnąć (err_goal), współczynnik uczenia sieci (lr) oraz współczynnik uczenia momentum (mc). Kolejnym krokiem jest ustalenie wartości poszczególnych warstw (A1, A2, A3), oraz wyznaczenie wartości błędu (E). Następnie w pętli ustalane są wartości poszczególnych delt (D1, D2, D3) oraz powtarzane są czynności od ustalania wartości poszczególnych warstw do wyznaczania błędu. Pętla ta kończy się w momencie osiągnięcia wymaganej wartości błędu (SSE < err_goal) lub gdy zostanie osiągnięta liczba przejść (max_epoch). Następnie odbywa się rysowanie wykresów, na których widać funkcję, którą sieć ma się nauczyć, postęp uczenia oraz wielkość błędu.

4.2. Eksperymenty

mc	EPOCH	SSE	lr	S1	S2
0,1	5000	4,3960E-01	0,001	25	15
0,1	5000	1,9397E+00	0,0001	25	15
0,1	5000	7,7887E+02	0,00001	25	15
0,2	5000	5,3940E-01	0,001	25	15
0,2	5000	1,3095E+00	0,0001	25	15
0,3	5000	1,7714E-04	0,001	25	15
0,3	5000	2,7394E+00	0,0001	25	15
0,4	5000	2,1910E-01	0,001	25	15
0,4	5000	8,6140E-01	0,0001	25	15
0,5	5000	1,7605E-06	0,001	25	15
0,5	5000	8,4970E-01	0,0001	25	15
0,6	5000	3,5000E-03	0,001	25	15
0,6	5000	7,5850E-01	0,0001	25	15
0,7	5000	1,3765E-04	0,001	25	15
0,7	5000	1,0371E+00	0,0001	25	15
0,8	5000	7,8509E-06	0,001	25	15
0,8	5000	2,1271E+00	0,0001	25	15
0,9	5000	3,6196E-05	0,001	25	15
0,9	5000	1,5073E+00	0,0001	25	15
0,99	5000	1,1849E+00	0,001	25	15
0,99	5000	2,4525E+00	0,0001	25	15
0,1	5000	3,8377E-08	0,001	40	37
0,1	5000	3,5000E-02	0,0001	40	37
0,2	5000	6,2169E-14	0,001	40	37
0,2	5000	1,7600E-02	0,0001	40	37
0,3	5000	9,4959E-09	0,001	40	37
0,3	5000	1,8990E-01	0,0001	40	37
0,4	5000	3,0725E-16	0,001	40	37
0,4	5000	8,5700E-02	0,0001	40	37
0,5	5000	3,7940E-08	0,001	40	37
0,5	5000	5,2000E-02	0,0001	40	37
0,6	5000	1,4598E-08	0,001	40	37
0,6	5000	1,1650E-01	0,0001	40	37
0,7	5000	2,7628E-08	0,001	40	37
0,7	5000	7,9500E-02	0,0001	40	37
0,8	5000	7,6105E-07	0,001	40	37
0,9	5000	1,2564E-12	0,001	40	37
0,99	5000	1,7653E-06	0,001	40	37
0,1	5000	1,0723E-13	0,001	50	37
0,2	5000	4,1835E-07	0,001	50	37
0,3	4570	2,0316E-20	0,001	50	37
0,3	5000	9,1528E-12	0,001	50	37
0,4	5000	2,7754E-14	0,001	50	37
0,5	5000	1,9616E-14	0,001	50	37
0,6	5000	1,3635E-10	0,001	50	37
0,7	5000	3,4929E-14	0,001	50	37
0,8	5000	5,0808E-28	0,001	50	37
0,9	5000	7,7238E-18	0,001	50	37
0,99	5000	4,1169E-07	0,001	50	37
0,1	5000	3,8530E-06	0,001	75	37
0,2	5000	8,1753E-18	0,001	75	37
0,3	5000	3,9916E-28	0,001	75	37
0,4	5000	1,0102E-05	0,001	75	37
0,5	5000	9,7103E-27	0,001	75	37
0,6	5000	5,4471E-28	0,001	75	37
0,7	5000	8,6394E-16	0,001	75	37
0,8	5000	4,4521E-29	0,001	75	37
0,9	5000	5,3513E-27	0,001	75	37
0,99	5000	1,2269E-05	0,001	75	37
0,1	5000	1,8777E-11	0,001	100	37
0,2	5000	6,6046E-24	0,001	100	37
0,3	5000	1,5067E-28	0,001	100	37
0,4	5000	5,1424E-29	0,001	100	37
0,5	5000	4,8789E-19	0,001	100	37
0,6	5000	4,5507E-29	0,001	100	37
0,7	5000	9,5647E-18	0,001	100	37
0,8	5000	2,6082E-29	0,001	100	37
0,9	5000	1,0491E-19	0,001	100	37
0,99	5000	4,9498E-20	0,001	100	37
0,1	5000	2,7002E-04	0,001	150	37
0,2	5000	7,8218E-07	0,001	150	37
0,3	5000	8,3792E-28	0,001	150	37
0,4	5000	2,3074E-29	0,001	150	37
0,5	5000	2,3931E-28	0,001	150	37
0,6	5000	7,3930E-05	0,001	150	37
0,7	5000	5,7095E-12	0,001	150	37
0,8	5000	5,9128E-29	0,001	150	37
0,9	5000	2,0498E-29	0,001	150	37
0,99	5000	4,6279E-20	0,001	150	37
0,1	5000	5,0300E-02	0,001	150	50
0,2	5000	1,5809E-09	0,001	150	50
0,3	5000	2,2512E-07	0,001	150	50
0,4	5000	3,0296E-10	0,001	150	50
0,5	5000	1,0324E-28	0,001	150	50
0,6	5000	1,2385E-28	0,001	150	50
0,7	5000	4,7797E-22	0,001	150	50
0,8	5000	3,0877E-29	0,001	150	50
0,9	5000	4,8651E-29	0,001	150	50
0,99	5000	1,6939E-20	0,001	150	50
0,1	5000	3,2958E-24	0,001	150	75
0,2	5000	4,2512E-13	0,001	150	75
0,3	5000	2,7348E-15	0,001	150	75
0,4	5000	1,2124E-28	0,001	150	75
0,5	5000	6,7120E-12	0,001	150	75
0,6	5000	1,2055E-07	0,001	150	75
0,7	5000	1,6413E-28	0,001	150	75
0,8	5000	1,1325E-28	0,001	150	75
0,9	5000	2,4948E-29	0,001	150	75
0,99	5000	1,5297E-20	0,001	150	75
0,1	5000	2,1000E-03	0,001	150	100
0,2	5000	4,1747E-28	0,001	150	100
0,3	5000	0,0011	0,001	150	100
0,4	5000	6,7596E-29	0,001	150	100
0,5	5000	1,6144E-13	0,001	150	100
0,6	5000	3,9049E-29	0,001	150	100
0,7	5000	2,0841E-28	0,001	150	100
0,8	5000	2,6427E-29	0,001	150	100
0,9	5000	2,8991E-29	0,001	150	100
0,99	5000	4,5036E-20	0,001	150	100
	min	2,0498E-29

Na podstawie zebranych 109 pomiarach z powyższej tabeli odszukałem najmniejszą wartość błędu przy pomocy funkcji Excel =MIN(„zbiór danych z kolumny”) i podświetliłem je w powyższej tabeli kolorem. Pozwoliło mi to na określenie danych jakie mam użyć w swoim programie.

Poniższy wykres ukazuje zdolność uczenia się wspomnianej sieci neuronowej przy liczbie przejść (epok) równej 5 000, współczynniku momentum równym 0.9, współczynniku uczenia sieci równym 0.001 oraz błędzie 2e-20, który został osiągnięty w 520 – tym przejściu.

Przy wyżej wymienionych wartościach udało mi się w najkrótszym czasie osiągnąć zamierzony błąd (2e-20).

2. Testowanie sieci neuronowej

1. Wpływ parametru „momentum (mc)” na zdolność uczenia się sieci neuronowej.

0,8	5,9128E-29
0,81	4,3021E-29
0,82	2,5539E-29
0,83	1,1508E-28
0,84	5,2570E-29
0,85	1,1646E-28
0,86	3,3995E-29
0,87	4,8379E-29
0,88	2,9225E-29
0,89	5,0425E-29
0,9	2,0498E-29
0,91	5,4678E-29
0,92	4,9600E-29
0,93	7,3487E-29
0,94	8,6232E-29
0,95	8,0945E-29
0,96	1,6263E-12
0,97	3,0470E-28
0,98	1,8294E-06
0,99	4,6279E-20
min	2,0498E-29

Z tabeli można wywnioskować, że sieć najlepiej uczy się przy współczynniku momentum mc równym 0.9.

1. Wpływ ilości przejść na zdolność uczenia się sieci neuronowej

0,1	1000	2,6000E-02	0,001	150	75
0,2	1000	5,9993E+00	0,001	150	75
0,3	1000	1,1000E-03	0,001	150	75
0,4	1000	1,8179E-12	0,001	150	75
0,5	1000	2,6128E-17	0,001	150	75
0,6	1000	1,4966E-12	0,001	150	75
0,7	1000	3,4377E-27	0,001	150	75
0,8	1000	2,6317E-27	0,001	150	75
0,9	1000	2,6325E-28	0,001	150	75
0,99	1000	6,5000E-03	0,001	150	75
0,1	500	2,1000E-03	0,001	150	100
0,2	500	4,1747E-28	0,001	150	100
0,3	500	0,0011	0,001	150	100
0,4	500	7,5700E-02	0,001	150	100
0,5	500	4,1000E-03	0,001	150	100
0,6	500	2,7000E-03	0,001	150	100
0,7	500	9,7123E-09	0,001	150	100
0,8	500	6,2814E-07	0,001	150	100
0,9	500	1,0512E-05	0,001	150	100
0,99	500	1,5789E+00	0,001	150	100

Z powyższej tabeli łatwo wywnioskować, że im więcej epoch tym mniejszy błąd i większa dokładność uczenia.

2. Podsumowanie

Po dobraniu odpowiednich parametrów dla pewności sprawdziłem dokładniejszą wartość parametru momentum mc, gdyż jest to główna różnica między funkcja learnbpm a learnbp i to od niego zależy szybkość uczenia się sieci. Kolejnym etapem było sprawdzenie szybkości zmniejszania się błędu SSE względem ilości przejść. Wnioski nasuwają się same – im więcej epok, tym wynik będzie dokładniejszy, a błąd mniejszy.

Po przeprowadzeniu kilku pomiarów przy użyciu lr = 0,00001 od razu zauważyłem, że sieć bardzo wolno się uczy zaś przy lr = 0.01 sieć nie uczy się wcale. Przy lr = 0.0001 sieć uczyła się szybciej niż lr = 0,00001 ale najlepszym wyborem okazała się wartość lr = 0,001, przy której sieć uczyła się najszybciej.

Projekt ten wykonałem wzorując się na informacjach zdobytych podczas zajęć laboratoryjnych, jak i na wiadomościach znalezionych w Internecie. Projekt ten jest niewielką częścią tego co można znaleźć w Internecie czy bibliotekach gdyż sieci neuronowe to zagadnienie bardzo szerokie.