Plotar Regressão Logística Multinomial e um-contra-todos

Introdução

A regressão logística é um algoritmo de classificação que pode ser usado para problemas de classificação binária e multiclasse. Neste laboratório, utilizaremos a biblioteca scikit-learn para plotar a superfície de decisão de dois modelos de regressão logística, nomeadamente a regressão logística multinomial e a regressão logística um-contra-todos. Usaremos um conjunto de dados de 3 classes e plotaremos a fronteira de decisão dos dois modelos para comparar o seu desempenho.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.

Importar Bibliotecas

Começaremos importando as bibliotecas necessárias para este laboratório. Usaremos a biblioteca scikit-learn para gerar o conjunto de dados e treinar os modelos de regressão logística, e a biblioteca matplotlib para plotar a fronteira de decisão.

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

Gerar Conjunto de Dados

Vamos gerar um conjunto de dados de 3 classes usando a função make_blobs do scikit-learn. Usaremos 1000 amostras e definiremos os centros dos blobs em [-5, 0], [0, 1.5], [5, -1]. Em seguida, transformaremos o conjunto de dados usando uma matriz de transformação para tornar o conjunto de dados mais difícil de classificar.

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)

Treinar o Modelo de Regressão Logística Multinomial

Agora, treinaremos um modelo de regressão logística multinomial usando a função LogisticRegression do scikit-learn. Definiremos o solucionador para "sag", o número máximo de iterações para 100, o estado aleatório para 42 e a opção multi-classe para "multinomial". Em seguida, imprimiremos a pontuação de treinamento do 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"))

Plotar a Fronteira de Decisão do Modelo de Regressão Logística Multinomial

Agora, plotaremos a superfície de decisão do modelo de regressão logística multinomial usando a função DecisionBoundaryDisplay do scikit-learn. Definiremos o método de resposta para "predict", o mapa de cores para "plt.cm.Paired" e plotaremos também os pontos de treinamento.

_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Superfície de decisão de 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
        )

Treinar o Modelo de Regressão Logística um-contra-todos

Agora, treinaremos um modelo de regressão logística um-contra-todos usando os mesmos parâmetros do Passo 3, mas com a opção multi-classe definida como "ovr". Em seguida, imprimiremos a pontuação de treinamento do 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"))

Plotar a Fronteira de Decisão do Modelo de Regressão Logística um-contra-todos

Agora, plotaremos a superfície de decisão do modelo de regressão logística um-contra-todos usando os mesmos parâmetros do Passo 4, mas plotaremos os hiperplanos correspondentes aos três classificadores um-contra-todos como linhas tracejadas.

_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Superfície de decisão de 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 Gráficos

Agora, visualizaremos os dois gráficos lado a lado para comparar as fronteiras de decisão dos dois 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("Regressão Logística 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
        )

plt.subplot(1,2,2)
_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Regressão Logística um-contra-todos")
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()

Resumo

Neste laboratório, aprendemos a plotar a superfície de decisão de dois modelos de regressão logística: a regressão logística multinomial e a regressão logística um-contra-todos. Usamos um conjunto de dados de 3 classes e comparamos o desempenho dos dois modelos plotando suas fronteiras de decisão. Observamos que o modelo de regressão logística multinomial apresentou uma fronteira de decisão mais suave, enquanto o modelo de regressão logística um-contra-todos apresentou três fronteiras de decisão separadas para cada classe.