<span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">Guia2</span> por <a xmlns:cc="http://creativecommons.org/ns#" href="http://nbviewer.ipython.org/urls/raw.githubusercontent.com/elsuizo/Redes_neuronales_Fuzzy/master/guia1.ipynb?create=1" property="cc:attributionName" rel="cc:attributionURL">Martin Noblía</a> se distribuye bajo una Licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional.
Considere el siguiente problema de clasificación:
$$\{ \mathbf{p}_{1}=[-1,1]^{T},t_{1}=1 \}$$$$\{ \mathbf{p}_{2}=[0,0]^{T},t_{1}=1 \} $$ $$\{ \mathbf{p}_{3}=[1,-1]^{T},t_{1}=1 \} $$$$\{ \mathbf{p}_{4}=[1,0]^{T},t_{1}=0 \} $$ $$\{ \mathbf{p}_{5}=[0,1]^{T},t_{1}=0 \} $$a) ¿Que tipo de perceptron utilizará para encontrar el clasificador? Especifique entradas, neuronas y salidas
b) Realizar un gráfico de los puntos con sus clases y encontrar la separatiz. Hallar el $\mathbf{W}$ y el $\mathbf{b}$ asociados a su solución
c) Programar un algoritmo(propio) que resuelva el problema desde una condición inicial azarosa. Realice los gráficos que muestren las separatrices de su clasificador
d) Usar toolbox
Primero, como es un problema linealmente separable(vease gráfico) podemos utilizar el perceptron, luego para elegir el número de neuronas teniendo en cuenta que un perceptron clasifica $2^{s}$(donde $s$ es el número de neuronas) clases distintas y ya que en este problema existen solo dos clases,
El número de neuronas elegidas es $1$.
El número de entradas es $5$ (Determinadas por $\mathbf{p}_{i}$) $i = 1,2..5$
El número de salidas es $1$ (determinado por $a = hardlim(\mathbf{W}^{T} \mathbf{p} + \mathbf{b})$) $\in R^{1}$
Sea una red neuronal con arquitectura perceptron(de una sola capa), cuya salida se calcula de la siguiente manera:
$$\mathbf{a} = \mathbf{f}(_{1}\mathbf{W} \, \mathbf{p} + \mathbf{b})$$Donde:
$_{1}\mathbf{W}$: matriz de pesos (parámetro de la red)
$\mathbf{p}$: vector de entradas
$\mathbf{b}$: vector de bias (parámetro de la red)
$\mathbf{f}$: es una función de transferencia hardlim
y sea la siguiente regla de aprendizaje:
$$e = t - a$$$$_{1}\mathbf{W}^{new} = (_{1}\mathbf{W}^{old})+ e \, \mathbf{p} $$$$\mathbf{b}^{new} = \mathbf{b}^{old} + e $$
In [1]:
# Imports
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
plt.rcParams['figure.figsize'] = 8,6 #parámetros de tamaño
In [2]:
# definimos la funcion de transferencia
hardlim = lambda t: .5 * (np.sign(t) + 1)
In [3]:
# Inputs
p_1 = np.array([-1,1])
p_2 = np.array([0,0])
p_3 = np.array([1,-1])
p_4 = np.array([1,0])
p_5 = np.array([0,1])
# Targets
t_1 = 1
t_2 = 1
t_3 = 1
t_4 = 0
t_5 = 0
In [4]:
# Conjunto de datos
data_set = ((p_1,t_1),(p_2,t_2),(p_3,t_3),(p_4,t_4),(p_5,t_5))
In [5]:
for data in data_set:
print 'input:%s --> target:%s' % (data[0],data[1])
In [6]:
# Condicion inicial
W = np.random.uniform(-1,1,size=2)
W
Out[6]:
In [7]:
# Condicion inicial
b = np.random.uniform(-1,1)
b
Out[7]:
In [8]:
# Entrenamiento
flag = True
epocas = 0
while flag:
flag = False
for data in data_set:
a = hardlim(np.dot(W,data[0]) + b)
t = data[1]
e = t - a
if np.abs(e) > 0:
flag = True
W = W + e * data[0]
b = b + e
epocas += 1
In [9]:
W
Out[9]:
In [10]:
b
Out[10]:
In [11]:
# Verificacion
for data in data_set:
a2 = hardlim(np.dot(W,data[0]) + b)
print 'input:%s --> salida:%s --> target:%s' % (data[0],a2,data[1])
print 'Numero de epocas:', epocas
In [12]:
# Funcion de la frontera de decision Wp + b = 0
def decision_boun(t,w,b):
"""
Decision boundary
"""
return (-b - t * w[1])/(w[0])
In [13]:
t = np.linspace(-2,2)
In [14]:
# Plots
plt.plot(data_set[-1][0][0],data_set[-1][0][1],'ro',markersize=12)
plt.plot(data_set[-2][0][0],data_set[-2][0][1],'ro',markersize=12)
plt.plot(t,decision_boun(t,W,b),'k--',linewidth=4)
plt.fill_between(t,decision_boun(t,W,b),-1.5,facecolor='green')
plt.title('Clasificacion con Perceptron',fontsize=20)
for data in data_set[0:3]:
plt.scatter(data[0][0],data[0][1],s=120)
plt.xlim((-1.5,1.5))
plt.ylim((-1.5,1.5))
plt.grid()
Vamos a utilizar un modulo de Python llamado neurolab[http://code.google.com/p/neurolab/]
In [15]:
import neurolab as nl
inputs = [[-1, 1], [0, 0], [1, -1], [1, 0],[0,1]]
target = [[1], [1], [1], [0],[0]]
# Creamos una neurona de dos entradas(con rangos entre(-1,1)) y una capa
net = nl.net.newp([[-1, 1],[-1, 1]], 1)
In [16]:
error = net.train(inputs, target, epochs=100, show=10, lr=0.1)
In [17]:
error
Out[17]:
In [18]:
# Verificamos
net.sim(inputs)
Out[18]:
In [19]:
plt.plot(error)
plt.xlabel('Numero de epocas',fontsize=20)
plt.ylabel('error de entrenamiento',fontsize=20)
plt.grid()
In [19]: