Multinomiale und One-vs-Rest logistische Regression darstellen

Einführung

Die logistische Regression ist ein Klassifikationsalgorithmus, der für binäre und mehrklassige Klassifikationsprobleme verwendet werden kann. In diesem Lab verwenden wir die scikit-learn-Bibliothek, um die Entscheidungsfläche zweier logistischer Regressionsmodelle zu zeichnen, nämlich die multinomiale logistische Regression und die eine-gegen-alle logistische Regression. Wir verwenden einen 3-Klassen-Datensatz und zeichnen die Entscheidungsgrenze der beiden Modelle, um ihre Leistung zu vergleichen.

VM-Tipps

Nachdem die VM gestartet ist, klicken Sie in der linken oberen Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Bibliotheken importieren

Wir beginnen, indem wir die erforderlichen Bibliotheken für dieses Lab importieren. Wir verwenden die scikit-learn-Bibliothek, um den Datensatz zu generieren und die logistischen Regressionsmodelle zu trainieren, und die matplotlib-Bibliothek, um die Entscheidungsgrenze zu zeichnen.

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

Datensatz generieren

Wir werden einen 3-Klassen-Datensatz mit der Funktion make_blobs aus scikit-learn generieren. Wir werden 1000 Stichproben verwenden und die Mittelpunkte der Blobs auf [-5, 0], [0, 1.5], [5, -1] setzen. Anschließend werden wir den Datensatz mit einer Transformationsmatrix transformieren, um den Datensatz schwieriger zu klassifizieren.

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)

Multinomiale logistische Regressionsmodell trainieren

Wir werden nun ein multinomiales logistisches Regressionsmodell mit der Funktion LogisticRegression aus scikit-learn trainieren. Wir werden den Solver auf "sag" setzen, die maximale Anzahl an Iterationen auf 100, den Zufallszustand auf 42 und die Mehrklassenoption auf "multinomial". Anschließend werden wir die Trainingsgenauigkeit des Modells ausgeben.

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"))

Entscheidungsgrenze des multinomialen logistischen Regressionsmodells zeichnen

Wir werden nun die Entscheidungsfläche des multinomialen logistischen Regressionsmodells mit der Funktion DecisionBoundaryDisplay aus scikit-learn zeichnen. Wir werden die Antwortmethode auf "predict" setzen, die Farbpalette auf "plt.cm.Paired" und auch die Trainingspunkte zeichnen.

_, 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
        )

Ein-gegen-alle logistisches Regressionsmodell trainieren

Wir werden nun ein ein-gegen-alle logistisches Regressionsmodell mit den gleichen Parametern wie in Schritt 3 trainieren, jedoch mit der Mehrklassenoption auf "ovr" gesetzt. Anschließend werden wir die Trainingsgenauigkeit des Modells ausgeben.

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"))

Entscheidungsgrenze des ein-gegen-alle logistischen Regressionsmodells zeichnen

Wir werden nun die Entscheidungsfläche des ein-gegen-alle logistischen Regressionsmodells mit den gleichen Parametern wie in Schritt 4 zeichnen, jedoch die Hyperebenen, die den drei ein-gegen-alle Klassifizierern entsprechen, als durchgezogene Linien zeichnen.

_, 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)

Plots visualisieren

Wir werden nun beide Plots nebeneinander visualisieren, um die Entscheidungsgrenzen der beiden Modelle zu vergleichen.

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()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die Entscheidungsfläche von zwei logistischen Regressionsmodellen, nämlich das multinomiale logistische Regression und das ein-gegen-alle logistische Regression, zeichnet. Wir haben einen 3-Klassen-Datensatz verwendet und die Leistung der beiden Modelle durch das Zeichnen ihrer Entscheidungsgrenze verglichen. Wir haben festgestellt, dass das multinomiale logistische Regressionsmodell eine glattere Entscheidungsgrenze hatte, während das ein-gegen-alle logistische Regressionsmodell drei separate Entscheidungsgrenzen für jede Klasse hatte.