Está en la página 1de 3

# Ricardo Ivan Macias Fusco

# Se utilizo la informacion del ejercicio anterior.


# Se utilizo la informacion proporcionada en https://www.youtube.com/playlist?
list=PL5tcWHG-UPH1OeZ2vU5xQd7RVpkWvwJny
# Se utilizo la informacion proporcionada en https://simonepeirone.it/posts/ml-01-
perceptron/
# Este segundo enlace se utilizo principalmente para la parte de MatPlotLib

# Se importa numpy para el uso de arreglos numericos y vectores.


import numpy as np
# Se importa matplotlib para graficas los resultados
from matplotlib import pyplot as plt
from matplotlib.colors import ListedColormap
# Se importa pandas para poder descargar el dataset y leer el archivo csv
import pandas as pd

# Se crea la clase perceptron


class Perceptron(object):
# Initiating the learning rate and number of iterations.
def __init__(self, cardinalidad, rango=1, limite=10):
# Valor limite es para limitar el numero de epocas que se pueden usar para
aprender.
self.limite = limite
# Valor rango es para validar el cambio que se puede generar con cada epoca
self.rango = rango
# Valor errores para almacenar los errores en un arreglo
self.errores = []
# pesos sirve para determinar los valores de entrada, y se agrega el sesgo
como un peso extra
self.pesos = np.zeros(cardinalidad + 1)

# se crea metodo para entrenar los valores y se envian como parametros las
reglas y su resultado
def entrenar(self, valores_entrenados, resultados_esperados):
# self.pesos = np.zeros(valores_entrenados.shape[1] + 1)
# iteramos las epocas necesarias segun el limite
for _ in range(self.limite):
error = 0
for valor, resultado_esperado in zip(valores_entrenados,
resultados_esperados):
# Se envia el valor al metodo predecir para saber su resultado en
el vector.
prediccion = self.predecir(valor)
# Buscamos los valores sin el sesgo, y los multiplicamos por el
rango de aprendizaje para tener el entrenamiento.
self.pesos[1:] += self.rango * (resultado_esperado - prediccion) *
valor
# Ignoramos el sesgo y solo le guardamos el aprendizaje con el
rango, pero sin los valores de entrada.
self.pesos[0] += self.rango * (resultado_esperado - prediccion)
error += int(self.pesos[0] != 0)
self.errores.append(error)
return self

# Se crea metodo para predecir, y recibe como parametro los valores de entrada
def predecir(self, valores):
# se utilizan los vectores para calcular con multiplicacion si el valor es
1 o 0
calculo = np.dot(valores, self.pesos[1:]) + self.pesos[0]
# Se regresa el resultado de la operacion.
return np.where(calculo >= 0.0, 1, -1)

# Se extrae informacion del dataset de iris


resultados_esperados = pd.read_csv("https://archive.ics.uci.edu/ml/machine-
learning-databases/iris/iris.data", header=None)
# Se crea una matriz con los datos extraidos.
valores_entrenados = resultados_esperados.iloc[0:100, [0, 2]].values
# Se manda llamar los valores de 1 a 50 y se les asigna un color (iris-setosa)
plt.scatter(valores_entrenados[:50, 0], valores_entrenados[:50, 1], color='red')
# Se manda llamar los valores de 51 a 100 y se les asigna un color (iris-
versicolor)
plt.scatter(valores_entrenados[50:100, 0], valores_entrenados[50:100, 1],
color='blue')
# Se manda llamar los valores de 101 a 150 y se les asigna un color (iris-
virginica)
plt.scatter(valores_entrenados[100:150, 0], valores_entrenados[100:150, 1],
color='yellow')
# Se manda llamar una muestra de la matriz graficada
plt.show()
# Se reduce la muestra
resultados_esperados = resultados_esperados.iloc[0:100, 4].values
# Se asignan los valores segun la informacion que se obtiene del dataset por el
valor
# Si es setosa se da el -1 y cualquier otra cosa se da valor 1
resultados_esperados = np.where(resultados_esperados == 'Iris-setosa', -1, 1)

# Se instancia el perceptron y se le asignan valores de entrada


clasificador = Perceptron(2)
# se envian los valores para que sean entrenados.
clasificador.entrenar(valores_entrenados, resultados_esperados)
# Se muestran los resultados de los errores.
plt.plot(range(1, len(clasificador.errores) + 1), clasificador.errores, marker='o')
plt.xlabel('Epocas')
plt.ylabel('Errores de clasificacion')
plt.show()

# Esta parte fue tomada de https://simonepeirone.it/posts/ml-01-perceptron/ para el


uso de Matplotlib
def plot_decision_regions(X, y, classifier, resolution=0.02):
# define los colores para el mapa.
markers = ('s', 'x', 'o', '^', 'v')
colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
cmap = ListedColormap(colors[:len(np.unique(y))])
# Grafica la parte de los resultados en el mapa
x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
np.arange(x2_min, x2_max, resolution))
Z = classifier.predecir(np.array([xx1.ravel(), xx2.ravel()]).T)
Z = Z.reshape(xx1.shape)
plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap)
plt.xlim(xx1.min(), xx1.max())
plt.ylim(xx2.min(), xx2.max())
# Imprime los resultados
for idx, cl in enumerate(np.unique(y)):
plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1],
alpha=0.8, c=cmap(idx),
marker=markers[idx], label=cl)

# Muestra la informacion de resultados en una grafica


plot_decision_regions(valores_entrenados, resultados_esperados,
classifier=clasificador)
plt.show()

También podría gustarte