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

Jarekz: /* Jednowymiarowa */

2016-05-04T07:23:16Z

Jednowymiarowa

Jarekz o 12:04, 2 maj 2016

2016-05-02T12:04:22Z

Jarekz: /* Jednowymiarowa */

2016-05-02T11:47:18Z

Jednowymiarowa

Jarekz: /* Jednowymiarowa */

2016-05-02T11:32:26Z

Jednowymiarowa

Jarekz: /* Dwuwymiarowa */

2016-05-02T11:30:32Z

Dwuwymiarowa

Jarekz: /* Jednowymiarowa */

2016-05-02T10:11:08Z

Jednowymiarowa

Podgląd zmian

Jarekz: Utworzono nową stronę "= Regresja = == Jednowymiarowa== W tym ćwiczeniu chcemy zastosować sieć do wykonania regresji nieliniowej. Załóżmy, że mamy generator który dostarcza żądaną..."

2015-05-21T18:28:35Z

Utworzono nową stronę "= Regresja = == Jednowymiarowa== W tym ćwiczeniu chcemy zastosować sieć do wykonania regresji nieliniowej. Załóżmy, że mamy generator który dostarcza żądaną..."

Nowa strona

= Regresja =
== Jednowymiarowa==
W tym ćwiczeniu chcemy zastosować sieć do wykonania regresji nieliniowej.

Załóżmy, że mamy generator który dostarcza żądaną ilość par liczb zgodnie z pewnym modelem, np.:
<source lang = python>
def gen(ile):
x = np.sort(5*np.random.rand(ile))
y = (1+10*x+x**2)/(1+2*x**2)
y+= 0.1*y*np.random.randn(ile)
return(x,y)
</source>

* Niech generator dostarcza nam po 10 par liczb. Proszę narysować kilka realizacji.
* Proszę skonstruować sieć, którą można nauczyć zależności między punktami wejściowymi (x) i wyjściowymi (y). W tym celu najlepiej wykorzystać sieć z nieliniową warstwą ukrytą typu tangensa hiperbolicznego i liniową warstwę wyjściową <tt>buildNetwork(N_wej, N_hid, N_wyj, hiddenclass=TanhLayer, outclass=LinearLayer)</tt>
Taka kombinacja warstw nieliniowej i liniowej pozwala na reprezentację dowolniej ciągłej funkcji, pod warunkiem użycia właściwej ilości neuronów w warstwie ukrytej. Liniowa warstwa wyjściowa pozwala na rozszerzenie zbioru wartości.
* Podobnie jak w poprzednim zadaniu proszę zbadać ewolucję:
** wag
** błędu na zbiorze uczącym
** błędu na zbiorze monitorującym
* Powyższe zależności proszę zaobserwować dla kilku rozmiarów warstwy ukrytej.
* Proszę wykreślić funkcję reprezentowaną przez sieć na tle punktów zbioru uczącego i prawdziwej (niezaszumionej) relacji ''y(x)''.
* Czy dla ustalonej architektury sieci (rozmiarów warstw) i ustalonego zbioru uczącego sieć zbiega do jednego rozwiązania? Dlaczego?
* Dla kilku ustalonych architektur zbadaj zależność błędu od rozmiaru zbioru uczącego.

Szkielet rozwiązania:

<source lang = python>
# -*- coding: utf-8 -*-
import matplotlib

matplotlib.use('TkAgg')
import numpy as np
import pylab as py
from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer, LinearLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised import BackpropTrainer

def gen(ile):
x = np.sort(5*np.random.rand(ile))
y = (1+10*x+x**2)/(1+2*x**2)
y+= 0.1*y*np.random.randn(ile)
return(x,y)

N_przykladow =7
x, y = gen(N_przykladow) # przykłady do ciągu uczącego
x_m, y_m = gen(N_przykladow) # przykłady do ciągu monitorującego
py.plot(x,y,'.')
py.show()

N_wej= ...
N_hid = ...
N_wyj = ...

#wytwarzam zbiór uczący
ZU = SupervisedDataSet(N_wej,N_wyj)
for i in range(N_przykladow):
ZU.addSample(...)
#wytwarzam sieć
net = buildNetwork(N_wej, N_hid, N_wyj, hiddenclass= ... , outclass= ...)

# inicjuję trenera
trener = BackpropTrainer...

py.ion()
N_epochs = 200

# inicjuję tablice na ewolucje
err = np.zeros(N_epochs)
err_m = np.zeros(N_epochs)
wagi = np.zeros((N_epochs,len(net.params)))

# inicjuję rysunki
py.subplot(2,1,1) # błędów
l_err, = py.plot(err,'b',label='zb. uczacy')
l_err_m, = py.plot(err_m,'r',label='zb. monitorujacy')
py.title(u'błąd')
py.legend()
py.ylim([0,1])

py.subplot(2,1,2) #wag
l_wagi = py.plot(wagi)
py.title('wagi')
py.ylim([-3,3])
py.draw()

# uczę
for n in range(N_epochs):
err[n] = ... # trenuję i odbieram błąd
for j, m in enumerate(x_m): # liczę średni błąd kwadratowy na zbiorze monitorującym:
err_m[n] += (y_m[ ... ] - net.activate(( ... ,)))**2
err_m[n] /= ... # normalizuję aby uzyskać średni błąd kwadratowy
l_err.set_ydata(err) # odrysowuję błąd na zb. uczącym
l_err_m.set_ydata(err_m) # odrysowuję błąd na zb. monitorującym

wagi[n,:] = ...
for k in range(len(l_wagi)):
l_wagi[k].set_ydata(wagi[:,k])

py.draw()

py.ioff()
py.show()

# funkcja reprezentowana przez sieć na tle punktów zbioru uczącego i prawdziwej (niezaszumionej) relacji y(x).
x_testowe = np.linspace(0.1,7,100)
y_testowe = np.zeros(100)
for i in range(len(x_testowe)):
y_testowe[i] = net.activate((...,))

z = (1+10*x_testowe+x_testowe**2)/(1+2*x_testowe**2) # prawdziwa relacja
py.plot(x_testowe,y_testowe,'r',label='regresja')
py.plot(x_testowe,z,'b',label='relacja prawdziwa')
py.plot(x,y,'bo',label='zb. uczacy')
py.plot(x_m,y_m,'mo',label='zb. monitorujacy')
py.legend()
py.show()

</source>



== Dwuwymiarowa ==
W zadaniu tym chciałbym abyście zbadali na ile złożona (ile neuronów ukrytych) musi być sieć modelująca/interpolująca funkcję:
:<math> f(x,y) = 0.1 + \frac{1 + \sin(2x + 3y)}{3.5 + \sin(x-y)}</math>
dla <math>x,y \in [-2,2]</math>
* Proszę wykreślić tą funkcję.

* Jako ciąg uczący proszę wykorzystać pary wejścia spróbkowane co 0.2 i odpowiadające im wartości funkcji.
* Test proszę przeprowadzić na danych próbkowanych gęściej, ale tak aby w zbiorze testowym nie było punktów ze zbioru uczącego (np.: <tt>np.arange(-2+0.05195,2,0.05195)</tt>).

Przydatne mogą być funkcje do:
* generowania danych np.:
<source lang= python>
def gen(vec):
x = vec
y = vec
f = np.zeros((len(x),len(y)))
for i, x_i in enumerate(x):
for j, y_j in enumerate(y):
f[i,j] = 0.1 + (1+np.sin(2*x_i + 3*y_j))/(3.5 + np.sin(x_i - y_j))
return(x,y,f)

(x,y,f)= gen(np.arange(-2,2,0.2))
</source>

* rysowania powierzchni 3D
<source lang = python>
from matplotlib.pyplot import plot, show, figure, draw
from mpl_toolkits.mplot3d import axes3d

def rysuj3d(x,y,f,fig):
X,Y = np.meshgrid(x,y)
ax = fig.gca(projection='3d')
ax.plot_surface(X, Y, f, rstride=3, cstride=3, alpha=0.3)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('f')

def scatter3d(x,y,f,fig,kolor):
X,Y = np.meshgrid(x,y)
ax = fig.gca(projection='3d')
ax.scatter(X, Y, f, c=kolor,marker='o')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('f')

#przykładowe użycie:
(x,y,f)= gen(np.arange(-2,2,0.2))
fig = figure()
rysuj3d(x,y,f,fig)
scatter3d(x,y,f,fig,'b')
show
</source>

@@ Linia 130: / Linia 130: @@
      for cykl in range(N_epochs):
          err[cykl] = ... # wykonaj krok uczenia
-         for j, m in enumerate(X): # liczę średni błąd kwadratowy na zbiorze monitorującym:
+         for j, x_j in enumerate(X_m): # liczę średni błąd kwadratowy na zbiorze monitorującym:
              err_m[cykl] += (Y_m[j] - ... )**2
          err_m[cykl] /=  X_m.shape[0]# normalizuję aby uzyskać średni błąd kwadratowy

← poprzednia wersja		Wersja z 11:30, 2 maj 2016
Linia 171:		Linia 171:

	</source>		</source>
		+
		+	{{hidden begin\|title=szkilet rozwiązania}}
		+	<source lang = python>
		+	def main(argv=None):
		+	N_epok = 1500
		+	N_rozmiarow = 7
		+	N_prob = 6
		+
		+	eta1 = 0.005
		+	eta2 = 0.8
		+	# inicjuję tablice na ewolucje
		+	bl = np.zeros((N_rozmiarow,N_prob)) #tablica na błąd zbioru uczącego
		+	bl_m = np.zeros((N_rozmiarow,N_prob)) #tablica na błąd zbioru monitorującego
		+	rozmiary = np.linspace(10,70,N_rozmiarow)
		+	for i,N_przykladow in enumerate(rozmiary):
		+	print ' '
		+	for proba in range(N_prob):
		+	print 'test dla ', N_przykladow, 'przykładów; ''próba: ', proba
		+	#zbiór uczący:
		+	X, Y = gen(N_przykladow) # przykłady do ciągu uczącego
		+	X_m, Y_m = gen(N_przykladow) # przykłady do ciągu monitorującego
		+
		+	# definiujemy obiekt sieci:
		+	S = siec( X, Y, N_hid=1)
		+	for cykl in range(N_epok):
		+	bl[i,proba] = S.fit_one_step(eta1,eta2)
		+	if cykl%100==0:
		+	print 'cykl:', cykl, u'błąd: ',bl[i,proba]
		+
		+	for j, m in enumerate(X): # liczę średni błąd kwadratowy na zbiorze monitorującym:
		+	bl_m[i,proba] += (Y_m[j] - S.predict(X[j]))**2
		+	bl_m[i,proba] /= X_m.shape[0]# normalizuję aby uzyskać średni błąd kwadratowy
		+
		+
		+	# rysunki
		+	sr_bl = np.mean(bl, axis = 1)
		+	std_bl = np.std(bl, axis = 1)
		+	sr_bl_m = np.mean(bl_m, axis = 1)
		+	std_bl_m = np.std(bl_m, axis = 1)
		+
		+	py.figure()
		+	py.fill_between(rozmiary,sr_bl-std_bl,sr_bl+std_bl , alpha=0.1, color="b")
		+	py.plot(rozmiary,sr_bl, 'b',label='zb. uczacy')
		+	py.fill_between(rozmiary,sr_bl_m-std_bl_m,sr_bl_m+std_bl_m , alpha=0.1, color="r")
		+	py.plot(rozmiary,sr_bl_m, 'r',label='zb. monitorujacy')
		+	py.title(u'błąd')
		+	py.legend()
		+	py.ylim([0,1.5])
		+	py.show()
		+	</source>
		+	{{hidden end}}

	== Dwuwymiarowa ==		== Dwuwymiarowa ==

@@ Linia 1: / Linia 1: @@
 = Regresja =
 == Jednowymiarowa==
@@ Linia 285: / Linia 286: @@
 show
 </source>

@@ Linia 14: / Linia 14: @@
 * Niech generator dostarcza nam po 10 par liczb. Proszę narysować kilka realizacji.
-* Proszę skonstruować sieć, którą można nauczyć zależności między punktami wejściowymi (x) i wyjściowymi (y). W tym celu najlepiej wykorzystać sieć z nieliniową warstwą ukrytą typu tangensa hiperbolicznego i liniową warstwę wyjściową <tt>buildNetwork(N_wej, N_hid, N_wyj, hiddenclass=TanhLayer, outclass=LinearLayer)</tt>
+* Proszę skonstruować sieć, którą można nauczyć zależności między punktami wejściowymi (x) i wyjściowymi (y). W tym celu najlepiej wykorzystać sieć z nieliniową warstwą ukrytą  i liniową warstwę wyjściową. Taka kombinacja warstw nieliniowej i liniowej pozwala na reprezentację dowolniej ciągłej funkcji, pod warunkiem użycia właściwej ilości neuronów w warstwie ukrytej. Liniowa warstwa wyjściowa pozwala na rozszerzenie zbioru wartości.
-Taka kombinacja warstw nieliniowej i liniowej pozwala na reprezentację dowolniej ciągłej funkcji, pod warunkiem użycia właściwej ilości neuronów w warstwie ukrytej. Liniowa warstwa wyjściowa pozwala na rozszerzenie zbioru wartości.
+* Proszę wykreślić funkcję reprezentowaną przez sieć na tle punktów zbioru uczącego i prawdziwej (niezaszumionej) relacji ''y(x)''.
 * Podobnie jak  w poprzednim zadaniu proszę zbadać ewolucję:
 **  wag
@@ Linia 21: / Linia 22: @@
 ** błędu na zbiorze monitorującym
 * Powyższe zależności proszę zaobserwować dla kilku rozmiarów warstwy ukrytej.
-* Proszę wykreślić funkcję reprezentowaną przez sieć na tle punktów zbioru uczącego i prawdziwej (niezaszumionej) relacji ''y(x)''.
 {{hidden begin|title=szkilet rozwiązania}}
@@ Linia 172: / Linia 172: @@
 ===Analiza krzywych uczenia ===
 * Dla kilku ustalonych architektur zbadaj zależność błędu od rozmiaru zbioru uczącego.
 {{hidden begin|title=szkilet rozwiązania}}

@@ Linia 23: / Linia 23: @@
 * Proszę wykreślić funkcję reprezentowaną przez sieć na tle punktów zbioru uczącego i prawdziwej (niezaszumionej) relacji ''y(x)''.
 * Czy dla ustalonej architektury sieci (rozmiarów warstw) i ustalonego zbioru uczącego sieć zbiega do jednego rozwiązania? Dlaczego?
 <source lang = python>
 # -*- coding: utf-8 -*-
@@ Linia 171: / Linia 169: @@
 </source>
 {{hidden begin|title=szkilet rozwiązania}}
 <source lang = python>