Uczenie maszynowe i sztuczne sieci neuronowe/Wykład 3

Z Brain-wiki

powrót

Nieliniowość

Nowością wprowadzoną przez Perceptron(Rosenblatt 1958) w stosunku do sieci MADALINE, było zastosowanie elementu nieliniowego. W perceptronie wyjście neuronu:

[math] y = f(e)[/math]
Model neuronu z nieliniowością

gdzie pobudzenie

[math] e = \sum_{i=1}^n w_ix_i + w_0 = \sum_{i=0}^n w_ix_i \quad \Leftarrow x_0 := 1 [/math]


Pobudzenie neuronu w postaci ważonej sumy wejść nie jest jedynym możliwym, mogą to być np.:

[math]e^{(j+1)} = e^{(j)} + \sum_{i=0}^n w^{(j)}x^{(j)}[/math]

lub

[math]e = \prod_{i=1}^n w_ix_i[/math]

Dla własności neuronu największe znaczenie ma jednak forma nieliniowości [math]f(.)[/math].

Perceptron Rosenblatta

Najprostsza pojęciowo postać nieliniowości:

Nieliniowa funkcja aktywacji w perceptronie Rosenblatta
[math]y = \left\{ \begin{array}{lcl} 1 \quad & \text{dla} & e \ge 0\\ 0 \quad & \text{dla} & e \lt 0 \end{array} \right. [/math]

Interpretacja geometryczna: perceptron prosty działa jak dyskryminator liniowy.

[math] x \;jest\; klasy \left\{ \begin{array}{l} 1 \\ 0 \end{array} \right\} jesli \left\{ \begin{array}{l} y = 1, e \ge 0\\ y = 0, e \lt 0 \end{array} \right\} [/math]

Obszar, w którym perceptron zwraca 1 — podejmuje decyzję tak jest ograniczony tworem o równaniu:

[math] \sum_{i=1}^n w_i x_i + w_0 = 0 [/math]

Dla n = 2 jest to prosta, dla n = 3 płaszczyzna, w ogólności rozmaitość liniowa stopnia n − 1 hiperpłaszczyzna.

Przykład

Rozważmy perceptron z trzema wagami [math]w = [-6, 2, 3][/math] pobudzenie neuronu:

[math]e = W X = [-6,2,3] \left[ \begin{array}{l} 1\\ x_1 \\ x_2 \end{array} \right] = -6 + 2x_1 + 3x_2 [/math]
Podział przestrzeni wejść na podprzestrzenie odpowiadające klasyfikacji jako "0" bądź "1"

We właściwej przestrzeni wejść(tzn. [math][x_1,x_2][/math]) hiperpowierzchnia podejmowania decyzji jest prostą o równaniu:

[math]2x_1 + 3x_2 - 6 = 0[/math]

Obcięty wektor wag [math]\tilde w = [2, 3][/math] jest prostopadły do prostej podejmowania decyzji. Wektor wag jest skierowany w stronę, gdzie y = 1.

Dobieranie wag perceptronu prostego

Wagi perceptronu prostego można dobrać na dwa sposoby:

  • możemy obliczyć wagi neuronów lub
  • znaleźć je w procesie iteracyjnego uczenia.
Obliczanie

Korzystamy z tego, że wektor w jest ortogonalny do hiperpłaszczyzny podejmowania decyzji, zatem musi spełniać równanie:

[math]w x = 0 \rightarrow \sum_{i=1}^n w_i x_i + w_0 = 0 [/math]

także "obcięty" wektor wag [math]\tilde w = [w_1,\dots, w_n][/math] jest ortogonalny do "obciętych" wektorów wejściowych [math]\tilde x = [x_1,\dots,x_n]^T[/math] bo:

[math]\forall_{ a,b}\quad w x^{(a)} - w x^{(b)} = 0[/math]

zatem

[math]\forall_{ a,b}\quad (\tilde w \tilde x^{(a)} +w_0) - (\tilde w \tilde x^{(b)} +w_0) = \tilde w\tilde x^{(a)} - \tilde w \tilde x^{(b)} = 0[/math]

Aby powyższa równość zachodziła musi zachodzić:

[math]\forall_{ a}\quad \tilde w \tilde x^{(a)} = 0[/math]

Przykład: Bramka NAND

Obliczmy wagi perceptronu realizującego funkcję logiczną NAND. Jej tabela wartości logicznych jest następująca:

[math]x_1[/math] 0 0 1 1
[math]x_2[/math] 0 1 0 1
[math]y[/math] 1 1 1 0

Spójrzmy na reprezentację graficzną:

Reprezentacja graficzna funkcji NAND

Można zaproponować następującą prostą podejmowania decyzji:

[math] x_1 + x_2 - 1.5 = 0 [/math]

wektor wag [math][w_1 , w_2 ][/math] jest prostopadły do tej prostej i skierowany w stronę gdzie [math]y = 1[/math], więc:

[math] [w_1 , w_2 ] = [-1, -1][/math]

i wybieramy

[math]w_0 = 1.5[/math].

Ostatecznie [math]w = [1.5, -1, -1][/math]

Uczenie perceptronu

Algorytm uczenia perceptronu jest formalnie bardzo podobny do algorytmu spadku gradientowego. Mamy ciąg uczący:

[math] \left\{ X^{(j)}, z^{(j)} \right\}_{j=1,\dots,M}[/math]
Ilustracja zmiany wag perceptronu zgodnie z regułą "delta"

i regułę zmiany wag po zaprezentowaniu j-tego przykładu (reguła ta nazywana jest "regułą delta"):

[math]W^{(j+1)} = W^{(j)} + \eta\delta^{(j)}X^{(j)}[/math]

gdzie [math]\delta^{(j)}[/math] jest błędem perceptronu dla j-tego przykładu:

[math]\delta^{(j)} = z^{(j)} - y^{(j)}[/math]

Istotną różnicę stanowi fakt, że:

[math] y = \{0,1\}[/math],

a co za tym idzie błąd może przyjmować tylko wartości dyskretne:

[math]\delta = \{-1,0,+1\}[/math]

Dlaczego ten algorytm działa?

Ponieważ wejścia i wyjścia mogą przyjmować tylko kilka wartości możemy prześledzić wszystkie przypadki. Są tylko 4 możliwości zmiany wag:

[math]z^{(j)}[/math] [math] y^{(j)}[/math] [math]\delta^{(j)}[/math] [math]\Delta W^{(j)}[/math] wkład do pobudzenia od i-tej współrzędnej po korekcie wag
0 0 0 (dobrze) 0 bez zmian
1 1 0 (dobrze) 0 bez zmian
0 1 -1 (odpowiedź za duża) [math]-\eta X^{(j)}[/math] [math](w_i - \eta x_i) x_i = w_i x_i - \eta x_i^2[/math]
1 0 1 (odpowiedź za mała) [math] \eta X^{(j)}[/math] [math](w_i + \eta x_i) x_i = w_i x_i + \eta x_i^2[/math]

Widać, że zawsze zmiana wagi (o ile [math]\eta[/math] nie jest zbyt duża) prowadzi w taką stronę aby po ponownym podaniu tego samego przykładu odpowiedź była bliższa pożądanej.

Ograniczenia perceptronu prostego

Ograniczeniem perceptronu prostego jest fakt, że za jego pomocą można rozwiązać tylko problemy separowalne liniowo. Co to oznacza zobaczmy na poniższym przykładzie:

Ilustracja problemu, który jest (AND) i nie jest (XOR) separowalny liniowo

Nowe możliwości: wielowarstwowe sieci perceptronów prostych

Co dwie warstwy neuronów nieliniowych to nie jedna :-) Jedna warstwa perceptronów prostych na swoim wyjściu prezentuje zestaw podziałów przestrzeni hiperpłaszczyznami - każdy neuron jeden podział.

  • Co się stanie jeśli wyjście tej warstwy wpuścimy na wejście następnej warstwy?
Przykładowe rozwiązanie problemu XOR przez dwie warstwy perceptronów prostych

Problem znalezienia wag w ogólności nie jest tu prosty. Dla XOR można go zapisać następująco:

[math] f \left([v_1\; v_2] \cdot f\left( \left[ \begin{array}{cc} w_{11} & w_{12} \\ w_{21} & w_{22} \end{array} \right] \cdot \left[ \begin{array}{cccc} 0&1&0&1 \\ 0&0&1&1 \end{array} \right] + \left[ \begin{array}{c} w_{10}\\ w_{20} \end{array} \right] + v_3 \right) \right) = [0 \;1\; 1\; 0] [/math]