Trazar la regresión logística multinomial y one-vs-rest

Introducción

La regresión logística es un algoritmo de clasificación que se puede utilizar para problemas de clasificación binaria y multi-clase. En este laboratorio, usaremos la biblioteca scikit-learn para trazar la superficie de decisión de dos modelos de regresión logística, a saber, la regresión logística multinomial y la regresión logística one-vs-rest. Usaremos un conjunto de datos de 3 clases y graficaremos el límite de decisión de los dos modelos para comparar su rendimiento.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargar. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje comentarios después de la sesión y resolveremos rápidamente el problema para usted.

Importar bibliotecas

Comenzaremos importando las bibliotecas necesarias para este laboratorio. Usaremos la biblioteca scikit-learn para generar el conjunto de datos y entrenar los modelos de regresión logística, y la biblioteca matplotlib para trazar el límite de decisión.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.linear_model import LogisticRegression
from sklearn.inspection import DecisionBoundaryDisplay

Generar conjunto de datos

Generaremos un conjunto de datos de 3 clases usando la función make_blobs de scikit-learn. Usaremos 1000 muestras y estableceremos los centros de los grupos en [-5, 0], [0, 1.5], [5, -1]. Luego transformaremos el conjunto de datos usando una matriz de transformación para que el conjunto de datos sea más difícil de clasificar.

centers = [[-5, 0], [0, 1.5], [5, -1]]
X, y = make_blobs(n_samples=1000, centers=centers, random_state=40)
transformation = [[0.4, 0.2], [-0.4, 1.2]]
X = np.dot(X, transformation)

Entrenar el modelo de regresión logística multinomial

Ahora entrenaremos un modelo de regresión logística multinomial usando la función LogisticRegression de scikit-learn. Estableceremos el resolvente en "sag", el número máximo de iteraciones en 100, el estado aleatorio en 42 y la opción de multi-clase en "multinomial". Luego imprimiremos la puntuación de entrenamiento del modelo.

clf = LogisticRegression(
        solver="sag", max_iter=100, random_state=42, multi_class="multinomial"
    ).fit(X, y)

print("training score : %.3f (%s)" % (clf.score(X, y), "multinomial"))

Trazar el límite de decisión del modelo de regresión logística multinomial

Ahora trazaremos la superficie de decisión del modelo de regresión logística multinomial usando la función DecisionBoundaryDisplay de scikit-learn. Estableceremos el método de respuesta en "predict", la mapa de colores en "plt.cm.Paired" y también graficaremos los puntos de entrenamiento.

_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Decision surface of LogisticRegression (multinomial)")
plt.axis("tight")

colors = "bry"
for i, color in zip(clf.classes_, colors):
        idx = np.where(y == i)
        plt.scatter(
            X[idx, 0], X[idx, 1], c=color, cmap=plt.cm.Paired, edgecolor="black", s=20
        )

Entrenar el modelo de regresión logística one-vs-rest

Ahora entrenaremos un modelo de regresión logística one-vs-rest usando los mismos parámetros que en el Paso 3, pero con la opción de multi-clase establecida en "ovr". Luego imprimiremos la puntuación de entrenamiento del modelo.

clf = LogisticRegression(
        solver="sag", max_iter=100, random_state=42, multi_class="ovr"
    ).fit(X, y)

print("training score : %.3f (%s)" % (clf.score(X, y), "ovr"))

Trazar el límite de decisión del modelo de regresión logística one-vs-rest

Ahora trazaremos la superficie de decisión del modelo de regresión logística one-vs-rest usando los mismos parámetros que en el Paso 4, pero tracamos los hiperplanos correspondientes a los tres clasificadores one-vs-rest como líneas discontinuas.

_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Decision surface of LogisticRegression (ovr)")
plt.axis("tight")

colors = "bry"
for i, color in zip(clf.classes_, colors):
        idx = np.where(y == i)
        plt.scatter(
            X[idx, 0], X[idx, 1], c=color, cmap=plt.cm.Paired, edgecolor="black", s=20
        )

xmin, xmax = plt.xlim()
ymin, ymax = plt.ylim()
coef = clf.coef_
intercept = clf.intercept_

def plot_hyperplane(c, color):
        def line(x0):
            return (-(x0 * coef[c, 0]) - intercept[c]) / coef[c, 1]

        plt.plot([xmin, xmax], [line(xmin), line(xmax)], ls="--", color=color)

for i, color in zip(clf.classes_, colors):
        plot_hyperplane(i, color)

Visualizar los gráficos

Ahora visualizaremos ambos gráficos lado a lado para comparar los límites de decisión de los dos modelos.

plt.subplot(1,2,1)
_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Multinomial Logistic Regression")
plt.axis("tight")

colors = "bry"
for i, color in zip(clf.classes_, colors):
        idx = np.where(y == i)
        plt.scatter(
            X[idx, 0], X[idx, 1], c=color, cmap=plt.cm.Paired, edgecolor="black", s=20
        )

plt.subplot(1,2,2)
_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("One-vs-Rest Logistic Regression")
plt.axis("tight")

colors = "bry"
for i, color in zip(clf.classes_, colors):
        idx = np.where(y == i)
        plt.scatter(
            X[idx, 0], X[idx, 1], c=color, cmap=plt.cm.Paired, edgecolor="black", s=20
        )

xmin, xmax = plt.xlim()
ymin, ymax = plt.ylim()
coef = clf.coef_
intercept = clf.intercept_

def plot_hyperplane(c, color):
        def line(x0):
            return (-(x0 * coef[c, 0]) - intercept[c]) / coef[c, 1]

        plt.plot([xmin, xmax], [line(xmin), line(xmax)], ls="--", color=color)

for i, color in zip(clf.classes_, colors):
        plot_hyperplane(i, color)

plt.subplots_adjust(wspace=0.5)
plt.show()

Resumen

En este laboratorio, aprendimos cómo trazar la superficie de decisión de dos modelos de regresión logística, a saber, la regresión logística multinomial y la regresión logística one-vs-rest. Utilizamos un conjunto de datos de 3 clases y comparamos el rendimiento de los dos modelos trazando su límite de decisión. Observamos que el modelo de regresión logística multinomial tenía un límite de decisión más suave, mientras que el modelo de regresión logística one-vs-rest tenía tres límites de decisión separados para cada clase.