Trazar límite de decisión Python

1. Instalar bibliotecas de requisitos previos
2. Límite de decisión
3. Use el pyplot de Matplotlib para trazar un límite de decisión que separa 2 clases
4. Generar límite de decisión

Un resumen visual de sus resultados con imágenes, gráficos y diagramas le da a la mente humana un tiempo más pausado para procesar, comprender y reconocer patrones en cualquier dato dado. Este artículo pasará por un procedimiento paso a paso para trazar un límite de decisión usando el pyplot de Matplotlib.

Para esto, utilizaremos el paquete de conjunto de datos de datos preprocesados incorporados (sin datos faltantes ni valores atípicos) proporcionado por la biblioteca Sklearn para trazar el límite de decisión en los datos. Luego usaremos la biblioteca de Matplotlib para trazar el límite de decisión.

Instalar bibliotecas de requisitos previos

Para usar la función de trazado de pyplot de Matplotlib, primero debemos instalar la biblioteca de Matplotlib. Esto lo podemos lograr ejecutando el siguiente comando:

pip install matplotlib

También es fundamental asegurarse de que trabajamos con la versión correcta de Python. Para este artículo, estamos usando la versión 3.10.4.

Podemos verificar la versión de python actualmente instalada ejecutando el siguiente comando:

python --version

Límite de decisión

Los algoritmos de aprendizaje automático de clasificación aprenden a asignar etiquetas a los ejemplos de entrada (observaciones). El objetivo de la clasificación es separar el espacio de características para que las etiquetas se asignen a los puntos en el espacio de características de la manera más correcta posible.

Este método se denomina superficie de decisión o límite, y funciona como una herramienta demostrativa para visualizar los resultados del modelo predictivo de clasificación. Podemos crear un límite de decisión lineal para un mínimo de dos entidades de entrada.

Sin embargo, si hay más de dos entidades de entrada, podemos crear límites de decisión multilineales. Este artículo se centrará en trazar el límite de decisión de dos entidades de entrada.

Use el pyplot de Matplotlib para trazar un límite de decisión que separa 2 clases

Importar las bibliotecas requeridas

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import datasets
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.model_selection import train_test_split

Generar el conjunto de datos

Generaremos un conjunto de datos personalizado utilizando la función make_blobs() de la biblioteca Sklearn dentro de la clase de conjuntos de datos. Como se mencionó anteriormente, el conjunto de datos generado que usaremos es un paquete de conjunto de datos integrado de datos preprocesados (sin datos faltantes ni valores atípicos) proporcionado por la biblioteca Sklearn.

Nuestras variables de conjuntos de datos generados de forma personalizada son las siguientes.

    samples     features    standard deviation
    1000        2           3

XFeature, yFeature = datasets.make_blobs(
    n_samples=1000, centers=2, n_features=2, random_state=1, cluster_std=3
)

Una vez que se completa la generación de datos, podemos crear un diagrama de dispersión de los datos para ver la variabilidad de los datos bajo una luz mucho mejor.

for c_value in range(2):
    row = np.where(yFeature == c_value)
    plt.scatter(XFeature[row, 0], XFeature[row, 1])
plt.show()

En el próximo paso, construiremos el modelo de clasificación para predecir datos no vistos. Podemos usar la regresión logística para nuestro conjunto de datos personalizado, ya que solo tiene dos características.

Modelo de regresión logística

Usaremos una función de modelo de regresión logística proporcionada por la clase Logistic Regression en la biblioteca sklearn y la entrenaremos con nuestros datos de muestra.

regressor = LogisticRegression()
regressor.fit(XFeature, yFeature)
y_pred = regressor.predict(XFeature)

Ahora evaluaremos la precisión mediante la clase precision_score de la biblioteca sklearn.

accuracy = accuracy_score(y, y_pred)
print("Model Accuracy: %.3f" % accuracy)

Generar límite de decisión

Matplotlib proporciona una función valiosa llamada contour(), que puede ayudar a agregar colores mientras se traza entre diferentes puntos. Para lograr esto, primero necesitamos inicializar la cuadrícula de puntos Xfeature o YFeature en el espacio de características.

Después de eso, necesitamos encontrar el valor máximo y el valor mínimo de cada característica y luego aumentar esto en uno para asegurarnos de que se cubra todo el espacio.

min1, max1 = XFeature[:, 0].min() - 1, XFeature[:, 0].max() + 1
min2, max2 = XFeature[:, 1].min() - 1, XFeature[:, 1].max() + 1

La biblioteca numpy proporciona una función arrange() para escalar las coordenadas con una resolución de 0.1.

x1_scale = np.arange(min1, max1, 0.1)
x2_scale = np.arange(min2, max2, 0.1)

En el siguiente paso, la biblioteca numpy proporciona una función meshgrid() para convertir las coordenadas escaladas en una cuadrícula.

x_grid, y_grid = np.meshgrid(x1_scale, x2_scale)

Después de eso, reduciremos la cuadrícula de matriz 2-D a una matriz 1-D usando la función flatten() proporcionada por la biblioteca numpy.

x_g, y_g = x_grid.flatten(), y_grid.flatten()
x_g, y_g = x_g.reshape((len(x_g), 1)), y_g.reshape((len(y_g), 1))

Finalmente, apilaremos la matriz 1-D una al lado de la otra como columnas en un conjunto de datos de entrada, pero con una resolución mucho más alta.

grid = np.hstack((x_g, y_g))

Después de eso, podemos ajustar esto al modelo de regresión que creamos anteriormente para predecir valores.

y_pred_2 = regressor.predict(grid)  # predict the probability
# keep just the probabilities for class 0
p_pred = regressor.predict_proba(grid)
p_pred = p_pred[:, 0]  # reshaping the results
p_pred.shape
pp_grid = p_pred.reshape(x_grid.shape)

Ahora, trazaremos esas cuadrículas pronosticadas como un gráfico de contorno usando contourf() usando diferentes colores.

surface = plt.contourf(x_grid, y_grid, pp_grid, cmap="Pastel1")
plt.colorbar(surface)  # create scatter plot for samples from each class
for class_value in range(2):
    row_ix = np.where(y == class_value)
    plt.scatter(X[row_ix, 0], X[row_ix, 1], cmap="Pastel1")
plt.show()

Y así, terminamos con el siguiente script para trazar un límite de decisión que separa dos clases.

Código completo:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import datasets
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.model_selection import train_test_split

XFeature, yFeature = datasets.make_blobs(
    n_samples=1000, centers=2, n_features=2, random_state=1, cluster_std=3
)

for c_val in range(2):
    row = np.where(yFeature == c_val)
    plt.scatter(XFeature[row, 0], XFeature[row, 1])
plt.show()

reg = LogisticRegression()
reg.fit(XFeature, yFeature)
y_pred = reg.predict(XFeature)

acc = accuracy_score(yFeature, y_pred)
print("Accuracy: %.3f" % acc)

min1, max1 = XFeature[:, 0].min() - 1, XFeature[:, 0].max() + 1
min2, max2 = XFeature[:, 1].min() - 1, XFeature[:, 1].max() + 1

x1_scale = np.arange(min1, max1, 0.1)
x2_scale = np.arange(min2, max2, 0.1)

x_grid, y_grid = np.meshgrid(x1_scale, x2_scale)

x_g, y_g = x_grid.flatten(), y_grid.flatten()
x_g, y_g = x_g.reshape((len(x_g), 1)), y_g.reshape((len(y_g), 1))

grid = np.hstack((x_g, y_g))

y_pred_2 = reg.predict(grid)
p_pred = reg.predict_proba(grid)
p_pred = p_pred[:, 0]
pp_grid = p_pred.reshape(x_grid.shape)

surface = plt.contourf(x_grid, y_grid, pp_grid, cmap="Pastel1")
plt.colorbar(surface)
for class_value in range(2):
    row_ix = np.where(yFeature == class_value)
    plt.scatter(XFeature[row_ix, 0], XFeature[row_ix, 1], cmap="Pastel1")
plt.show()

Producción:

Así es como podemos aplicar el límite de decisión separando dos clases usando el pyplot de Matplotlib.