Uczenie maszynowe i sztuczne sieci neuronowe/Wykład 3

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.

Kod symulujący przykładowy perceptron prosty 

# -*- coding: utf-8 -*-
import numpy as np
import pylab as py
import matplotlib.animation as animation



class Perceptron(object):
    """Perceptron Rosenblatta"""
    def __init__(self, w, w0):
        self.w = np.array(w)
        self.w0 = np.array(w0)
	self.first_plot = True

    def ucz(self, X, Z, eta):
        delta = Z - self.licz(X)
        self.w += eta*delta*X
        self.w0 += eta*delta
        return delta
    
    def licz(self, X):
        e = np.sum(self.w*X) + self.w0
        if e >= 0:
            y = 1
        else:
            y=0
        return y
    
def rysuj(data):
    linia.set_ydata(data)
    return linia,    
    
def licz_wynik():
    global p, x, X, Z
    delta=1
    y = np.zeros(len(x))
    #while delta > 0:
    delta = 0
    for j  in range(len(X)):
        d = p.ucz( X[j,:], Z[j], eta) # uczymy neuron j-tego elementu w ciagu uczacym
        delta += np.abs(d)         # sumujemy wartosci bezwzgledne bladow
	y[0] = (-p.w[0]*x[0] - p.w0) / p.w[1]
	y[1] = (-p.w[0]*x[1] - p.w0) / p.w[1]
    print 'zla klasyfikacja ' +str(delta) +' na '+ str(len(Z)) + ' punktow '
    yield y


    	  
	    
p = Perceptron(w = [0.1, 0.6], w0 = -0.4 )
eta=0.1
X=np.array([[1, 1], [3, 3],[4,1],[2, 3], [3, 4], [1.2, 3.2]])
Z=np.array([1, 1,1, 0, 0, 0, ])



xmin=-5
xmax=5
red  = np.where( Z>0 )
blue = np.where( Z<=0)
fig1 = py.figure(1)	
py.plot(X[blue,0], X[blue,1],'bo' , X[red, 0], X[red,1] ,'ro')
py.xlim([xmin-2, xmax+2])
py.ylim([0-2,5+2])
x = np.array([xmin, xmax])
y = (-p.w[0]*x - p.w0) / p.w[1]
linia, = py.plot(x,y)

line_ani = animation.FuncAnimation(fig1, rysuj, licz_wynik,   interval=100)#, blit=True,repeat=False)	

py.show()

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]