Gewichteter Datensatz - Darstellung der Entscheidungsfunktion

Einführung

In diesem Tutorial lernen wir, wie wir eine Entscheidungsfunktion eines gewichteten Datensatzes mit scikit-learn darstellen. Wir lernen auch, wie wir unterschiedlichen Gewichten den Proben im Datensatz zuweisen, um zu zeigen, wie die Gewichte die Entscheidungsfunktion beeinflussen.

VM-Tipps

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

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, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Importieren der erforderlichen Bibliotheken

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken für unser Projekt.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model

Erstellen eines gewichteten Datensatzes

Wir erstellen einen gewichteten Datensatz mit der numpy-Bibliothek. Wir generieren 20 Punkte mit zufälligen Werten und weisen den letzten 10 Proben einen größeren Gewicht zu.

np.random.seed(0)
X = np.r_[np.random.randn(10, 2) + [1, 1], np.random.randn(10, 2)]
y = [1] * 10 + [-1] * 10
sample_weight = 100 * np.abs(np.random.randn(20))
sample_weight[:10] *= 10

Zeichnen des gewichteten Datensatzes

Wir zeichnen den gewichteten Datensatz mit der matplotlib-Bibliothek. Die Größe der Punkte ist proportional zu ihrem Gewicht.

xx, yy = np.meshgrid(np.linspace(-4, 5, 500), np.linspace(-4, 5, 500))
fig, ax = plt.subplots()
ax.scatter(
    X[:, 0],
    X[:, 1],
    c=y,
    s=sample_weight,
    alpha=0.9,
    cmap=plt.cm.bone,
    edgecolor="black",
)

Anpassen des ungewichteten Modells

Wir trainieren ein ungewichtetes Modell mit dem SGDClassifier-Algorithmus aus der scikit-learn-Bibliothek. Anschließend zeichnen wir die Entscheidungsfunktion des ungewichteten Modells.

clf = linear_model.SGDClassifier(alpha=0.01, max_iter=100)
clf.fit(X, y)
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
no_weights = ax.contour(xx, yy, Z, levels=[0], linestyles=["solid"])

Anpassen des gewichteten Modells

Wir trainieren ein gewichtetes Modell mit dem gleichen Algorithmus wie in Schritt 4, aber diesmal übergeben wir das sample_weight-Argument an die fit-Methode. Anschließend zeichnen wir die Entscheidungsfunktion des gewichteten Modells.

clf = linear_model.SGDClassifier(alpha=0.01, max_iter=100)
clf.fit(X, y, sample_weight=sample_weight)
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
samples_weights = ax.contour(xx, yy, Z, levels=[0], linestyles=["dashed"])

Hinzufügen einer Legende und Anzeigen des Graphen

Wir fügen einer Legende zum Graphen hinzu, um zwischen dem ungewichteten und dem gewichteten Modell zu unterscheiden. Anschließend zeigen wir den Graphen an.

no_weights_handles, _ = no_weights.legend_elements()
weights_handles, _ = samples_weights.legend_elements()
ax.legend(
    [no_weights_handles[0], weights_handles[0]],
    ["ohne Gewichte", "mit Gewichten"],
    loc="untere linke Ecke",
)

ax.set(xticks=(), yticks=())
plt.show()

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie man mit scikit-learn die Entscheidungsfunktion eines gewichteten Datensatzes zeichnet. Wir haben auch gelernt, wie man den Proben im Datensatz unterschiedliche Gewichte zuweist, um zu zeigen, wie die Gewichte die Entscheidungsfunktion beeinflussen.