Tracer la régression logistique multinomiale et One-vs-Rest

Introduction

La régression logistique est un algorithme de classification qui peut être utilisé pour les problèmes de classification binaire et multi-classe. Dans ce laboratoire, nous utiliserons la bibliothèque scikit-learn pour tracer la surface de décision de deux modèles de régression logistique, à savoir la régression logistique multinomiale et la régression logistique one-vs-rest. Nous utiliserons un ensemble de données à 3 classes et tracerons la frontière de décision des deux modèles pour comparer leurs performances.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous réglerons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

Nous commencerons par importer les bibliothèques nécessaires pour ce laboratoire. Nous utiliserons la bibliothèque scikit-learn pour générer l'ensemble de données et entraîner les modèles de régression logistique, et la bibliothèque matplotlib pour tracer la frontière de décision.

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

Générer un ensemble de données

Nous allons générer un ensemble de données à 3 classes en utilisant la fonction make_blobs de scikit-learn. Nous utiliserons 1000 échantillons et définirons les centres des grappes à [-5, 0], [0, 1.5], [5, -1]. Nous transformerons ensuite l'ensemble de données en utilisant une matrice de transformation pour rendre l'ensemble de données plus difficile à classifier.

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)

Entraîner le modèle de régression logistique multinomiale

Nous allons maintenant entraîner un modèle de régression logistique multinomiale en utilisant la fonction LogisticRegression de scikit-learn. Nous définirons le solveur sur "sag", le nombre maximum d'itérations sur 100, l'état aléatoire sur 42 et l'option multi-classe sur "multinomial". Nous afficherons ensuite le score d'entraînement du modèle.

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

print("score d'entraînement : %.3f (%s)" % (clf.score(X, y), "multinomial"))

Tracer la frontière de décision du modèle de régression logistique multinomiale

Nous allons maintenant tracer la surface de décision du modèle de régression logistique multinomiale en utilisant la fonction DecisionBoundaryDisplay de scikit-learn. Nous définirons la méthode de réponse sur "predict", la carte de couleurs sur "plt.cm.Paired" et tracerons également les points d'entraînement.

_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Surface de décision de LogisticRegression (multinomiale)")
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
        )

Entraîner le modèle de régression logistique One-vs-Rest

Nous allons maintenant entraîner un modèle de régression logistique One-vs-Rest en utilisant les mêmes paramètres que dans l'Étape 3, mais avec l'option multi-classe définie sur "ovr". Nous afficherons ensuite le score d'entraînement du modèle.

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

print("score d'entraînement : %.3f (%s)" % (clf.score(X, y), "ovr"))

Tracer la frontière de décision du modèle de régression logistique One-vs-Rest

Nous allons maintenant tracer la surface de décision du modèle de régression logistique One-vs-Rest en utilisant les mêmes paramètres que dans l'Étape 4, mais tracer les hyperplans correspondant aux trois classifieurs One-vs-Rest comme des lignes pointillées.

_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Surface de décision 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)

Visualiser les graphiques

Nous allons maintenant visualiser les deux graphiques côte à côte pour comparer les frontières de décision des deux modèles.

plt.subplot(1,2,1)
_, ax = plt.subplots()
DecisionBoundaryDisplay.from_estimator(
        clf, X, response_method="predict", cmap=plt.cm.Paired, ax=ax
    )
plt.title("Régression logistique multinomiale")
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("Régression logistique One-vs-Rest")
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()

Sommaire

Dans ce laboratoire, nous avons appris à tracer la surface de décision de deux modèles de régression logistique, à savoir la régression logistique multinomiale et la régression logistique One-vs-Rest. Nous avons utilisé un ensemble de données à 3 classes et comparé les performances des deux modèles en traçant leur frontière de décision. Nous avons observé que le modèle de régression logistique multinomiale avait une frontière de décision plus lisse, tandis que le modèle de régression logistique One-vs-Rest avait trois frontières de décision distinctes pour chaque classe.