1Powtórzenie WprowadzeniedoSieciNeuronowych—Laboratorium02—Perceptronprostycd

Projekt pn. „Wzmocnienie potencjału dydaktycznego UMK w Toruniu w dziedzinach matematyczno-przyrodniczych”

realizowany w ramach Poddziałania 4.1.1 Programu Operacyjnego Kapitał Ludzki

Wprowadzenie do Sieci Neuronowych — Laboratorium 02 — Perceptron prosty cd

Maja Czoków, Jarosław Piersa 2012-10-10

1 Powtórzenie

1.1 Algorytm uczenia perceptronu

Dane: Perceptron o n wejściach, k przykładów uczących E¹...E^k wraz z poprawnymi odpowiedziami T¹...T^k. Zakładamy, że funkcja aktywująca ma postać znakową. W tej sytuacji dodatkowym parametrem uczącym jest wartość progu p.

Wynik: Wartości wag wi oraz progu p które dają optymalną klasyfikację.

1. Przypisujemy wagom i progowi małe losowe wartości wokół 0, przypisujemy takiemu układowi wag zerowy czas życia, startowy zestaw zapamiętujemy jako „rekordzistę”,

2. Przebiegamy przykłady losując z listy

3. Dla wybranego przykładu E^j sprawdzamy, czy E^j jest dobrze klasyfikowany,

• Jeśli tak, zwiększamy mu czas życia o jeden. Jeżeli jest to wynik lepszy niż u dotychczasowego rekordzisty, zapominamy go (dotychczasowego rekordzistę) i zapisujemy bieżący układ wag jako nowego rekordzistę. Wracamy do 2.

• Jeśli nie, to

wi:= wi+ η · ERR · E^j_i θ := θ − ERR

Nowo-powstałemu układowi wag przypisujemy zerowy czas życia. Wracamy do 2.

4. Algorytm kończymy po przebiegnięciu odpowiedniej liczby iteracji. Zwracamy najbardziej żywotny zestaw wag (tj.

rekordzistę).

1.2 Uzasadnianie wnioskowania

Dane: Nauczony perceptron prosty z funkcją progową, próg p, wejście u = (u1, ..., un).

Wynik: Uzasadnienie klasyfikacji zwróconej na przykładzie u tj. najmniej liczna lista cech, które charakteryzują u i mają największy wpływ na klasyfikację.

Uwaga: Algorytm jest mutacyjny, tj. modyfikuje próg neuronu. Sugerowane jest operowanie na kopii parametrów.

1. Obliczamy odpowiedź perceptronu o na przykładzie u.

2. Przypisujemy p := θ (kopia progu, p := −x0· w0 w wypadku biasu).

3. Przypisujemy uzasadnienie = ”” (pusty napis).

4. Oznaczamy wszystkie cechy jako niewykorzystane.

5. Znajdujemy czynnik kluczowy tj. u_i takie, że

• u_iw_io > 0 tj. cecha wspiera wynikową odpowiedź,

• |wi| ma największą wartość spośród wszystkich ui, które wspierają odpowiedź o,

• ui jeszcze nie był użyty jako fragment uzasadnienia w poprzednich krokach (niewykorzystana).

6. Sprawdź czy

|wi| > X

l6=ii ulniewykorzystany

|wl| + p,

• jeżeli tak, to dodaj u_i do uzasadnienia i zwróć gotowy zestaw cech:

uzasadnienie+ = “ bo ui= (..).“

• jeżeli nie, to dodaj ui do uzasadnienia:

uzasadnienie+ = “ bo ui= (..) oraz “ p = p − u_iw_i

Po czym oznaczamy jednostkę ui jako wykorzystaną i wracamy do 5.

7. UWAGA: JeżeliP

iwiui= p to uzasadnienie nie będzie możliwe.

Rysunek 1: Uzasadnianie wnioskowania — wybór „najcięższych” argumentów.

1.3 Maszyny liniowe (Multiclass linear classifier )

Maszyna liniowa składa się z n wejść, l „perceptronów”,każdy przypisany do swojej kategorii. Perceptrony mają swoje kolejne indeksy i te same wejścia. Oznacza to,to że ML ma łącznie nl wag (z progami: (n+1)l wag), po n dla każdego z l perceptronów (z progami: po n + 1). Będziemy je oznaczać poprzez w_ij, gdzie i = 0, 1..n jest indeksem wejścia, natomiast j = 1..l jest indeksem perceptronu. Uznajemy ponadto, że we wszystkich perceptronach funkcja aktywująca jest identycznością

f (x) = x To jest każdy z perceptronów zwraca wyłącznie sumę ważoną

outj=

n

X

i=0

wijxi (1)

Odpowiedzą całej maszyny liniowej jest indeks perceptronu, który zwrócił największą wartość outj.

O = {j : ∀k=1..l outk≤ outj} (2)

Maszyna linowa zwraca kategorię danych wejściowych x1..x_n, ale kategoryzacja nie musi być binarna.

out

Rysunek 2: Schemat maszyny liniowej

1.4 Algorytm Uczenia Maszyny Liniowej

Dane: zestaw przykładów uczących E^j, j = 1..k oraz poprawnych odpowiedzi T^j, j = 1..k.

Wynik: wagi w_ij, dla których sieć daje poprawne klasyfikacje.

1. Przypisujemy wagom małe losowe wartości wokół 0, 2. Przebiegamy przykłady losując z listy,

3. Dla wybranego przykładu E^j sprawdzamy, czy E^j jest dobrze klasyfikowany,

• Jeśli tak, wracamy do 2.

• Jeśli nie (tzn. jest kategoria p a miała być q), to korygujemy wagi neurony p-tego i q-tego w_ip+ = E_i^j

wiq− = E_i^j Wracamy do 2.

4. Algorytm kończymy po przebiegnięciu odpowiedniej liczby iteracji. Dodajemy modyfikację kieszeni i zapadki (tj.

zapamiętywanie najbardziej żywotnych zestawów wag).

2 Zadania

2.1 Zadanie 1. Klasyfikacja punktów na R

• Napisz (zmodyfikuj z poprzednich zajęć) w Octavie / Matlabie funkcję implementującą działanie perceptronu. Funkcja za argument powinna przyjmować wektor dwóch danych wejściowych oraz wektor wag w tym w₀ (oraz ewentualnie próg, jeżeli nie jest on zawarty w wagach).

x = [1 , 2];

w = [1 , 2 , 3];

a = p e r c ( x , w );

• Wygeneruj dwie chmury punktów na R² z różnymi kategoriami N = 20;

x1 = r a n d n(1 , N ) + 2 ; x2 = r a n d n(1 , N ) -2;

y1 = r a n d n(1 , N ) + 3 ; y2 = r a n d n(1 , N ) -1;

C1 = o n e s (1 , N );

C2 = - o n e s (1 , N );

• Wyświetl wygenerowane dane h o l d off ;

p l o t( x1 , y1 , ’ r + ’);

h o l d on ;

p l o t( x2 , y2 , ’ bo ’);

EX = [ x1 , x2 ];

EY = [ y1 , y2 ];

C = [ C1 , C2 ];

• Zaimplementuj SPLA (plik spla.m). Uwaga! Jeżeli nie wiadomo czy dane są separowalne, to należy korzystać z wersji pocket algorytmu.

f u n c t i o n w a g i = s p l a ( EX , EY , C , T = 1 0 0 0 0 )

% w a g i l o s o w e w = r a n d n(1 ,3);

for i =1: T

% l o s u j e m y p r z y k l a d

j = f l o o r(r a n d()*l e n g t h( C ) ) + 1 ;

% o b l i c z a m y a k t y w a c j e

out = p e r c ([ EX ( j ) , EY ( j )] , w );

if out == C ( j )

% n a s t e p n y p r z y k l a d e l s e

% k o r e k c j a wag err = C ( j ) - out ;

w += err .* [1 , EX ( j ) , EY ( j )];

end % if

end % for w a g i = w ; end % f u n c t i o n

• Oblicz klasyfikację nauczonego perceptronu na danych EX, EY Out = [];

for i =1:l e n g t h( EX ) E = [ EX ( i ) , EY ( i )];

Out = [ Out , p e r c ( E , w a g i ) ];

end

• Wydrukuj nauczoną klasyfikację

% w y b i e r a m y te , k t o r e m a j a o d p o w i e d z d o d a t n i a I P o s = f i n d( Out > 0 ) ;

% te , k t o r e m a j a o d p o w i e d z u j e m n a I N e g = f i n d( Out < = 0 ) ;

h o l d off ;

p l o t( EX ( I P o s ) , EY ( I P o s ) , ’ r + ’);

h o l d on ;

p l o t( EX ( I N e g ) , EY ( I N e g ) , ’ bo ’);

• Na podstawie nauczonych wag oblicz postać i wyświetl prostą separującą. Przydatne funkcjetext(), sprintf (), legend().

• Zmodyfikuj dane uczące, aby obie klasy nieco na siebie nachodziły (zjawisko nazywane jest overlapping). Uruchom algorytm SPLA na nich. Wyciągnij wnioski.

• Wygeneruj cztery chmury punktów uczących. Połącz je w klasy wg funkcji logicznych AND, OR, XOR. Wykonaj uczenie na takich danych, np.

– problem AND (x₁= −1, x₂= −1, E = −1), (−1, 1, −1), (1, −1, −1), (1, 1, 1)

– problem OR (−1, −1, −1), (−1, 1, 1), (1, −1, 1), (1, 1, 1) – problem XOR (−1, −1, −1), (−1, 1, 1), (1, −1, 1), (1, 1, −1)

Wyciągnij wnioski.

• Dodaj modyfikację kieszonki i zapadki, naucz perceptron zmodyfikowanym algorytmem na różnych zestawach.

2.2 Zadanie 3*. SPLA cd.

(* dla chętnych) Napisz program, który wyświetla zmieniającą się klasyfikację na fragmencie płaszczyzny podczas uczenia perceptronu. Pomocne funkcje: axis(), sleep(), print().

2.3 Zadanie 4. Maszyna liniowa

Zaimplementuj maszynę liniową (linear multi-classifier)

• Wygeneruj chmurę przykładów uczących podzielonych na trzy kategorie (wsk. zmodyfikuj punkt 2.1)

• Wczytaj przygotowane dane z pliku (kolejno: x, y, odpowiedź) A = l o a d( ’ ./ zad2 -7 - - m u l t i c l a s s . txt ’);

EX = A (: , 1);

EY = A (: , 2);

C = A (: , 3) +1; % z m i e n i a m y z 0 ,1 ,2 na 1 ,2 ,3 p l o t( EX , EY , ’ b + ’)

• Zaimplementuj maszynę liniową (wsk. wagi będą tablicą o wymiarze ilosc kategorii × ilosc wejsc).

f u n c t i o n ret = ml ( x , w a g i ) s = w a g i * x ’;

m = max( s );

ret = f i n d( s >= m );

end

• zmodyfikuj kod tak aby uwzględniał również bias w_0,∗

• przetestuj maszynę:

w a g i = r a n d n(3 ,2);

j = 1;

x = [ EX ( j ) , EY ( j )];

ml ( x , w a g i )

• zaimplementuj algorytm uczenia:

f u n c t i o n w a g i = u c z e n i e _ m l ( EX , EY , C ) T = 1 0 0 0 0 ;

% w a g i l o s o w e w a g i = r a n d n(3 ,2);

for i =1: T

% w y l o s u j p r z y k l a d

j = f l o o r(r a n d()*l e n g t h( EX ) + 1 ) ; x = [ EX ( j ) , EY ( j )];

o = ml ( x , w a g i );

if ( o == C ( j ))

% ok , nic nie r o b i m y e l s e

% w z m a c n i a m y te , k t o r e byc p o w i n n y w a g i ( C ( j ) ,:) += x ;

% o s l a b i a m y te , k t o r e sa w a g i ( o ,:) -= x ;

end % if end % for end % f u n c t i o n

• Dopisz do algorytmu kieszonkę i / lub zapadkę.

• Oblicz klasy na naucznych wagach:

Out = [];

for i =1:l e n g t h( EX ) x = [ EX ( i ) , EY ( i )];

Out = [ Out ; ml ( x , w a g i )];

end

• Wyświetl nauczoną kategoryzację I1 = f i n d( Out == 1);

I2 = f i n d( Out == 2);

I3 = f i n d( Out == 3);

h o l d off ;

p l o t( EX ( I1 ) , EY ( I1 ) , ’ 1 o ’);

h o l d on ;

p l o t( EX ( I2 ) , EY ( I2 ) , ’ 2+ ’);

p l o t( EX ( I3 ) , EY ( I3 ) , ’ 3^ ’);

• Dostosuj algorytm aby działał dla wersji z biasem, naucz ponownie taki system i porównaj wyniki.

3 Zadania programistyczne (do wyboru)

3.1 Zadanie 1. Autoasocjator graficzny

Zadanie polega na zastosowaniu perceptronów i algorytmów uczenia do konstrukcji autoasocjatora graficznego tj. układu, który jest w stanie nauczyć się obrazów oraz usunąć szumy jeżeli takie pojawią się na wejściu. W efekcie dając na wejściu obraz, który nie jest żadnym z wzorców uczących, program powinien wygenerować ten, który zna i jest najbardziej podobny do wejścia.

Działanie:

• na wejściu dany jest zaszumiony obraz (wcześniej nauczony)

• układ ma tyle perceptronów ile pikseli na obrazie

• każdy perceptron czyta wszystkie piksele z obrazu wejściowego i zwraca wartość kontrolowanego piksela wyjściowego (zapalony lub nie)

• wynikowy obraz powstaje z odpowiedzi wszystkich perceptronów, poprawnie naucozna sieć powinna odzyskać orygi- nalny obraz usuwając szum

Uczenie:

• dla każdego perceptronu / piksela: wejściem są wszystkie wzorcowe obrazy, poprawną odpowiedzą wartość czy piksel przy danym obrazie powinien być zapalony czy zgaszony

• dodatkowo wskazane jest uczyć na zaszumionych kopiach wzorcowych obrazów Ciekawe rozszerzenia i alternatywy:

• Autoasocjator symboliczny / wektorowy: zamiast na pikselach operuje na fragmentach obrazu, np kresce poziomej, pionowej, skośnej, półkolu, kropce itp. Na przykład litera T jest połączeniem kreski pionowej wycentrowanej oraz kreski poziomej na górze obrazu (i wszystko inne wyłączone), Litera L — kreska pionowa z lewej i pozioma na dole, O

— półkola z lewej i prawej oraz z góry i dołu, D — półkole z prawej i kreska pionowa wycentrowana, X — dwie kreski skośne etc.

• Autoasocjator działający na trzech kanałach (RGB)

Rysunek 3: Konstrukcja autoasocjatora graficznego.

3.2 Zadanie 2. Automatyczny oceniacz programów

Czasami obiektom nie można przypisać cech numerycznych, a jedynie symboliczne, które są kodowane na wartości numeryczne (np. +1 — cecha obecna, −1 cecha nieobecna). Rozważmy opis programu zaliczeniowego z sieci neuronowych. Jego lista cech może obejmować np:

• Czy program w ogóle działa?

• Czy program daje wyniki wyglądające na poprawne?

• Czy program ma interfejs graficzny?

• Czy program został oddany w trakcie zajęć?

• Czy program sam siebie klasyfikuje jako zaliczony?

• Czy program zawiera wyczerpujące komentarze w kodzie?

• Czy grafy / sieci / ilości wejść są ustalone na sztywno i trudne do zmiany (zauważmy, że jest to cecha charakterystyczna dla źle napisanych programów, waga odpowiadająca temu wejściu powinna być ujemna)?

• Czy program wyświetla tylko klasyfikację pomijając uzasadnienie (patrz uwaga wyżej)?

• Czy program został napisany w „normalnym” języku programowania (co to jest „normalny” język pozostawiamy gestii sprawdzającego lub... innego klasyfikatora symbolicznego)?

• Czy program sam jest w stanie wygenerować listę programów uczących i nauczyć się na niej poprawnej klasyfikacji?

• Czy autor programu ma więcej pomysłów niż autor zadania i dodał coś od siebie?

Napisz program, który na wejściu otrzymuje listę cech programu i dokonuje binarnej oceny (zaliczony lub niezaliczony) oraz wyświetla uzasadnienie, tzn. które z cech mają największy wpływ na końcową ocenę.

• Głównym punktem ocenianym w tym zadaniu jest nie klasyfikacja, ale jej uzasadnienie.

• Lista powyższa została wymyślona na potrzeby zadania i po kilku kawach, ale zdradza jakie pytania mogą paść podczas sprawdzania programów.

• (dla ambitnych) Rozważ jak można dostosować program aby dokonywał i uzasadniał kategoryzację na trzy oceny:

niezaliczony, zaliczony, wybitnie zaliczony.

• Zamiast oceniacza programów można napisać program oceniający: książki, samochody, inne programy oceniające, wykładowców, komputery, jakość kawy z ekspresu... Wszelkie przejawy kreatywności mile widziane.