Algoritmo de Perceptrón para la clasificación en Python

El Perceptron es un algoritmo de aprendizaje de máquina lineal para tareas de clasificación binaria.

Puede considerarse uno de los primeros y más simples tipos de redes neuronales artificiales. Definitivamente no es un aprendizaje «profundo», pero es un importante elemento constitutivo.

Al igual que la regresión logística, puede aprender rápidamente una separación lineal en el espacio de las características para tareas de clasificación de dos clases, aunque a diferencia de la regresión logística, aprende utilizando el algoritmo de optimización de descenso de gradiente estocástico y no predice probabilidades calibradas.

En este tutorial, descubrirá el algoritmo de aprendizaje de la máquina de clasificación de Perceptrón.

Después de completar este tutorial, lo sabrás:

El Clasificador de Perceptrón es un algoritmo lineal que puede aplicarse a tareas de clasificación binaria.

Cómo encajar, evaluar y hacer predicciones con el modelo Perceptron con Scikit-Learn.
Cómo sintonizar los hiperparámetros del algoritmo de Perceptrón en un determinado conjunto de datos.

Empecemos.

Algoritmo de Perceptrón para la clasificación en Python
Foto de Belinda Novika, algunos derechos reservados.

Resumen del Tutorial

Este tutorial está dividido en 3=tres partes; son:

Algoritmo de Percepción

Perceptrón con Scikit-Learn
Sintonizar los hiperparámetros del Perceptrón

Algoritmo de Percepción

El algoritmo del Perceptrón es un algoritmo de aprendizaje de máquina de clasificación de dos clases (binarias).

Es un tipo de modelo de red neuronal, quizás el tipo más simple de modelo de red neuronal.

Consiste en un único nodo o neurona que toma una fila de datos como entrada y predice una etiqueta de clase. Esto se consigue calculando la suma ponderada de las entradas y un sesgo (establecido en 1). La suma ponderada de la entrada del modelo se denomina activación.

Activación = Pesos * Entradas + Sesgo

Si la activación está por encima de 0,0, el modelo dará 1,0; de lo contrario, dará 0,0.

Predicción 1: Si la activación > 0.0
Predecir 0: Si la activación <= 0.0

Dado que las entradas se multiplican por los coeficientes del modelo, como la regresión lineal y la regresión logística, es una buena práctica normalizar o estandarizar los datos antes de utilizar el modelo.

El Perceptrón es un algoritmo de clasificación lineal. Esto significa que aprende un límite de decisión que separa dos clases utilizando una línea (llamada hiperplano) en el espacio de características. Como tal, es apropiado para aquellos problemas en los que las clases pueden ser bien separadas por una línea o un modelo lineal, lo que se conoce como linealmente separable.

Los coeficientes del modelo se denominan pesos de entrada y se entrenan utilizando el algoritmo de optimización de descenso de gradiente estocástico.

Los ejemplos del conjunto de datos de entrenamiento se muestran al modelo de uno en uno, el modelo hace una predicción y se calcula el error. Luego se actualizan los pesos del modelo para reducir los errores del ejemplo. Esto se llama la regla de actualización del Perceptrón. Este proceso se repite para todos los ejemplos del conjunto de datos de entrenamiento, llamado una época. Este proceso de actualización del modelo usando ejemplos se repite entonces para muchas épocas.

Los pesos de los modelos se actualizan con una pequeña proporción del error de cada lote, y la proporción se controla mediante un hiperparámetro llamado tasa de aprendizaje, que suele fijarse en un valor pequeño. Esto es para asegurar que el aprendizaje no ocurra demasiado rápido, lo que da como resultado un modelo de habilidad posiblemente menor, lo que se denomina convergencia prematura del procedimiento de optimización (búsqueda) de los pesos del modelo.

pesos(t + 1) = pesos

El entrenamiento se detiene cuando el error cometido por el modelo cae a un nivel bajo o ya no mejora, o se realiza un número máximo de épocas.

Los valores iniciales de los pesos del modelo se fijan en pequeños valores aleatorios. Además, el conjunto de datos de entrenamiento se baraja antes de cada época de entrenamiento. Esto es por diseño para acelerar y mejorar el proceso de entrenamiento del modelo. Debido a esto, el algoritmo de aprendizaje es estocástico y puede lograr resultados diferentes cada vez que se ejecuta. Por ello, es una buena práctica resumir el rendimiento del algoritmo en un conjunto de datos utilizando una evaluación repetida e informando de la precisión de la clasificación media.

El ritmo de aprendizaje y el número de épocas de entrenamiento son hiperparámetros del algoritmo que se pueden establecer utilizando la heurística o el ajuste de hiperparámetros.

Para más información sobre el algoritmo Perceptrón, vea el tutorial:

Ahora que estamos familiarizados con el algoritmo de Perceptrón, exploremos cómo podemos usar el algoritmo en Python.

Perceptrón con Scikit-Learn

El algoritmo Perceptron está disponible en la biblioteca de aprendizaje de la máquina Python de scikit-learn a través de la clase Perceptron.

La clase permite configurar el ritmo de aprendizaje (eta0), que por defecto es 1.0.

<div id="ezoic-pub-ad-placeholder-720" data-inserter-version="2"></div> … # Definir el modelo modelo = Perceptrón(eta0=1.0)

...

# Definir el modelo

modelo = Perceptron(eta0=1.0)

La implementación también permite configurar el número total de épocas de entrenamiento (max_iter), que por defecto es de 1.000.

… # Definir el modelo modelo = Perceptrón(max_iter=1000)<div id="ezoic-pub-ad-placeholder-722" data-inserter-version="2"></div>

...

# Definir el modelo

modelo = Perceptron(max_iter=1000)

La implementación del algoritmo Perceptron de scikit-learn también proporciona otras opciones de configuración que puede querer explorar, como la parada temprana y el uso de una pérdida de penalización.

Podemos demostrar el clasificador Perceptrón con un ejemplo práctico.

Primero, definamos un conjunto de datos de clasificación sintética.

Usaremos la función make_classification() para crear un conjunto de datos con 1.000 ejemplos, cada uno con 20 variables de entrada.

El ejemplo crea y resume el conjunto de datos.

# Conjunto de datos de clasificación de pruebas de sklearn.datasets importar make_classification # Definir el conjunto de datos X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1) # resumir el conjunto de datos impresión (forma X, forma Y)<div id="ezoic-pub-ad-placeholder-725" data-inserter-version="2"></div>

# Conjunto de datos de clasificación de pruebas

de sklearn.conjuntos de datos importación hacer_clasificación

# Definir el conjunto de datos

X, y = make_classification(n_muestras=1000, n_funciones=10, n_informativo=10, n_redundante=0, estado_aleatorio=1)

# resumir el conjunto de datos

imprimir(X.forma, y.forma)

Ejecutando el ejemplo se crea el conjunto de datos y se confirma el número de filas y columnas del conjunto de datos.

Podemos ajustar y evaluar un modelo de Perceptrón usando la validación cruzada de repetición estratificada k-fold a través de la clase RepeatedStratifiedKFold. Usaremos 10 pliegues y tres repeticiones en el arnés de prueba.

Usaremos la configuración por defecto.

… # Crear el modelo modelo = Perceptron()<div id="ezoic-pub-ad-placeholder-728" data-inserter-version="2"></div>

...

# Crear el modelo

modelo = Perceptron()

El ejemplo completo de la evaluación del modelo de Perceptrón para la tarea de clasificación binaria sintética se enumera a continuación.

# Evaluar un modelo de perceptrón en el conjunto de datos de la importación numérica significa de numpy import std de sklearn.datasets importar make_classification de sklearn.model_selection import cross_val_score de sklearn.model_selection import RepeatedStratifiedKFold de sklearn.linear_model import Perceptron # Definir el conjunto de datos X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1) # Definir el modelo modelo = Perceptron() # Definir el método de evaluación del modelo cv = RepetidoEstratificadoKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1) # Evaluar el modelo puntuación = cross_val_score(modelo, X, y, puntuación=’precisión’, cv=cv, n_jobs=-1) # Resumir el resultado print(‘Precisión media: %.3f (%.3f)’ % (media(puntuaciones), std(puntuaciones))

# Evaluar un modelo de perceptrón en el conjunto de datos

de numpy importación significa

de numpy importación std

de sklearn.conjuntos de datos importación make_classification

de sklearn.model_selection importación puntaje_valor_cruzado

de sklearn.model_selection importación RepeatedStratifiedKFold

de sklearn.modelo_lineal importación Perceptron

# Definir el conjunto de datos

X, y = make_classification(n_muestras=1000, n_funciones=10, n_informativo=10, n_redundante=0, estado_aleatorio=1)

# Definir el modelo

modelo = Perceptron()

# Definir el método de evaluación del modelo

cv = RepeatedStratifiedKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1)

# Evaluar el modelo

resultados = puntaje_valor_cruzado(modelo, X, y, puntuación=«exactitud, cv=cv, n_jobs=–1)

# Resumir el resultado

imprimir(«Precisión media: %.3f (%.3f) % (significa(resultados), std(resultados)))

La ejecución del ejemplo evalúa el algoritmo Perceptrón en el conjunto de datos sintéticos e informa de la precisión media en las tres repeticiones de la validación cruzada multiplicada por 10.

Sus resultados específicos pueden variar dada la naturaleza estocástica del algoritmo de aprendizaje. Considere ejecutar el ejemplo unas cuantas veces.

En este caso, podemos ver que el modelo alcanzó una precisión media de alrededor del 84,7 por ciento.

Precisión media: 0,847 (0,052)<div id="ezoic-pub-ad-placeholder-732" data-inserter-version="2"></div>

Precisión media: 0,847 (0,052)

Podemos decidir usar el clasificador de Perceptrón como nuestro modelo final y hacer predicciones sobre nuevos datos.

Esto puede lograrse ajustando el conducto del modelo a todos los datos disponibles y llamando a la función predict() que pasa en una nueva fila de datos.

Podemos demostrarlo con un ejemplo completo que se enumera a continuación.

<div id="ezoic-pub-ad-placeholder-734" data-inserter-version="2"></div> # Hacer una predicción con un modelo de perceptrón en el conjunto de datos de sklearn.datasets importar make_classification de sklearn.linear_model import Perceptron # Definir el conjunto de datos X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1) # Definir el modelo modelo = Perceptron() # Modelo de ajuste model.fit(X, y) # Definir nuevos datos fila = [0.12777556,-3.64400522,-2.23268854,-1.82114386,1.75466361,0.1243966,1.03397657,2.35822076,1.01001752,0.56768485] # hacer una predicción yhat = model.predict([row]) # resumir la predicción print(‘Clase prevista: %d’ % yhat)

# Hacer una predicción con un modelo de perceptrón en el conjunto de datos

de sklearn.conjuntos de datos importación make_classification

de sklearn.modelo_lineal importación Perceptron

# Definir el conjunto de datos

X, y = make_classification(n_muestras=1000, n_funciones=10, n_informativo=10, n_redundante=0, estado_aleatorio=1)

# Definir el modelo

modelo = Perceptron()

# Modelo de ajuste

modelo.encajar(X, y)

# Definir nuevos datos

fila = [[0.12777556,–3.64400522,–2.23268854,–1.82114386,1.75466361,0.1243966,1.03397657,2.35822076,1.01001752,0.56768485]

# hacer una predicción

yhat = modelo.predecir([[fila])

# resumir la predicción

imprimir(Clase prevista: %d’. % yhat)

Ejecutando el ejemplo se ajusta al modelo y hace una predicción de etiqueta de clase para una nueva fila de datos.

A continuación, podemos ver la configuración de los hiperparámetros del modelo.

Sintonizar los hiperparámetros del Perceptrón

Los hiperparámetros del algoritmo del Perceptrón deben ser configurados para su conjunto de datos específico.

Tal vez el hiperparámetro más importante es el ritmo de aprendizaje.

Una gran tasa de aprendizaje puede hacer que el modelo aprenda rápido, pero tal vez a costa de una menor habilidad. Un menor ritmo de aprendizaje puede dar como resultado un modelo de mejor rendimiento, pero puede llevar mucho tiempo entrenar al modelo.

Puede obtener más información sobre la exploración de los índices de aprendizaje en el tutorial:

Es común probar las tasas de aprendizaje en una escala de logaritmo entre un valor pequeño como 1e-4 (o menor) y 1.0. En este caso probaremos los siguientes valores:

… # Definir la cuadrícula cuadrícula = dict() cuadrícula[‘eta0’] = [0.0001, 0.001, 0.01, 0.1, 1.0]

...

# Definir la cuadrícula

cuadrícula = dict()

cuadrícula[[«eta0] = [[0.0001, 0.001, 0.01, 0.1, 1.0]

El siguiente ejemplo lo demuestra utilizando la clase GridSearchCV con una cuadrícula de valores que hemos definido.

<div id="ezoic-pub-ad-placeholder-740" data-inserter-version="2"></div> # Tasa de aprendizaje de búsqueda de cuadrículas para el perceptrón de sklearn.datasets importar make_classification de sklearn.model_selection import GridSearchCV de sklearn.model_selection import RepeatedStratifiedKFold de sklearn.linear_model import Perceptron # Definir el conjunto de datos X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1) # Definir el modelo modelo = Perceptron() # Definir el método de evaluación del modelo cv = RepetidoEstratificadoKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1) # Definir la cuadrícula cuadrícula = dict() cuadrícula[‘eta0′] = [0.0001, 0.001, 0.01, 0.1, 1.0] # Definir la búsqueda search = GridSearchCV(modelo, cuadrícula, puntuación=’precisión’, cv=cv, n_jobs=-1) # realizar la búsqueda resultados = search.fit(X, y) # Resumir print(‘Precisión media: %.3f’ % resultados.mejor_puntuación_) print(‘Config: %s’ % results.best_params_) # resumir todo media = resultados.cv_resultados_[‘mean_test_score’] params = resultados.cv_resultados_[‘params’] por media, param en zip(media, params): print(«>%.3f with: %r» % (media, param))

# Tasa de aprendizaje de búsqueda de cuadrículas para el perceptrón

de sklearn.conjuntos de datos importación make_classification

de sklearn.model_selection importación GridSearchCV

de sklearn.model_selection importación RepeatedStratifiedKFold

de sklearn.modelo_lineal importación Perceptron

# Definir el conjunto de datos

X, y = make_classification(n_muestras=1000, n_funciones=10, n_informativo=10, n_redundante=0, estado_aleatorio=1)

# Definir el modelo

modelo = Perceptron()

# Definir el método de evaluación del modelo

cv = RepeatedStratifiedKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1)

# Definir la cuadrícula

cuadrícula = dict()

cuadrícula[[«eta0] = [[0.0001, 0.001, 0.01, 0.1, 1.0]

# Definir la búsqueda

busca en = GridSearchCV(modelo, cuadrícula, puntuación=«exactitud, cv=cv, n_jobs=–1)

# realizar la búsqueda

resultados = busca en.encajar(X, y)

# Resumir

imprimir(Precisión media: %.3f’. % resultados.mejor_puntuación_)

imprimir(Config: %s’ % resultados.best_params_)

# resumir todo

significa = resultados.cv_resultados_[[‘mean_test_score’]

params = resultados.cv_resultados_[[«params]

para significa, param en zip(significa, params):

imprimir(«>%.3f con: %r» % (significa, param))

Al ejecutar el ejemplo se evaluará cada combinación de configuraciones utilizando una validación cruzada repetida.

Sus resultados específicos pueden variar dada la naturaleza estocástica del algoritmo de aprendizaje. Intente ejecutar el ejemplo unas cuantas veces.

En este caso, podemos ver que una tasa de aprendizaje menor que la predeterminada da como resultado un mejor rendimiento con una tasa de aprendizaje de 0,0001 y 0,001, alcanzando ambas una precisión de clasificación de alrededor del 85,7 por ciento, en comparación con la predeterminada de 1,0 que alcanzó una precisión de alrededor del 84,7 por ciento.

Precisión media: 0,857 Config: {‘eta0’: 0.0001} >0.857 con: {a6}*: 0.0001} >0.857 con: {a6}*: 0.001} >0.853 con: {a6}*: 0.01} >0.847 con: {a6}*: 0.1} >0.847 con: {‘eta0’: 1.0}

Precisión media: 0,857

Config: {‘eta0’: 0.0001}

>0.857 con: {a6}*: 0.0001}

>0.857 con: {a6}*: 0.001}

>0.853 con: {a6}*: 0.01}

>0.847 con: {a6}*: 0.1}

>0.847 con: {a6}*: 1.0}

Otro importante hiperparámetro es la cantidad de épocas que se utilizan para entrenar el modelo.

Esto puede depender del conjunto de datos de entrenamiento y podría variar enormemente. De nuevo, exploraremos los valores de configuración en una escala de registro entre 1 y 1e+4.

… # Definir la cuadrícula cuadrícula = dict() cuadrícula[‘max_iter’] = [1, 10, 100, 1000, 10000]

...

# Definir la cuadrícula

cuadrícula = dict()

cuadrícula[[‘max_iter’] = [[1, 10, 100, 1000, 10000]

Usaremos nuestro índice de aprendizaje de 0,0001 encontrado en la búsqueda anterior.

<div id="ezoic-pub-ad-placeholder-746" data-inserter-version="2"></div> … # Definir el modelo modelo = Perceptrón(eta0=0.0001)

...

# Definir el modelo

modelo = Perceptron(eta0=0.0001)

El ejemplo completo de la cuadrícula de búsqueda del número de épocas de entrenamiento se enumera a continuación.

# Búsqueda en la cuadrícula de las épocas totales para el Percitrón de sklearn.datasets importar make_classification de sklearn.model_selection import GridSearchCV de sklearn.model_selection import RepeatedStratifiedKFold de sklearn.linear_model import Perceptron # Definir el conjunto de datos X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1) # Definir el modelo modelo = Perceptrón(eta0=0.0001) # Definir el método de evaluación del modelo cv = RepetidoEstratificadoKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1) # Definir la cuadrícula cuadrícula = dict() cuadrícula[‘max_iter’] = [1, 10, 100, 1000, 10000] # Definir la búsqueda search = GridSearchCV(modelo, cuadrícula, puntuación=’precisión’, cv=cv, n_jobs=-1) # realizar la búsqueda resultados = search.fit(X, y) # Resumir print(‘Precisión media: %.3f’ % resultados.mejor_puntuación_) print(‘Config: %s’ % results.best_params_) # resumir todo media = resultados.cv_resultados_[‘mean_test_score’] params = resultados.cv_resultados_[‘params’] por media, param en zip(media, params): print(«>%.3f with: %r» % (media, param))<div id="ezoic-pub-ad-placeholder-748" data-inserter-version="2"></div>

# Búsqueda en la cuadrícula de las épocas totales para el Percitrón

de sklearn.conjuntos de datos importación make_classification

de sklearn.model_selection importación GridSearchCV

de sklearn.model_selection importación RepeatedStratifiedKFold

de sklearn.modelo_lineal importación Perceptron

# Definir el conjunto de datos

X, y = make_classification(n_muestras=1000, n_funciones=10, n_informativo=10, n_redundante=0, estado_aleatorio=1)

# Definir el modelo

modelo = Perceptron(eta0=0.0001)

# Definir el método de evaluación del modelo

cv = RepeatedStratifiedKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1)

# Definir la cuadrícula

cuadrícula = dict()

cuadrícula[[‘max_iter’] = [[1, 10, 100, 1000, 10000]

# Definir la búsqueda

busca en = GridSearchCV(modelo, cuadrícula, puntuación=«exactitud, cv=cv, n_jobs=–1)

# realizar la búsqueda

resultados = busca en.encajar(X, y)

# Resumir

imprimir(Precisión media: %.3f’. % resultados.mejor_puntuación_)

imprimir(Config: %s’ % resultados.best_params_)

# resumir todo

significa = resultados.cv_resultados_[[‘mean_test_score’]

params = resultados.cv_resultados_[[«params]

para significa, param en zip(significa, params):

imprimir(«>%.3f con: %r» % (significa, param))

Al ejecutar el ejemplo se evaluará cada combinación de configuraciones utilizando una validación cruzada repetida.

Sus resultados específicos pueden variar dada la naturaleza estocástica del algoritmo de aprendizaje. Intente ejecutar el ejemplo unas cuantas veces.

En este caso, podemos ver que las épocas de 10 a 10.000 resultan en aproximadamente la misma precisión de clasificación. Una excepción interesante sería explorar la configuración de la tasa de aprendizaje y el número de épocas de entrenamiento al mismo tiempo para ver si se pueden lograr mejores resultados.

<div id="ezoic-pub-ad-placeholder-750" data-inserter-version="2"></div> Precisión media: 0,857 Config: {‘max_iter’: 10} >0.850 con: {‘max_iter’: 1} >0.857 con: {‘max_iter’: 10} >0.857 con: {‘max_iter’: 100} >0.857 con: {‘max_iter’: 1000} >0.857 con: {‘max_iter’: 10000}

Precisión media: 0,857

Config: {‘max_iter’: 10}

>0.850 con: {‘max_iter’: 1}

>0.857 con: {‘max_iter’: 10}

>0.857 con: {‘max_iter’: 100}

>0.857 con: {‘max_iter’: 1000}

>0.857 con: {‘max_iter’: 10000}

Más lecturas

Esta sección proporciona más recursos sobre el tema si desea profundizar en él.

Tutoriales

Libros

APIs

Artículos

Resumen

En este tutorial, descubriste el algoritmo de aprendizaje de la máquina de clasificación de Perceptrón.

Específicamente, aprendiste:

El Clasificador de Perceptrón es un algoritmo lineal que puede aplicarse a tareas de clasificación binaria.

Cómo encajar, evaluar y hacer predicciones con el modelo Perceptron con Scikit-Learn.
Cómo sintonizar los hiperparámetros del algoritmo de Perceptrón en un determinado conjunto de datos.

¿Tiene alguna pregunta?
Haga sus preguntas en los comentarios de abajo y haré lo posible por responder.

Descubre el aprendizaje rápido de la máquina en Python!

Desarrolle sus propios modelos en minutos

…con sólo unas pocas líneas de código de aprendizaje científico…

Aprende cómo en mi nuevo Ebook:
Dominio de la máquina de aprendizaje con la pitón

Cubre Tutoriales de auto-estudio y proyectos integrales como:
Cargando datos, visualización, modelado, tuningy mucho más…

Finalmente traer el aprendizaje automático a
Sus propios proyectos

Sáltese los académicos. Sólo los resultados.

Ver lo que hay dentro

Resumen del Tutorial

Algoritmo de Percepción

Perceptrón con Scikit-Learn

Sintonizar los hiperparámetros del Perceptrón

Más lecturas

Tutoriales

Libros

APIs

Artículos

Resumen

Descubre el aprendizaje rápido de la máquina en Python!

Desarrolle sus propios modelos en minutos

Finalmente traer el aprendizaje automático a Sus propios proyectos

Finalmente traer el aprendizaje automático a
Sus propios proyectos