Plot-Entscheidungsgrenze Python

1. Installieren Sie erforderliche Bibliotheken
2. Entscheidungsgrenze
3. Verwenden Sie Matplotlibs pyplot, um eine Entscheidungsgrenze zu zeichnen, die 2 Klassen trennt
4. Entscheidungsgrenze generieren

Eine visuelle Zusammenfassung Ihrer Ergebnisse mit Bildern, Grafiken und Diagrammen gibt dem menschlichen Verstand eine gemächlichere Zeit zum Verarbeiten, Verstehen und Erkennen von Mustern in gegebenen Daten. Dieser Artikel führt Sie Schritt für Schritt durch, um eine Entscheidungsgrenze mit Matplotlibs Pyplot zu zeichnen.

Dazu verwenden wir das integrierte Datensatzpaket für vorverarbeitete Daten (ohne fehlende Daten oder Ausreißer), das von der Sklearn-Bibliothek bereitgestellt wird, um die Entscheidungsgrenze für Daten darzustellen. Dann werden wir die Bibliothek von Matplotlib verwenden, um die Entscheidungsgrenze zu zeichnen.

Installieren Sie erforderliche Bibliotheken

Um die Plotfunktion von Matplotlibs Pyplot zu verwenden, müssen wir zuerst die Bibliothek von Matplotlib installieren. Wir können dies erreichen, indem wir den folgenden Befehl ausführen:

pip install matplotlib

Es ist auch wichtig sicherzustellen, dass wir mit der richtigen Python-Version arbeiten. Für diesen Artikel verwenden wir Version 3.10.4.

Wir können die aktuell installierte Python-Version überprüfen, indem wir den folgenden Befehl ausführen:

python --version

Entscheidungsgrenze

Klassifikationsalgorithmen für maschinelles Lernen lernen, Eingabebeispielen (Beobachtungen) Labels zuzuweisen. Ziel der Klassifikation ist es, den Merkmalsraum so aufzuteilen, dass Punkte im Merkmalsraum möglichst korrekt beschriftet werden.

Diese Methode wird als Entscheidungsoberfläche oder -grenze bezeichnet und dient als anschauliches Werkzeug zur Visualisierung der Ergebnisse des Klassifikationsvorhersagemodells. Wir können eine lineare Entscheidungsgrenze für mindestens zwei Eingabemerkmale erstellen.

Wenn jedoch mehr als zwei Eingabemerkmale vorhanden sind, können wir multilineare Entscheidungsgrenzen erstellen. Dieser Artikel konzentriert sich auf das Plotten der Entscheidungsgrenze von zwei Eingabe-Features.

Verwenden Sie Matplotlibs pyplot, um eine Entscheidungsgrenze zu zeichnen, die 2 Klassen trennt

Importieren Sie die erforderlichen Bibliotheken

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

Generieren Sie den Datensatz

Wir werden ein benutzerdefiniertes Dataset mit der Sklearn-Bibliotheksfunktion make_blobs() innerhalb der Datasets-Klasse generieren. Wie oben erwähnt, handelt es sich bei dem generierten Datensatz, den wir verwenden werden, um ein integriertes Datensatzpaket für vorverarbeitete Daten (ohne fehlende Daten oder Ausreißer), das von der Sklearn-Bibliothek bereitgestellt wird.

Unsere benutzerdefinierten Datensatzvariablen lauten wie folgt.

    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
)

Sobald die Datengenerierung abgeschlossen ist, können wir ein Streudiagramm der Daten erstellen, um die Datenvariabilität in einem stark verbesserten Licht zu sehen.

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

Im nächsten Schritt erstellen wir das Klassifizierungsmodell, um unsichtbare Daten vorherzusagen. Wir können die logistische Regression für unseren benutzerdefinierten Datensatz verwenden, da er nur zwei Funktionen hat.

Logistisches Regressionsmodell

Wir werden eine logistische Regressionsmodellfunktion verwenden, die von der Logistic Regression-Klasse in der sklearn-Bibliothek bereitgestellt wird, und sie mit unseren Beispieldaten trainieren.

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

Jetzt werden wir die Genauigkeit durch die Klasse precision_score aus der sklearn-Bibliothek auswerten.

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

Entscheidungsgrenze generieren

Matplotlib bietet eine wertvolle Funktion namens contour(), die helfen kann, beim Plotten zwischen verschiedenen Punkten Farben hinzuzufügen. Um dies zu erreichen, müssen wir zuerst das Punkteraster Xfeature oder YFeature im Merkmalsraum initialisieren.

Danach müssen wir den Maximal- und Minimalwert jedes Merkmals finden und diesen dann um eins erhöhen, um sicherzustellen, dass der gesamte Bereich abgedeckt ist.

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

Die numpy-Bibliothek bietet eine arrange()-Funktion, um die Koordinaten mit einer Auflösung von 0,1 zu skalieren.

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

Im nächsten Schritt stellt die numpy-Bibliothek eine meshgrid()-Funktion bereit, um skalierte Koordinaten in ein Gitter umzuwandeln.

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

Anschließend reduzieren wir das 2-D-Array-Raster mithilfe der Funktion flatten() der numpy-Bibliothek auf ein 1-D-Array.

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

Schließlich stapeln wir das 1-D-Array nebeneinander als Spalten in einem Eingabedatensatz, jedoch mit einer viel höheren Auflösung.

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

Danach können wir dies in das Regressionsmodell einpassen, das wir oben erstellt haben, um Werte vorherzusagen.

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)

Jetzt werden wir diese vorhergesagten Gitter als Konturdiagramm mit contourf() mit verschiedenen Farben darstellen.

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

Und so landen wir mit dem folgenden Skript, um eine Entscheidungsgrenze zu zeichnen, die zwei Klassen trennt.

Vollständiger Code:

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

Ausgang:

So können wir mithilfe von Matplotlibs Pyplot eine Entscheidungsgrenze anwenden, die zwei Klassen trennt.