UNIVERSIDAD DE GUADALAJARA

CENTRO UNIVERSITARIO DE CIENCIAS EXACTAS E INGENIERÍA

DIVISION DE ELECTRONICA Y COMPUTACION

DEPARTAMENTO DE CIENCIAS COMPUTACIONALES

INTELIGENCIA ARTIFICAL II

PRACTICA 02

Pedro Morales Enríquez

Código: 216787639
Sección: D02
Profesor: Julio Esteban Valdés López

Fecha: 08 de octubre del 2020

 ÍNDICE

ÍNDICE ................................................................................................................................... 2
INTRODUCCIÓN .................................................................................................................. 3
PERCEPTRON SIMPLE ....................................................................................................... 2
Código.......................................................................................................................................... 2
Grafica ......................................................................................................................................... 5
CONCLUSIÓN ...................................................................................................................... 7
 INTRODUCCIÓN

En la siguiente practica se presentan el código implementado del algoritmo del perceptrón

simple, así como una grafica interactiva la cual permite clasificar 2 pares de elementos. Para
poder desarrollar dicha practica fue necesario auxiliarse de las librerías de Python matplotlib
así como numpy, la primera permite crear grafías dinámicas y con las cuales se puede
interactuar y la segunda permite realizar fácilmente operaciones con matrices. La grafica
interactiva puede seleccionar 2 colores, el azul y el rojo estos colores representaran nuestros
objetos a clasificar, también se permite configurar las épocas que realiza el algoritmo del
perceptrón, así como la tasa de aprendizaje que queremos que tenga. Después de configurar
tanto los puntos en la gráfica como los otros parámetros se da clic en iniciar y el algoritmo
procede a clasificarlos, además podemos agregar más puntos y poder realizar otra
clasificación.
 PERCEPTRON SIMPLE

Código
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.widgets import CheckButtons
from matplotlib.widgets import Button
from matplotlib.widgets import TextBox

global stop_points
global X1
global X2
global Y_aux
global X
global Y
global epochs
global epochData
global l
global larningData
X1 = []
X2 = []
Y_aux = []
X = []
Y = []
stop_points = False
epochs = "50"
epochData = 50
l = "0.1"
larningData = 0.1
#mouse click function to store coordinates and plot vertical red line
def onclick(event):
# Only use event within the axes.
global X1
global X2
global Y_aux
global X
global Y
global stop_points

if not event.inaxes == ax1:

return

if check_box.get_status()[0] and not(stop_points):

ix, iy = event.xdata, event.ydata
X1.append((ix))
X2.append((iy))
Y.append(0)
ax1.plot(ix,iy, marker = "o", color = "red")
fig.canvas.draw_idle()

elif not(stop_points):
ix, iy = event.xdata, event.ydata
 X1.append((ix))
X2.append((iy))
Y.append(1)
ax1.plot(ix,iy, marker = "o", color = "blue")
fig.canvas.draw_idle()

class Perceptron(object):
ind = 0
def __init__(self, n_input, learning_rate):
self.w = -1 + 2 * np.random.rand(n_input)
self.b = -1 + 2 * np.random.rand()
self.eta = learning_rate

def predict(self, X):

p = X.shape[1]
y_est = np.zeros(p)
for i in range(p):
y_est[i] = np.dot(self.w, X[:,i]) + self.b
if y_est[i] >= 0:
y_est[i] = 1
else:
y_est[i] = 0
return y_est

def fit(self, X, Y, epochs):

p = X.shape[1]
for _ in range(epochs):
for i in range(p):
y_est = self.predict(X[:,i].reshape(-1,1))
self.w += self.eta * (Y[i] - y_est) * X[:,i]
self.b += self.eta * (Y[i] - y_est)

def draw_2d(self, model, Xself, Yself):

w1, w2, b = model.w[0], model.w[1], model.b
li, ls = -1, 1
ax1.plot([li,ls],
[(1/w2)*(-w1*(li)-b), (1/w2)*(-w1*(ls)-b)])

class Start(object):
def start(self, event):
global stop_points
global X
global Y
global epochData
global larningData

X = np.array([X1,X2])

print(Y)
neuron = Perceptron(2, larningData)
if buttonS.label.get_text() == 'Iniciar':
buttonS.label.set_text("Agregar puntos")
stop_points = True
 neuron.fit(X, Y, epochData)
print(neuron.predict(X))
neuron.draw_2d(neuron, X, Y, );
elif buttonS.label.get_text() == 'Agregar puntos':
buttonS.label.set_text("Iniciar")
stop_points = False

callback = Start()
#plots the graph
x = range(-1,2)
y = range(-1,2)

fig, ax1 = plt.subplots()

ax1.plot(x,y, color = "white")
ax1.set_title('Grafica')

#create the check box

ax2 = plt.axes([0.8, 0.05, 0.1, 0.075])
check_box = CheckButtons(ax2, ['Color: ON(Rojo)/OFF(Azul)'], [False,])

button_start = plt.axes([0.65, 0.05, 0.1, 0.075])

buttonS = Button(button_start, 'Iniciar')
buttonS.on_clicked(callback.start)

def submit_e(text):
global epochData
global epochs
try:
epochData = eval(text)
if epochData < 1:
epochData = 1
text_box_e.set_val("1")
except:
epochData = 50
text_box_e.set_val("50")

def submit_l(text):
global larningData
global l
try:
larningData = eval(text)
if larningData < 0:
larningData = 0.1
text_box_l.set_val("0.1")
except:
larningData = 0.1
text_box_l.set_val("0.1")

epoch_box = plt.axes([0.15, 0.05, 0.075, 0.075])

text_box_e = TextBox(epoch_box, 'Epocas', initial=epochs)
text_box_e.on_submit(submit_e)
learning_box = plt.axes([0.35, 0.05, 0.1, 0.075])
text_box_l = TextBox(learning_box, 'Aprendizaje', initial=l)
text_box_l.on_submit(submit_l)

# List to store coordinates

cid = fig.canvas.mpl_connect('button_press_event', onclick)

Grafica
 CONCLUSIÓN

Finalmente, para concluir considero que esta práctica resulto algo complicada, porque si
bien el algoritmo del perceptrón es a priori bastante sencillo los requisitos de la interfaz
subieron considerablemente el nivel de la práctica. Para poder resolverla tuve que utilizar la
librería de Python matplotlib y además un evento en Python para identificar cuando el
usuario hacía clic. Teniendo esto lo demás resulto sencillo, aunque la única desventaja que
había es que matplotlib no te permite configurar todo lo que quieras de sus widgets y estas
muy sujeto a lo que te ofrece. Sin embargo, en lugar de usar otra herramienta decidí
aprovechar todas las ventajas que esta daba en la creación de graficas dinámicas. En cuanto
al algoritmo del perceptrón lo cierto es que simplemente había que almacenar los datos que
las coordenadas me daban y después de obtener esos datos, generaba 2 vectores, el primer
vector tenía las entradas, es decir las coordenadas de cada punto y el segundo las salidas
deseadas es decir 0 o 1 de acuerdo con el color. Y finalmente mandaba dichos parámetros
al algoritmo y usando la librería numpy se volvería sencillo operar sobre vectores. Al final
simplemente si los puntos son separables la línea se dibuja con bastante precisión, pero
cuando no es así el algoritmo sigue hasta terminar las épocas y encontrarse con que
gráficamente no son separables por un solo hiperplano.