El modelo perceptron es una de las bases del aprendizaje automático, inspirado en el funcionamiento de las neuronas en el cerebro humano. Fue desarrollado por Frank Rosenblatt en la década de 1950 y está diseñado para realizar tareas de clasificación binaria, como determinar si un objeto pertenece o no a una categoría.
¿Qué Es el Modelo Perceptron?
En su forma más simple, un perceptrón procesa múltiples entradas, cada una con un peso asociado, y calcula una suma ponderada de estas entradas. Posteriormente, aplica una función de activación, como una función escalón, para producir una salida binaria (0 o 1) dependiendo de si la suma ponderada supera un umbral predefinido.
Características Clave del Perceptrón:
- Es un modelo utilizado para problemas de clasificación linealmente separables.
- Produce una salida binaria basada en un umbral de activación.
- Se utiliza en tareas como detección de spam, diagnóstico médico
Diferencias Entre el Perceptrón y una Neurona Biológica
Las similitudes entre el perceptrón y una neurona biológica incluyen:
- Procesamiento de Señales:
- Una neurona biológica recibe señales en sus dendritas, y si la suma de estas supera un umbral, genera una señal de salida.
- En el perceptrón, se calculan las entradas ponderadas y se compara con un umbral para determinar la salida.
- Finalidad:
- Las neuronas biológicas forman parte del sistema nervioso y procesan información sensorial.
- El perceptrón es un modelo matemático utilizado en aprendizaje automático.
Aunque comparten el concepto de umbral y salidas binarias, sus contextos y aplicaciones son diferentes.
Componentes Principales del Modelo Perceptrón
- Entradas: Representadas como .
- Pesos: Cada entrada tiene un peso asociado , que determina su importancia.
- Suma Ponderada: La suma de las entradas multiplicadas por sus pesos.
- Función de Activación: Convierte la suma ponderada en una salida binaria. Por ejemplo, si , la salida será 1; de lo contrario, será 0.
- Salida: Determina la categoría de la muestra.
¿Cómo Aprende un Perceptrón?
El aprendizaje en el perceptrón se basa en un proceso iterativo donde los pesos se ajustan para minimizar los errores. Este proceso se conoce como regla delta, que corrige los pesos en función de la diferencia entre la salida esperada y la salida obtenida.
Problemas que Puede Resolver un Perceptrón
El perceptrón es ideal para resolver problemas de clasificación binaria linealmente separables, como:
- Clasificación de Spam: Identificar correos electrónicos como spam o no spam.
- Detección de Fraudes: Clasificar transacciones como válidas o fraudulentas.
- Diagnóstico Médico: Clasificar condiciones médicas basadas en datos de pacientes.
Sin embargo, no es adecuado para problemas con fronteras de decisión no lineales, que requieren modelos más complejos como redes neuronales multicapa.
Implementación de un Perceptrón en Python
A continuación, se presenta una implementación básica del modelo perceptrón utilizando Python:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.pyplot as pyplot
class PresentarDatos(object):
def __init__(self,X,W,coste,minEscalaEjeX,maxEscalaEjeX,minEscalaEjeY,maxEscalaEjeY,minRangoValoresX,maxRangoValoresX):
self.X=X
self.W=W
self.coste=coste
self.x = range(minRangoValoresX,maxRangoValoresX)
self.minEscalaEjeX = minEscalaEjeX
self.minEscalaEjeX = minEscalaEjeX
self.maxEscalaEjeX = maxEscalaEjeX
self.minEscalaEjeY = minEscalaEjeY
self.maxEscalaEjeY = maxEscalaEjeY
self.minRangoValoresX = minRangoValoresX
self.maxRangoValoresX = maxRangoValoresX
def __recta(self,x):
z = float((-self.W[2]-self.W[0]*x)/self.W[1])
return z
def __dibujarGraficaDispersion(self):
pyplot.scatter(self.X[:50, 0], self.X[:50, 1],
color='red', marker='o', label='cero')
pyplot.scatter(self.X[50:100, 0], self.X[50:100, 1],
color='blue', marker='x', label='uno')
pyplot.xlabel('sepalo')
pyplot.ylabel('petalo')
def __funcionCoste(self):
pyplot.ylabel('coste')
pyplot.xlabel('epocas')
pyplot.legend(loc='upper left')
#x=np.linspace(1,len(self.coste),len(self.coste))
pyplot.plot(range(1, len(self.coste) + 1), self.coste, marker='o')
pyplot.show()
def __dibujarRecta(self):
# recta= Recta(self.X,self.W)
y2= [self.__recta(x) for x in self.x ]
pyplot.plot(self.x, y2)
# Establecer el color de los ejes.
pyplot.axhline(0, color="black")
pyplot.axvline(0, color="black")
# Escala de los ejes
pyplot.xlim(self.minEscalaEjeX, self.maxEscalaEjeX)
pyplot.ylim(self.minEscalaEjeY, self.maxEscalaEjeY)
pyplot.show()
# representar los datos
def pintarDatos(self):
self.__dibujarGraficaDispersion()
self.__dibujarRecta()
self.__funcionCoste()
class Percentron():
def __init__(self,eta,n_iter):
self.W=np.array([0.0,0.0])
self.eta=eta
self.n_iter=n_iter
self.umbral=1
self.cadena_errors= []
def fit(self,X,Y):
n_muestras=len(Y)
for i in range(0,self.n_iter):
error=0
for i in range(0,n_muestras):
y = self.__prodEscalar(X[i],self.W) + self.umbral
if y >= 0 :
y = 1
else:
y = -1
sigma = (Y[i]-y)
self.W = self.W + (self.eta*sigma* X[i,:])
self.umbral = self.umbral + self.eta * sigma
error = error + np.abs(sigma)
self.cadena_errors.append(error)
self.n_iter = self.n_iter + 1
return self
def __prodEscalar(self,_V1,_V2):
s = 0
for i, x in enumerate(_V1):
s = _V1[i] * _V2[i] + s
return s
def predict(self,X):
y = np.dot(X,self.W) + self.umbral
return np.where(y >=0.0,1,-1)
def getDatos():
datos = pd.read_csv("iris.data",header = None)
datos.tail()
Y = datos.iloc[0:100, 4].values
Y = np.where(Y == 'Iris-setosa', -1, 1)
#Tomamos las muestras
X = datos.iloc[0:100, [0,2]].values #longitud del sepalo y del petalo
return X,Y
X,Y = getDatos()
#Valor inicial W
eta=0.01
n_iter=10
cadena_errors = []
percentron = Percentron(eta,n_iter)
datos = percentron.fit(X,Y)
W = np.append(datos.W,datos.umbral)
presentarDatos = PresentarDatos(X,W,datos.cadena_errors,4,7.5,0.5,5.5,0,10)
presentarDatos.pintarDatos()
Visualización del Proceso de Aprendizaje
El siguiente código muestra cómo se visualizan los datos y la línea de decisión:
def __recta(self,x):
z = float((-self.W[2]-self.W[0]*x)/self.W[1])
return z
def __dibujarGraficaDispersion(self):
pyplot.scatter(self.X[:50, 0], self.X[:50, 1],
color='red', marker='o', label='cero')
pyplot.scatter(self.X[50:100, 0], self.X[50:100, 1],
color='blue', marker='x', label='uno')
pyplot.xlabel('sepalo')
pyplot.ylabel('petalo')
def __funcionCoste(self):
pyplot.ylabel('coste')
pyplot.xlabel('epocas')
pyplot.legend(loc='upper left')
#x=np.linspace(1,len(self.coste),len(self.coste))
pyplot.plot(range(1, len(self.coste) + 1), self.coste, marker='o')
pyplot.show()
def __dibujarRecta(self):
# recta= Recta(self.X,self.W)
y2= [self.__recta(x) for x in self.x ]
pyplot.plot(self.x, y2)
# Establecer el color de los ejes.
pyplot.axhline(0, color="black")
pyplot.axvline(0, color="black")
# Escala de los ejes
pyplot.xlim(self.minEscalaEjeX, self.maxEscalaEjeX)
pyplot.ylim(self.minEscalaEjeY, self.maxEscalaEjeY)
pyplot.show()
# representar los datos
def pintarDatos(self):
self.__dibujarGraficaDispersion()
self.__dibujarRecta()
self.__funcionCoste()
