Uczenie maszynowe i sztuczne sieci neuronowe/Ćwiczenia 2 - Historia wersji

Jarekz: /* Modelowanie i predykcja szeregu czasowego */

2015-12-28T16:46:31Z

Modelowanie i predykcja szeregu czasowego

Jarekz: /* Regresja liniowa jako filtr */

2015-12-28T16:38:09Z

Regresja liniowa jako filtr

Jarekz: /* Regresja liniowa jako filtr */

2015-12-28T16:37:41Z

Regresja liniowa jako filtr

Jarekz: /* Regresja liniowa jako filtr */

2015-12-28T16:36:39Z

Regresja liniowa jako filtr

Jarekz: /* Sieć jako filtr liniowy */

2015-12-28T16:25:57Z

Sieć jako filtr liniowy

Jarekz o 16:19, 28 gru 2015

2015-12-28T16:19:01Z

Jarekz: Utworzono nową stronę "=Pybrain= Część praktyczna naszych zajęć oparta będzie na bibliotece (zestawie modułów) [http://pybrain.org/pages/home PyBrain]. Jak twierdzą autorzy PyBrain je..."

2015-05-21T18:22:39Z

Utworzono nową stronę "=Pybrain= Część praktyczna naszych zajęć oparta będzie na bibliotece (zestawie modułów) [http://pybrain.org/pages/home PyBrain]. Jak twierdzą autorzy PyBrain je..."

Nowa strona

=Pybrain=
Część praktyczna naszych zajęć oparta będzie na bibliotece (zestawie modułów) [http://pybrain.org/pages/home PyBrain].
Jak twierdzą autorzy PyBrain jest skrótem od Python-Based Reinforcement Learning, Artificial Intelligence and Neural Network Library, czyli sądząc po nazwie powinniśmy w nim znaleźć narzędzia do wszystkich naszych ćwiczeń.

W PyBrainie sieci tworzone są z ''Modułów'' połączonych za pomocą ''Połączeń''. O sieciach tych można myśleć jak o acyklicznych grafach, w których węzłach są Moduły a krawędzie są Połączeniami.

== Szybki start ==
Aby zapoznać się z podstawami posługiwania się narzędziami PyBraina wykorzystamy kilka przykładów z oryginalnego tutoriala.

Poniższe polecenia proszę wykonać interaktywnie z linii poleceń pythona.

Skrótowe polecenie do wytworzenia typowej sieci warstwowej to <tt>buildNetwork</tt>
<source lang = python>
from pybrain.tools.shortcuts import buildNetwork
net = buildNetwork(2, 3, 1)
</source>
To polecenie zwraca obiekt <tt>net</tt>, który reprezentuje sieć mającą dwa wejścia, trzy neurony ukryte i jeden wyjściowy. Warstwy są obiektami typu ''Moduł'' i są połączone za pomocą obiektów typu ''FullConnection''.

Aby nasza sieć obliczyła swoje wyjście dla zadanego wejścia trzeba wywołać metodę <tt>activate</tt>.
<source lang = python>
net.activate([2, 1])
</source>

Strukturę sieci możemy zbadać wypisując różne jej elementy:
<source lang = python>
net['in']
net['hidden0']
net['out']
net.connections
</source>

== A teraz powoli ==
Teraz zbudujmy najprostszą sieć liniową złożoną z jednego neuronu o dwóch wejściach i jednym wyjściu.

Importujemy potrzebne funkcje i obiekty:
<source lang = python>
from pybrain.structure import FeedForwardNetwork, LinearLayer, FullConnection
</source>

wytwarzamy pustą sieć

<source lang = python>
siec = FeedForwardNetwork()
</source>

tworzymy węzły wejściowe i wyjściowe
<source lang = python>
warstwaWejsciowa = LinearLayer(2)
warstwaWyjsciowa = LinearLayer(1)
</source>

dodajemy węzły do sieci

<source lang = python>
siec.addInputModule(warstwaWejsciowa)
siec.addOutputModule(warstwaWyjsciowa)
</source>

łączymy węzły

<source lang = python>
wej_do_wyj = FullConnection(warstwaWejsciowa, warstwaWyjsciowa)
siec.addConnection(wej_do_wyj)
</source>

inicjujemy strukturę sieć

<source lang = python>
siec.sortModules()
</source>

możemy podejrzeć wartości wag

<source lang = python>
print siec.params
</source>

przepuszczenie danych przez sieć

<source lang = python>
print siec.activate([1,3])
</source>

=Sieć jako filtr liniowy=

Poniższy przykład ma nam uświadomić możliwość wykorzystania sieci do filtrowania sygnałów. Przy okazji nauczymy się definiować ciąg uczący i stosować metody spadku gradientowego do uczenia sieci.

==Przygotowanie danych ==
Najpierw przygotujemy dane. Dane wejściowe to szum gaussowski, zaś wyjście to przefiltrowany dolnoprzepustowo szum z częstością odcięcia 20Hz.
<source lang = python>
from scipy.signal import firwin, lfilter
import numpy as np

sampling = 128.0
# przygotowujemy dane tak aby nauczyć sieć filtrowania dolnoprzepustowego
t = np.arange(0,2,1/sampling)
x = np.random.randn(len(t))
b= firwin(30,20.0/sampling)
y = lfilter(b,[1],x)
</source>

Sprawdźmy jak wygląda sygnał wejściowy, wyjściowy oraz ich widma:
<source lang = python>
from pylab import subplot, plot, show, title, xlabel

def spectrum(x,Fs):
N = len(x)
P = np.abs(np.fft.fft(x))**2/len(x)
f = np.fft.fftfreq(len(x),1.0/Fs)
P = P[0:N/2]
P[1:-1] *=2
f = f[0:N/2]
return f,P
subplot(2,2,1)
plot(t,x)
title(u'wejście')
xlabel('s')
subplot(2,2,3)
plot(t,y)
title(u'wyjście')
xlabel('s')
subplot(2,2,2)
f,P = spectrum(x,sampling)
plot(f,P)
title(u'Widmo wejścia')
xlabel('Hz')
subplot(2,2,4)
f,P = spectrum(y,sampling)
plot(f,P)
title(u'Widmo wyjścia')
xlabel('Hz')

show()
</source>

==Wytworzenie sieci==
* wytwarzamy pustą sieć
<source lang = python>
siec = FeedForwardNetwork()
</source>
* tworzymy węzły wejściowe i wyjściowe
<source lang = python>
N_wej = 30
warstwaWejsciowa = LinearLayer(N_wej)
warstwaWyjsciowa = LinearLayer(1)
</source>
* dodajemy węzły do sieci
<source lang = python>
siec.addInputModule(warstwaWejsciowa)
siec.addOutputModule(warstwaWyjsciowa)
</source>
* łączymy węzły
<source lang = python>
wej_do_wyj = FullConnection(warstwaWejsciowa, warstwaWyjsciowa)
siec.addConnection(wej_do_wyj)
</source>

* inicjujemy strukturę sieci
<source lang = python>
siec.sortModules()
</source>

== Tworzenie ciągu uczącego==

* tworzymy ciąg uczący CU
<source lang = python>
from pybrain.datasets import SupervisedDataSet
CU = SupervisedDataSet(N_wej, 1)
for i in range(len(x)-N_wej-1):
bufor_wejsciowy = x[i:i+N_wej]
wartosc_wyjsciowa = y[i+N_wej]
CU.addSample( bufor_wejsciowy, wartosc_wyjsciowa)
</source>

== Uczenie sieci==
* za uczenie sieci metodami "z nauczycielem" odpowiada w pybrain moduł <tt>pybrain.supervised.trainers</tt> http://pybrain.org/docs/api/supervised/trainers.html, dostarcza on dwóch klas: BackpropTrainer i RPropMinusTrainer. Na razie zajmiemy się tą pierwszą klasą.
* importujemy i tworzymy obiekt typu <tt>BackpropTrainer</tt>, któremu przekazujemy sieć, ciąg uczący oraz parametry uczenia: współczynnik uczenia i bezwładność.
<source lang = python>
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(siec, CU,learningrate=0.0001, momentum=0.5)
</source>
* wywołujemy metodę uczącą sieć podanym ciągiem uczącym. <tt>maxEpochs</tt> oznacza, że uczenie prowadzimy do momentu uzyskania zpieżności,jednak nie dłużej niż 1000 iteracji.
<source lang = python>
trainer.trainUntilConvergence(maxEpochs = 1000)
</source>

==Testowanie sieci ==
* testujemy działanie sieci na zbiorze uczącym
<source lang = python>
y_est = np.zeros(x.shape)
for i in range(len(x)-N_wej-1):
bufor_wejsciowy = x[i:i+N_wej]
y_est[i+N_wej] = siec.activate(bufor_wejsciowy)
</source>
* proszę zilustrować działanie na wykresach przebiegów czasowych i widm sygnału wejściowego i wyjściowego.
<source lang = python>
subplot(221)
plot(t,x)
subplot(223)
plot(t,y)
plot(t,y_est,'.')

subplot(222)
f,Px = spectrum(x,sampling)
plot(f,Px)

subplot(224)

f,Py = spectrum(y,sampling)
plot(f,Py)

f,P_est = spectrum(y_est,sampling)
plot(f,P_est)

show()
</source>

* wytwarzamy nowy zbiór danych wejściowych
<source lang = python>
x_test = np.zeros(len(t))
faza = np.zeros(len(range(1,64,2)))
for i,f in enumerate(range(1,64,2)):
faza[i] = np.random.rand(1)*2*np.pi
x_test += np.sin(2*np.pi*f*t + faza[i])
</source>
* proszę przepuścić ten zbiór danych przez sieć i zilustrować wynik działania na wykresach przebiegów czasowych i widm sygnału wejściowego i wyjściowego.

# Proszę sprawdzić zbieżność algorytmu w zależności od parametrów uczenia
# Proszę sprawdzić działanie sieci w zależności od rozmiaru wejścia



=Modelowanie i predykcja szeregu czasowego=

Załóżmy, że mamy pewien szereg czasowy. Dalej zakładamy, że jest on wynikiem pewnego procesu autoregresyjnego, tzn. że jego kolejna próbka jest pewną kombinacją liniową poprzednich próbek z dodanym szumem:
: <math> x_t = \sum_{i=1}^p a_i x_{t-i} +\epsilon_t</math>

Czy dałoby się zastosować techniki uczenia sieci neuronowej do oszacowania współczynników <math>a_i</math>?

# Przy pomocy poniższego kodu proszę wygenerować realizację procesu AR o długości N = 2000 i współczynnikach a = [-0.5, 0.2], epsilon niech będzie = 0.1:
<source lang =python>
def generujAR(a, epsilon, N):
x=np.zeros(N)
rzad = len(a)
for i in range(rzad,N):
for p in range(len(a)):
x[i] += a[p]*x[i-(p+1)]
x[i] += epsilon*np.random.randn()
return x
</source>
# Proszę wykreślić tą realizację
# Skonstruować ciąg uczący gdzie wejściem jest ''p'' poprzednich próbek zaś wyjściem kolejna próbka.
# Skonstruuj sieć o ilości wejść równej rzędowi modelu ''p''
# Ucz sieć i obserwuj jak zmieniają się wagi.
# Zbadaj co dzieje się z estymowanymi parametrami oraz błędem popełnianym przez sieć gdy rozmiar wejścia nie jest zgodny z rzędem modelu.

<source lang =python>
# -*- coding: utf-8 -*-
from pybrain.structure import FeedForwardNetwork, LinearLayer, FullConnection
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.datasets import SupervisedDataSet
from scipy.signal import firwin, lfilter
import numpy as np
import pylab as py

def generujAR(a, epsilon, N):
x=np.zeros(N)
rzad = len(a)
for i in range(rzad,N):
for p in range(len(a)):
x[i] += a[p]*x[i-(p+1)]
x[i] += epsilon*np.random.randn()
return x

N = 2000
x = np.zeros(N)
a = np.array([ -0.5, 0.2]) #[0.1 -0.2 0.3 0.1 -0.1]
epsilon =0.1
x = generujAR(a,epsilon,N)
py.plot(x)
py.show()

# tworzymy ciąg uczący CU
N_wej = 2
CU = SupervisedDataSet(N_wej, 1)
for i in range(len(x)-N_wej-1):
bufor_wejsciowy = x[i:i+N_wej]
wartosc_wyjsciowa = x[i+N_wej]
CU.addSample( bufor_wejsciowy[::-1], wartosc_wyjsciowa)#

# wytwarzamy pustą sieć
siec = FeedForwardNetwork()

# tworzymy węzły wejściowe i wyjściowe

warstwaWejsciowa = LinearLayer(N_wej)
warstwaWyjsciowa = LinearLayer(1)

# dodajemy węzły do sieci
siec.addInputModule(warstwaWejsciowa)
siec.addOutputModule(warstwaWyjsciowa)

# łączymy węzły
wej_do_wyj = FullConnection(warstwaWejsciowa, warstwaWyjsciowa)
siec.addConnection(wej_do_wyj)

# inicjujemy strukturę sieci
siec.sortModules()

trainer = BackpropTrainer(siec, CU,learningrate=0.01, momentum=0.8,verbose=True)
#trainer.trainUntilConvergence(maxEpochs = 500)
for i in range(10):
trainer.trainEpochs(1)
print i, siec.params

# test na zbiorze uczącym
y_est = np.zeros(x.shape)
for i in range(len(x)-N_wej-1):
bufor_wejsciowy = x[i:i+N_wej]
y_est[i+N_wej] = siec.activate(bufor_wejsciowy[::-1])
#py.plot(t,x)
py.subplot(2,1,1)
py.plot(x,'b')
py.plot(y_est,'r')
py.subplot(2,1,2)
py.plot(x-y_est)
print 'wariancja reziduum, ', np.var(x-y_est)
print 'wariancja procesu AR, ', epsilon**2
print 'parametry procesu: ', str(a)
print 'parametry wyestymowane: ', str(siec.params)
py.show()
</source>

@@ Linia 87: / Linia 87: @@
 Poniższy przykład ma nam uświadomić możliwość wykorzystania regresji do filtrowania sygnałów. Przy okazji nauczymy się pracy z  ciągiem uczącym.
-Proszę uzupełnić brakujace fragmenty kodu:
+Proszę uzupełnić brakujace fragmenty kodu (w razie wątpliwości pytać prowadzącego):
 <source lang = python>

@@ Linia 85: / Linia 85: @@
 =Regresja liniowa jako filtr =
-Poniższy przykład ma nam uświadomić możliwość wykorzystania regresji do filtrowania sygnałów. Przy okazji nauczymy się pracy z  ciągiem uczącym
+Poniższy przykład ma nam uświadomić możliwość wykorzystania regresji do filtrowania sygnałów. Przy okazji nauczymy się pracy z  ciągiem uczącym.
 <source lang = python>
@@ Linia 107: / Linia 109: @@
 rzad = 30
 N_wej = rzad # rozmiar bufora wejściowego
-T = 10 # ile skund sygnału
+# po początkowej obserwacji budowy ciągu uczącego warto przełżczyć wartość demo na False
 t  = np.arange(0,T,1/sampling)
 #Losowy sygnał wejściowy
@@ Linia 115: / Linia 119: @@
 # przygotowujemy dane tak aby nauczyć filtrowania dolnoprzepustowego
-b= firwin(rzad,10.0/sampling)
+b= firwin(rzad,20.0/sampling)
 y = lfilter(b,[1],x)
@@ Linia 127: / Linia 131: @@
      X[i,:] = x[i:i+N_wej]
      Y[i] = y[i+N_wej-1]
-     if demo:
+     if demo: # poniższy fragment kodu ilustruje tworzenie ciągu uczącego
          py.clf()
          py.plot(t,x,'r')
@@ Linia 135: / Linia 139: @@
          py.pause(1)
-# tworzmy obiekt do regersji liniowej
+# tworzmy instancję obiektu do regersji liniowej
-model = linear_model.LinearRegression(fit_intercept=False)
+model = ... # tu wywołaj odpowiednią funkcję z modułu  linear_model
 # dopasowujemy parametry modelu
-model.fit(X, Y)
+model.fit(...) # uzupełnij argumenty
 # test na zbiorze uczącym: dla kolejnych buforów wejściowych obliczamy wartości wyjściowe
@@ Linia 149: / Linia 153: @@
 # - górny panel sygnał wejściowy
 # - dolny panel sygnał otrzymany jako predykcje modelu (czerwony) na tle filtrowanego sygnału  (zielony)
 py.figure(1)
 py.subplot(2,1,1)
-py.plot(t,x)
+py.plot(t,...)
 py.title('wejscie')
 py.subplot(2,1,2)
-py.plot(t,y,'g')
+py.plot(t,...,'g')
-py.plot(t,y_est,'r')
+py.plot(t,...,'r')
 py.title('wyjscie')
@@ Linia 174: / Linia 179: @@
 for i in range(len(x)-N_wej-1):
      bufor_wejsciowy = x_test[i:i+N_wej]
-     y_est[i+N_wej-1] = model.predict(bufor_wejsciowy)
+     y_est[i+N_wej-1] = model.predict(...) #uzupełnij
 #ilustracja działania dopasowanego modelu na sygnał testowy
@@ Linia 203: / Linia 208: @@
 print b
 print "model"
-print model.coef_
+print model..... # uzupełnij

@@ Linia 461: / Linia 461: @@
 : <math> x_t = \sum_{i=1}^p a_i x_{t-i} +\epsilon_t</math>
-Czy dałoby się zastosować techniki uczenia sieci neuronowej do oszacowania współczynników <math>a_i</math>?
+Czy dałoby się zastosować regresję liniową do oszacowania współczynników <math>a_i</math>?
 # Przy pomocy poniższego kodu proszę wygenerować realizację procesu AR o długości N = 2000 i współczynnikach a = [-0.5, 0.2], epsilon niech będzie = 0.1:
 <source lang =python>
@@ Linia 561: / Linia 618: @@
 py.show()
 </source>

@@ Linia 91: / Linia 91: @@
 <source lang = python>
 # -*- coding: utf-8 -*-
-#from sklearn.neural_network import MLPRegressor #http://scikit-learn.org/dev/modules/generated/sklearn.neural_network.MLPRegressor.html#sklearn.neural_network.MLPRegressor
 from sklearn import linear_model
 from scipy.signal import firwin, lfilter

@@ Linia 83: / Linia 83: @@
 </source>
 -->
-=Sieć jako filtr liniowy=
+=Regresja liniowa jako filtr =
-Poniższy przykład ma nam uświadomić możliwość wykorzystania sieci do filtrowania sygnałów. Przy okazji nauczymy się definiować ciąg uczący i stosować metody spadku gradientowego do uczenia sieci.
+Poniższy przykład ma nam uświadomić możliwość wykorzystania regresji do filtrowania sygnałów. Przy okazji nauczymy się pracy z  ciągiem uczącym
 ==Przygotowanie danych ==
 Najpierw przygotujemy dane. Dane wejściowe to szum gaussowski, zaś wyjście to przefiltrowany dolnoprzepustowo szum z częstością odcięcia 20Hz.
@@ Linia 135: / Linia 256: @@
 </source>
-==Wytworzenie sieci==
+==Wytworzenie instancji obiektu do regresji i uczenie==
 <source lang = python>
 siec = FeedForwardNetwork()
@@ Linia 230: / Linia 350: @@
 # Proszę sprawdzić działanie sieci w zależności od rozmiaru wejścia
+-->
 <!--
 # -*- coding: utf-8 -*-

@@ Linia 1: / Linia 1: @@
 =Pybrain=
 Część praktyczna naszych zajęć oparta będzie na bibliotece (zestawie modułów) [http://pybrain.org/pages/home PyBrain].
@@ Linia 81: / Linia 82: @@
 print siec.activate([1,3])
 </source>
+-->
 =Sieć jako filtr liniowy=