Jarekz: /* Pojedynczy neuron: reguła delta */

2019-03-29T15:41:11Z

Pojedynczy neuron: reguła delta

Jarekz o 16:32, 16 lut 2017

2017-02-16T16:32:53Z

Jarekz: /* Uczenie nieliniowej sieci: Jak znaleźć błąd dla warstwy ukrytej? */

2016-04-25T08:15:59Z

Uczenie nieliniowej sieci: Jak znaleźć błąd dla warstwy ukrytej?

Jarekz o 15:32, 21 maj 2015

2015-05-21T15:32:39Z

Jarekz: Utworzono nową stronę " =Formy nieliniowości= Na poprzednich wykładach zajmowaliśmy się: * sieciami liniowymi: łatwo można dla nich sformułować i udowodnić zbieżność gradientowej r..."

2015-05-21T15:27:00Z

Utworzono nową stronę " =Formy nieliniowości= Na poprzednich wykładach zajmowaliśmy się: * sieciami liniowymi: łatwo można dla nich sformułować i udowodnić zbieżność gradientowej r..."

Nowa strona

=Formy nieliniowości=
Na poprzednich wykładach zajmowaliśmy się:
* sieciami liniowymi: łatwo można dla nich sformułować i udowodnić zbieżność gradientowej reguły uczenia. Niestety miały one ograniczenie do reprezentowania odwzorowań liniowych.
* perceptornem Rosenblatta: łatwo można było wyprowadzić dla niego regułę uczenia, wnosił nową jakość- podział przestrzeni wejściowej na rozłączne obszary decyzyjne, składanie sieci wielowarstwowych wprowadza nową jakość (możliwość konstruowania dowolnych podziałów przestrzeni wejściowej ) ale:
** dla jednej warstwy można rozwiązywać tylko problemy separowalne liniowo
** dla większej ilości warstw brak jest reguły uczenia

Problem z regułą uczenia perceptronu Rosenblatta bierze się z tego, że nie można do niej wykorzystać metod spadku gradientowego, ze względu na występującą w nim nieciągłość.

Okazuje się, że w wielu przypadkach dobrze sprawdzają się następujące dwie funkcje sigmoidalne:
* funkcja logistyczna:
:<math>y = \frac{1}{1+\exp(-\beta e)} </math>
: * pochodna: <math>\frac{dy}{de} = \beta y (1-y)</math>
: * zbiór wartości otwarty:<math>y \in (0,1)</math>
* tangens hiperboliczny
:<math>y = \tgh(\beta e) = \frac{\exp(\beta e)-\exp(-\beta e)}{\exp(\beta e) + \exp(-\beta e)} </math>
: * pochodna :<math>\frac{d y }{d e} = \beta (1+y)(1-y)</math>
: * zbiór wartości <math>y \in (-1,1)</math>
We wszystkich powyższych wzorach <math>\beta</math> to parametr odpowiadający za stromość sigmoidy, zaś <math>e</math> to pobudzenie neuronu.

= Uczenie=
== Pojedynczy neuron: reguła delta ==
Podobnie jak dla wszystkich omawianych dotychczas sieci celem uczenia neuronu nieliniowego jest taki dobór jego wag, aby zminimalizować błąd średnio-kwadratowy popełniany na ciągu uczącym.
Niech ciąg uczący będzie:
:<math>\left\{ \left(X^{(j)}, z^{(j)}\right)\right\}_{j = 1,\dots,N} </math>
Funkcja błędu to:
: <math>J(w) = \frac{1}{2} \sum_{j=1}^N\left(z^{(j)}- y^{(j)} \right)^2 = \sum_{j=1}^N J^{(j)}(w)</math>
gdzie:
:<math>y^{(j)} = f\left(e^{(j)}\right) = f \left( \sum_{i=0}^n w_i^{(j)} x_i^{(j)}\right)</math>
zaś
:<math>J^{(j)}(w) = \frac{1}{2} \left( z^{(j)} -y^{(j)}\right)^2 </math>

podobnie jak w przypadku regresji liniowej chcemy zmieniać wag w kierunku przeciwnym do kierunku gradientu funkcji kosztu, tzn. po prezentacji ''j = 1'' przykładu ''i''-ta waga zmienia się tak:
:<math>w_i^{(j+1)} - w_i^{(j)} = \Delta w_i^{(j)} = -\eta \frac{\partial J^{(j)} }{\partial w_i} =
-\eta \frac{\partial J^{(j)} }{\partial y^{(j)}} \frac{\partial y^{(j)}}{\partial w_i} = - \eta \frac{\partial J^{(j)} }{\partial y^{(j)}} \frac{\partial y^{(j)}}{\partial e} \frac{\partial e}{\partial w_i}
</math>
łatwo zauważyć, że:
: <math>\frac{\partial J^{(j)} }{\partial y^{(j)}} = - \left( z^{(j)} -y^{(j)}\right)
</math>
oraz, że:
:<math> \frac{\partial e}{\partial w_i} = x_j^{(j)}</math>
natomiast:
:<math>\frac{\partial y^{(j)}}{\partial e^{(j)}} = \frac{d f(e)}{de^{(j)}} </math>
Łącząc te wszystkie spostrzeżenia otrzymujemy:
:<math> \Delta w_i^{(j)} = \eta \frac{df(e)}{d e^{(j)}}\left(z^{(j)} - y^{(j)}\right)x_i^{(j)} = \eta \delta^{(j)}x_i^{(j)}</math>
gdzie wprowadziliśmy:
:<math>\delta^{(j)} = \frac{df(e)}{de^{(j)}} \left( z^{(j)}- y^{(j)}\right)</math>

==Uczenie nieliniowej sieci: Jak znaleźć błąd dla warstwy ukrytej?==
;Pomysł: [[Plik:Rzutowanie.png‎|thumb|right|319px]]
błąd <math>\delta_m^{(j)}</math> występujący w ''j'' − tym kroku uczenia na neuronie ''m'' rzutujemy wstecz do wszystkich neuronów, które stanowią wejście dla neuronu ''m'' − tego.
Rzutując, mnożymy błąd przez ten sam współczynnik wagowy, który w czasie propagacji ''w przód'' ważył wejście.
;Dlaczego?
;Uzasadnienie intuicyjne: Jeśli neuron warstwy ukrytej przyczynił się do powstania błędu na neuronie warstwy wyjściowej rzutując ''w przód'' przez dużą wagę, to trzeba mu zwrócić informację o błędzie proporcjonalnie do tej wagi.

;Uzasadnienie formalne:
[[Plik:Backprop_oznaczenia.png|thumb|right|319px|Oznaczenia]]
Reguła ta wynika wprost z gradientowej metody minimalizacji funkcji błędu.
Rozważmy sieć dwuwarstwową.
Dla wzorca ''j'' − tego ''k'' − ta jednostka ukryta otrzymuje pobudzenie:
:<math>e_k^{(j)} = \sum_{i \in U}w_i^{k{(j)}}x_i^{(j)}</math>
gdzie: <math> U </math> - indeksy wejść warstwy ukrytej, <math>w_i^{k{(j)}}</math> - ''i''-ta waga ''k''-tej jednostki w ''j''-tym kroku uczenia.
Jednostka ta wytwarza sygnał wyjściowy:
:<math>V_k^{(j)} = f\left( e_k ^{(j)}\right) = f\left(\sum_{i \in U} w_i^{k(j)} x_i^{(j)}\right) </math>

Jednostka wyjściowa, ''n'' − ta, otrzymuje zatem sygnał:
<math> e_n^{(j)} = \sum_{i \in Wyj} W_i^{n(j)}V_i^{(j)} = \sum_{i \in Wyj}
W_i^{n(j)}f\left(\sum_{i \in U} w_i^{k(j)}x_i^{(j)}\right)
</math>
(gdzie: <math>Wyj</math> — indeksy wejść warstwy wyjściowej, '''uwaga''': <math>e_n^{(j)} \ne e_k^{(j)}</math> dla <math> n \ne k </math> !)
i wytwarza sygnał wyjściowy:
:<math>y_n^{(j)} = f\left(e_n^{(j)}\right) = f\left(\sum_{i \in Wyj} W_i^{n(j)} f\left(\sum_{i \in U} w_i^{k(j)}x_i^{(j)}\right)\right)
</math>

Miara błędu wygląda tak:
:<math>J(\mathbf{w}) = \frac{1}{2}\sum_{n,j}\left(z_n^{(j)} - y_n{(j)}\right)^2
= \frac{1}{2}\sum_{n,j} \left(z_n^{(j)} - f\left( \sum_{i \in Wyj} W_i^{n(j)}f\left(\sum_{i \in U}w_i^{k(j)}x_i^{(j)}\right)\right) \right)^2
</math>
i jest ciągłą i różniczkowalną funkcją wszystkich wag, możemy więc ją minimalizować zmieniając wagi w kierunku przeciwnym do gradientu (<math>\mathbf{w}</math> to wszystkie wagi zarówno ''w'' jak i ''W'' ).

Dla warstwy wyjściowej otrzymujemy:
:<math> \Delta W_i^{n(j)} = -\eta \frac{\partial J^{(j)}}{\partial W_i^{n}} = \eta \left( z_n^{(j)} - y_n^{(j)}\right) \frac{df(e_n^{(j)})}{de} V_k^{(j)} = \eta \delta^{(j)} V_k^{(j)} </math>
gdzie oznaczyliśmy: <math>\delta_n^{(j)} = \left( z_n^{(j)} - y_n^{(j)}\right) \frac{df(e_n^{(j)})}{de}</math>

Dla warstwy ukrytej otrzymujemy:
[[Plik:Backprop_2.png|thumb|right|319px|Błędy w warstwie ukrytej]]
:<math>\Delta w_i^{k(j)} = -\eta \frac{\partial J^{(j)}}{\partial w_i^k} = -\eta \frac{\partial J^{(j)}}{\partial V_k }\frac{\partial V_k^{(j)}}{\partial w_i^k} =</math>
:<math> = \eta \sum_n \left(z_n^{(j)} - y_n^{(j)}\right)
\frac{df(e_n^{(j)})}{d e_n}W_i^n \frac{df(e_k^{(j)})}{de_k} x_i^{(j)} =</math>
:<math>=\eta \sum_n \delta_n^{(j)}W_i^n \frac{df(e_k^{(j)})}{de_k}x_i^{(j)} =</math>
:<math> =\eta \delta_k^{(j)} x_i^{(j)} </math>
przy czym zdefiniowaliśmy:
:<math>\delta_k^{(j)} = \frac{df(e_k^{(j)}) }{d e_k} \sum_n W_i^n \delta_n^{(j)}</math>
Widać, że wzór na zmianę wag, czy to warstwy wejściowej, czy ukrytej ma tę samą postać, różni się jedynie definicją <math> \delta</math>. Dla warstw ukrytych błąd jest sumą ważoną (wagami połączeń ''do przodu'') błędów popełnionych w wyższej warstwie.

Regułę tą można udowodnić dla dowolnej ilości warstw stosując odpowiednią ilość razy regułę łańcuchową.

== Problemy uczenia metodą wstecznej propagacji błędu ==
* Minima lokalne funkcji kosztu. W odróżnieniu od funkcji kosztu dla problemu sieci liniowych w przypadku sieci nieliniowych funkcja kosztu ma zazwyczaj wiele lokalnych minimów. Algorytm wstecznej propagacji błędu jako algorytm spadku gradientowego nie jest odporny na ich występowanie.
* Generalizacja: Uczenie z wykorzystaniem tylko jednego ciągu uczącego i reguły wstecznej propagacji błędu może prowadzić do problemów z generalizacją, czyli wynikami działania sieci na danych nie występujących w ciągu uczącym.

= Klasyczne przykłady zastosowań =

;XOR: rozwiązanie metodą wstecznej propagacji dla jednostek sigmoidalnych — jednostki są sterowane w stronę wysycenia. Czas uczenia jest bardzo długi: setki epok prezentacji całego zbioru treningowego.

;Koder: Dwuwarstwowa sieć o N wejściach, N wyjściach i M neuronach w warstwie ukrytej (M < N). Chcemy uzyskać autoasocjację czyli X(j) = Y (j).
* Praktyczne zastosowanie — kompresja np. obrazów.
* Teoretyczne — wyznaczanie możliwości sieci — problem łatwo można skalować i zmieniać jego trudność przez zmianę M/N.
[[Plik:koder.png|thumb|center|292px|Ilustracja koncepcji kodera.]]

;NETtalk: Klasyczna praca (Sejnowski i Rosenberg 1987,Complex Systems 1, 145–168): generacja ciągu fonemów z angielskiego tekstu pisanego.
* Architektura: 7 × 29 wejść kodujących 7 kolejnych liter, 80 jednostek ukrytych, 26 jednostek wyjściowych kodujacych fonemy.
* Zbiór uczący: 1024 słowa podawane w postaci par (litera,fonem)
* Efekty: po 10 epokach zrozumiała wymowa, po 50 — 95% odtwarzania zbioru treningowego, 78% na ciągłym tekście źródłowym. Porównanie stanowi system algorytmiczny DEC-talk (jest lepszy)
[[Plik:NetTalk.png‎ |thumb|center|754px|Ilustracja konstrukcji sieci NetTalk]]

;Struktura drugorzędowa białka: (Quian, Sejnowski (1988), Journal of Molecural Biology 202, 865–884).
* Wejście — ruchome okno z 13 aminokwasów.
* Na wyjściu odczytujemy prognozę struktury środkowej części okna jako spirali α, arkusza β lub innej struktury.
* Efekt: na nowym zbiorze danych dokładność predykcji 62% (w porównaniu do konkurencyjnej metody 53%)

;Rozpoznawanie celów sonarowych:(Gorman i Sejnowski (1988) Neural Network 1, 75–89) Problem: rozróżnianie sygnałów sonarowych odbitych albo od skał albo od metalowych cylindrów leżących na dnie zatoki.
* Preprocessing: transformanta Fouriera
* Architektura: 60 jednostek wejściowych i 2 wyjściowe, liczba jednostek ukrytych od 0 –24,
* Na nowych danych (generalizacja ) dla 12 jednostek ukrytych ∼ 85%; poprawa jakości do ∼ 90% po staranniejszym wybraniu zbioru treningowego.
[[Plik:sonar_epoki.png|thumb|center|290px|Wyniki różnych architektur dla zbioru uczącego]]

;Kierowanie samochodem (Pomerlau, 1989):
* Sygnał wejściowy — obraz z kamery video 30 × 32 piksle umocowanej na dachu oraz obraz 8 × 32 piksle z dalmierza kodującego odległość w skali szarości,
* warstwa ukryta 29 jednostek, wyjście 45 jednostek ułożonych w linię (środkowa jednostka kodowała jazdę na wprost, boczne — kąt skrętu odpowiednio w lewo lub w prawo).
* Zbiór treningowy: 1200 symulowanych fragmentów drogi. Uczenie: około 40 powtórzeń każdego ze wzorców.
* Efekt: sieć mogła prowadzić samochód z prędkością około 5 km/h po drodze przez zalesiony obszar wokół kampusu Carrengie-Mellon.
Ograniczenie prędkości: moc obliczeniowa komputera — sieć symulowana była na komputerze Sun-3 (metody algorytmiczne dawały prędkość o połowę mniejszą)
[[http://www.youtube.com/watch?v=5u4G23_OohI|Przykład kierowania samochodem (czas 3:25-8:38)]]

;Rozpoznawanie ręcznie pisanych kodów pocztowych(Le Cun 1989, Neural Computaion 1 541–551):
[[Plik:Pismo.png|thumb|right|390px|Schemat sieci do rozpoznawania kodów pocztowych]]
* Preprocessing: rozdzielenie kodów na po jedyncze cyfry, wyskalowanie do standardowych rozmiarów i skwantowanie na tablicę piksli 16 × 16.
* W całej sieci było w sumie 1256 jednostek i 9700 niezależnych parametrów.
* Nauka na zbiorze 7300 cyfr i test na 2000 cyfr.
* Wynik: 1% błędów dla zbioru uczącego i 5% dla testowego. Po dopuszceniu odpowiedzi ”nie wiem” błąd na zbiorze testowym 1%, ale odrzucone było 12% cyfr. Dalszą poprawę generalizacji uzyskano po usunięciu niepotrzebnych wag (99% trafności przy 9% odrzutów)

← poprzednia wersja		Wersja z 16:32, 16 lut 2017
Linia 1:		Linia 1:
		+	[[Uczenie_maszynowe_i_sztuczne_sieci_neuronowe\|powrót]]
	=Formy nieliniowości=		=Formy nieliniowości=
	Na poprzednich wykładach zajmowaliśmy się:		Na poprzednich wykładach zajmowaliśmy się:

@@ Linia 28: / Linia 28: @@
 : <math>J(w) = \frac{1}{2} \sum_{j=1}^N\left(z^{(j)}- y^{(j)} \right)^2 = \sum_{j=1}^N J^{(j)}(w)</math>
 gdzie:
-:<math>y^{(j)} = f\left(e^{(j)}\right) = f \left( \sum_{i=0}^n w_i^{(j)} x_i^{(j)}\right)</math>
+:<math>y^{(j)} = f\left(e^{(j)}\right) = f \left( \sum_{i=0}^n w_i x_i^{(j)}\right)</math>
 zaś
 :<math>J^{(j)}(w) = \frac{1}{2} \left( z^{(j)} -y^{(j)}\right)^2 </math>
@@ Linia 47: / Linia 47: @@
 gdzie wprowadziliśmy:
 :<math>\delta^{(j)} = \frac{df(e)}{de^{(j)}} \left( z^{(j)}- y^{(j)}\right)</math>
 ==Uczenie nieliniowej sieci: Jak znaleźć błąd dla warstwy ukrytej?==

@@ Linia 68: / Linia 68: @@
 Jednostka wyjściowa, ''n'' − ta, otrzymuje zatem sygnał:
-<math> e_n^{(j)} = \sum_{i \in Wyj} W_i^{n(j)}V_i^{(j)} = \sum_{i \in Wyj}
+:<math> e_n^{(j)} = \sum_{i \in Wyj} W_i^{n(j)}V_i^{(j)} = \sum_{i \in Wyj}
 W_i^{n(j)}f\left(\sum_{i \in U} w_i^{k(j)}x_i^{(j)}\right)
 </math>
-(gdzie: <math>Wyj</math> — indeksy wejść warstwy wyjściowej, '''uwaga''': <math>e_n^{(j)} \ne e_k^{(j)}</math> dla <math> n \ne k </math> !)
+:(gdzie: <math>Wyj</math> — indeksy wejść warstwy wyjściowej, '''uwaga''': <math>e_n^{(j)} \ne e_k^{(j)}</math> dla <math> n \ne k </math> !)
 i wytwarza sygnał wyjściowy:
 :<math>y_n^{(j)} = f\left(e_n^{(j)}\right) = f\left(\sum_{i \in Wyj} W_i^{n(j)} f\left(\sum_{i \in U} w_i^{k(j)}x_i^{(j)}\right)\right)

← poprzednia wersja		Wersja z 15:32, 21 maj 2015
Linia 1:		Linia 1:
−
	=Formy nieliniowości=		=Formy nieliniowości=
	Na poprzednich wykładach zajmowaliśmy się:		Na poprzednich wykładach zajmowaliśmy się:

Uczenie maszynowe i sztuczne sieci neuronowe/Wykład 4 - Historia wersji

Jarekz: /* Pojedynczy neuron: reguła delta */

Jarekz o 16:32, 16 lut 2017

Jarekz: /* Uczenie nieliniowej sieci: Jak znaleźć błąd dla warstwy ukrytej? */

Jarekz o 15:32, 21 maj 2015

Jarekz: Utworzono nową stronę " =Formy nieliniowości= Na poprzednich wykładach zajmowaliśmy się: * sieciami liniowymi: łatwo można dla nich sformułować i udowodnić zbieżność gradientowej r..."