Spis treści 1 Instrukcje 1.1 Hipoteza 1.2 Parametry 1.3 Wyniki 2 Kod 3 Walidacja 3.1 Zastosowanie w naszym przykładzie 3.1.1 Krzywa ROC Instrukcje W tym ćwiczeniu zbudujemy klasyfikator bazujący na regresji logistycznej. Jego zadaniem będzie określanie prawdopodobieństwa przyjęcia kandydata na studia na podstawie wyników z dwóch egzaminów maturalnych (każdy przeskalowany na zakres 0-100%): z matematyki i z biologii. Hipotetyczne dane znajdują się w pliku Plik:Reg log data1.txt. Dla przypomnienia: Hipoteza w regresji logistycznej ma postać:. ze względu na stabilność numeryczną obliczeń dobrze jest ograniczyć zakres zmienności exp np do zakresu [1e-8, 1e+8]: f = exp(x) if f < 1e-8: f = 1e-8 if f>1e8: f = 1e8 Parametry parametry regresji znajdujemy przez maksymalizację funkcji log-wiarygodności:
W tym ćwiczeniu zrobimy to za pomocą funkcji optymalizacyjnych z modułu scipy.optimize[1]. Wynikają z tego dwie konsekwencje: 1. Funkcje te są przystosowane do szukania minimów funkcji celu. Musimy więc podawać im jako argumenty funkcję minus log-wiarygodności 2. Niektóre algorytmy mogą działać szybciej jeśli zaimplementujemy jawnie postać pochodnej: Wyniki Wyniki regresji logistycznej możemy odbierać na dwa sposoby: Kod obliczyć wartość hipotezy dla badanego wejścia i dopasowanych parametrów: miara ta ma interpretację prawdopodobieństwa przynależności wejścia do klasy 1 dopisać funkcję wykonującą klasyfikację, tzn. porównanie wartości hipotezy z 1/2. Dla wartości hipotezy > 1/2 klasyfikacja zwraca 1, w przeciwnym razie 0. Ten kod pomoże Ci zapoznać się z regresją logistyczną. W tym celu będziesz misiał uzupełnić kody funkcji: sigmoida funkcjakosztu predykcja funkcjakosztureg Proponuję robić to stopniowo w miarę jak będę sie pojawiać wywołania tych funkcji. # -*- coding: utf-8 -*- # #importujemy potrzebne moduły i klasy import matplotlib matplotlib.use('tkagg') import numpy as np import pylab as py import scipy.optimize as so #=========================================== # definicje funkcji, które trzeba uzupełnić: #=========================================== def hipoteza(x, theta): '''ta funkcja zwraca wartość hipotezy dla danego wejścia x i parametrów
theta''' # zaimplementuj hipotezę dla regresji logistycznej zgodnie ze wzorami z wykładu: #http://brain.fuw.edu.pl/edu/index.php/uczenie_maszynowe_i_sztuczne_sieci_neu ronowe/wyk%c5%82ad_6#hipoteza # return h pass def funkcjalogwiarygodnosci(theta, X, y): '''Ta funkcja oblicza wartość funkcji log-wiarygodności dla regresji logistycznej używając theta jako parametrów oraz X i y jako zbioru uczącego''' # zaimlementuj funkcję l(theta) z wykładu: # http://brain.fuw.edu.pl/edu/index.php/uczenie_maszynowe_i_sztuczne_sieci_neur onowe/wyk%c5%82ad_6#funkcja_wiarygodno.c5.9bci ''' l=0.0 for j in range(len(y)): h = hipoteza(x[j,:],theta) l +=... return l''' pass def minusfunkcjalogwiarygodnosci(theta, X, y): return (-1.)*funkcjaLogWiarygodnosci(theta, X, y) def pochodnalogwiarygodnosci(theta, X, y): '''ta funkcja oblicza wartość pochodnej funkcji log-wiarygodności dla podaanych wartości theta, X i y''' # zaimplementuj wzory na dl/dtheta z # http://brain.fuw.edu.pl/edu/index.php/uczenie_maszynowe_i_sztuczne_sieci_neur onowe/wyk%c5%82ad_6#funkcja_wiarygodno.c5.9bci ''' dl_dtheta = np.zeros(len(theta)) for i in range(len(theta)): for j in range(len(y)): dl_dtheta[i] +=... return dl_dtheta ''' pass def minuspochodnalogwiarygodnosci(theta, X, y): return (-1)*pochodnaLogWiarygodnosci(theta, X, y)
def klasyfikacja(testx, theta): ''' Ta funkcja zwraca wynik klasyfikacji przykładu testx przy parametrach theta. Po obliczeniu hipotezy, jeśli otrzymane prawdopodobieństwo jest większe niż 0.5 to zwraca 1 w przeciwnym wypadku zwraca 0''' pass ##################################################################### # definicje funkcji pomocniczych, których nie musisz modyfikować #====================================================== def rysujdanegrup(x, y, marker, xlabel, ylabel,legend_list): '''X - macierz wartości wejściowych zorganizowana tak, że kolejne przykłady są w wierszach, kolumny to kolejne wynmiary wejścia, y - wektor określający przynależność do grupy, indeksy tego wektora odpowiadają wireszom macierzy X, marker - zestaw markerów do oznaczania elementów grup, markerów powinno być tyle ile jest grup''' p=[] for g in np.unique(y): g = int(g) tmp =py.plot(x[np.where(y==g),],x[np.where(y==g),1],marker[g]) p.append(tmp[]) py.legend(p,legend_list) # Dodajemy napisy py.xlabel(xlabel) py.ylabel(ylabel) def rysujgranice(theta, X, y, marker, xlabel, ylabel,legend_list): rysujdanegrup(x, y, marker, xlabel, ylabel,legend_list) # granica między obszarami dana jest równaniem # theta^t x = 0 x_plot = np.array([np.min(x[:,1]), np.max(x[:,1])]) y_plot = -1./theta[2]*(theta[1]*x_plot + theta[]) py.plot(x_plot,y_plot,'b') #===================================================
######################### Program ################################# # Wczytanie danych # Pierwsze dwie kolumny zawierają wyniki egzaminów, # trzecia kolumna zawiera etykietę (przynależność do grupy) data = np.loadtxt('reg_log_data1.txt',delimiter=',') X = data[:, [, 1]] y = data[:, 2] ## ==================== Część1: Rysunki ==================== # Zawsze dobrze jest pooglądać dane aby nabrać wyczucia do problemu print 'rysujemy dane: "+" oznacza przykłady z gdzie y = 1 zaś "o" te z y = 0' rysujdanegrup(x, y,marker = ('bo','r+'),xlabel='wynik z matematyki', ylabel='wynik z biologii',legend_list=(u'nie przyjęty',u'przyjęty')); py.show() ## ============ Część 2: Obliczamy funkcję kosztu i gradient ============ # W tej części maksymalizujemy funkcję log-wiarygodności dla regresji logistycznej # Aby to zrobić musisz uzupełnić kody w funkcjach: # hipoteza # funkcjalogwiarygodnosci # pochodnalogwiarygodnosci # Szkielety tych funkcji znajdują sie na początku tego pliku # Teraz trzeba zmodyfikować macierz X i dodać jej z lewej strony kolumnę jedynek odopwiadającą # parametrow theta[0] N = len(y) # ilość przykładów w zbiorze uczącym XX = np.concatenate((np.ones((n,1)), X),axis = 1) # rozmiar wejścia rozszerzonego o jedynki xdim = XX.shape[1] # IInicjalizujemy parametry: theta0 = np.zeros((xdim, 1)); # Oblicz funkcje log-wiarygodności i jej pochodną dla danych początkowych logwiar = funkcjalogwiarygodnosci(theta0, XX, y) pochlogwiar = pochodnalogwiarygodnosci(theta0, XX, y) print 'wartość log-wiarygodności dla początkowej thety: '+ str(logwiar)
print 'pochodna log-wiarygodnosci dla poczatkowej thety: '+ str(pochlogwiar) ## ============= Część 3: Optymalizacja ============= # Funkcje optymalizujące zaczerpniemy z modułu scipy.optimize # ponieważ funkcje te są zaimplementowane do mnimalizowania # zamiast maksymalizować funkcję lowwiarygodności będziemy # minimalizować tą funkcje przemnożoną przez -1 # czyli minusfunkcjalogwiarygodnosci #fprime=minuspochodnalogwiarygodnosci, theta_opt = so.fmin_bfgs(minusfunkcjalogwiarygodnosci, theta0, fprime=minuspochodnalogwiarygodnosci, args=(xx,y), disp= True) # wypiszmy theta print 'Wartość log wiarygodnosci dla optymalnych parametrów: '+str(funkcjalogwiarygodnosci(theta_opt, XX, y)) print 'theta: '+str(theta_opt) # narysujmy uzyskany podział rysujgranice(theta_opt, X, y,marker = ('bo','r+'),xlabel='wynik z matematyki', ylabel='wynik z biologii',legend_list=(u'nie przyjęty',u'przyjęty')); py.show() ## ============== Część 4: Przewidywanie ============== # PO dopasowaniu parametrów nadszedł czas aby zrobić predykcję. # obliczmy jakie prawdopodobieństwo przyjęcia ma kandydat z wynikami # 20 z matematyki # 80 z biologii # Do przewidywania wykorzystujemy funkcję hipoteza, bo zgodnie z naszą interpretacją daje ona # prawdopodobieństwo przyjęcia prob = hipoteza([1, 20, 80], theta_opt) print 'dla kandydata z wymnikami 20 z matematyki i 80 z biologii prawdopodobieństwo przyjęcia wynosi: ' +str(prob)
Walidacja Teoria do tej części znajduje się tu: wykład Zastosowanie w naszym przykładzie W części piątej naszego programu dodamy kross-walidację typu leave-one-out. Po kolei odłożymy po jednym przykładzie ze zbioru uczącego, na takim zredukownaym zbiorze nauczymy regresję, a następnie sprawdzimy która z poniższych możliwych sytuacji zachodzi: TP: stan faktyczny jest pozytywny (y=1) i klasyfikator się nie myli (wynik = 1) TN: stan faktyczny jest negatywny (y=0) i klasyfikator się nie myli (wynik = 0) FP: wynik fałszywie pozytywny (fałszywy alarm): stan faktyczny jest negatywny (y=0) ale klasyfikator się myli (wynik = 1) FN: przegapiony alarm: stan faktyczny jest pozytywny (y=1) i klasyfikator się myli (wynik = 0) ## =============Część 5: walidacja ============== # zastosujemy kross-walidację typu leave-one-out # przygotowujemy liczniki: TP = TN = FP = FN = for v in range(len(y)): print v,'/', len(y) # odkładamy przykład v do testowania testx = XX[v] testy = y[v] # robimy zredukowany zbiór uczący przez usunięcie przykładu v tenx = np.delete(xx,v,axis=) teny = np.delete(y,v) # uczymy regresję theta_opt = so.fmin_bfgs(minusfunkcjalogwiarygodnosci, theta0, fprime=minuspochodnalogwiarygodnosci, args=(tenx,teny), disp= False) # klasyfikujemy odłożony przykład : proszę uzupełnić funkcję klasyfikacja na początku pliku wynik = klasyfikacja(testx, theta_opt) # aktualizujemy liczniki; proszę uzupełnić kod: if testy == 1: if wynik == 1:... else:... else:
if wynik == 1:... else:... print 'TP: ', TP print 'FP: ', FP print 'TN: ', TN print 'FN: ', FN Dla naszego zbioru uczącego powinniśmy uzyskać: TP: 55 FP: 6 TN: 34 FN: 5 Krzywa ROC Aby wykreślić krzywą ROC należy przeprowadzić klasyfikację dla wielu możliwych wartości progu dla hipotezy, powyżej którego uznajemy przypadek za należący do klasy 1. Modyfikując funkcję klasyfikacja, uzyskujemy następującą funkcje klasyfikującą zależną od progu: def klasyfikacjaprog(testx, theta_opt,prog): prob = hipoteza(testx, theta_opt) if prob >prog: return 1 else: return Funkcję tą możemy wykorzystać do obliczenia liczebności poszczególnych przypadków klasyfikacji w zależności od progu: def liczroc(xx,y,progi): '''funkcja oblicza FPR i TPR dla zadanych progów''' TP = np.zeros(len(progi)) TN = np.zeros(len(progi)) FP = np.zeros(len(progi)) FN = np.zeros(len(progi)) for v in range(len(y)): print v,'/', len(y) testx = XX[v] testy = y[v] tenx = np.delete(xx,v,axis=) teny = np.delete(y,v) theta_opt = so.fmin_bfgs(minusfunkcjalogwiarygodnosci, theta0,
fprime=minuspochodnalogwiarygodnosci, args=(tenx,teny), disp= False) for ind, prog in enumerate(progi): wynik = klasyfikacjaprog(testx, theta_opt,prog) #========================== # tu wstaw odpowiedni kawałek kodu #========================== TPR = TP/(TP+FN) FPR = FP/(FP+TN) return (FPR,TPR) Do wykreślenia krzywej ROC możesz użyć następującego kodu. Zaznaczamy w nim na wykresie wartości progów dla których osiągnięto konkretne wartości FPR i TPR. progi = np.arange(0.0,1.1,0.1) FPR,TPR= liczroc(xx,y,progi) py.plot(fpr,tpr,'o') py.plot(fpr,tpr) for ind,pr in enumerate(progi): py.text(fpr[ind],tpr[ind],str(pr)) py.xlabel('fpr') py.ylabel('tpr') py.xlim((,1)) py.ylim((,1)) py.show() Dopisz powyższe funkcje do głównego modułu.