Einführung
In diesem Lab wird gezeigt, wie man kontinuierliche Merkmale mit der Klasse KBinsDiscretizer in Scikit-learn diskretisiert. Die Diskretisierung ist der Prozess, bei dem kontinuierliche Merkmale in diskrete Merkmale umgewandelt werden, indem die Merkmalswerte in eine Reihe von Bins unterteilt werden. Dies kann nützlich sein, wenn man mit linearen Modellen arbeitet, die nur lineare Beziehungen modellieren können, oder um die Komplexität von Entscheidungsbäumen zu reduzieren.
Tipps für die VM
Nachdem der Start der VM abgeschlossen 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 von Jupyter Notebook nicht automatisiert werden.
Wenn Sie während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.
Laden der erforderlichen Bibliotheken
In diesem Schritt importieren wir die erforderlichen Bibliotheken.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import KBinsDiscretizer
from sklearn.tree import DecisionTreeRegressor
Erstellen des Datensatzes
In diesem Schritt erstellen wir einen Datensatz mit einem kontinuierlichen Eingangsmerkmal und einem kontinuierlichen Ausgangsmerkmal. Wir werden die numpy.random.RandomState()-Methode verwenden, um Zufallszahlen für das Eingangsmerkmal zu generieren, und die numpy.sin()-Methode, um das Ausgangsmerkmal zu generieren.
rnd = np.random.RandomState(42)
X = rnd.uniform(-3, 3, size=100)
y = np.sin(X) + rnd.normal(size=len(X)) / 3
X = X.reshape(-1, 1)
Visualisierung des Datensatzes
In diesem Schritt visualisieren wir den Datensatz mit einem Punkt-Diagramm (Scatter Plot).
plt.scatter(X, y, color='black')
plt.show()
Diskretisierung des Eingangsmerkmals
In diesem Schritt verwenden wir die Klasse KBinsDiscretizer, um das Eingangsmerkmal zu diskretisieren. Wir werden 10 Bins erstellen und die One-Hot-Codierung verwenden, um die Daten zu transformieren.
enc = KBinsDiscretizer(n_bins=10, encode="onehot")
X_binned = enc.fit_transform(X)
Visualisierung des diskretisierten Datensatzes
In diesem Schritt visualisieren wir den diskretisierten Datensatz mit einem Punkt-Diagramm (Scatter Plot).
plt.scatter(X_binned, y, color='black')
plt.show()
Trainieren eines linearen Regressionsmodells
In diesem Schritt trainieren wir ein lineares Regressionsmodell auf dem ursprünglichen Datensatz.
reg = LinearRegression().fit(X, y)
Trainieren eines Entscheidungsbaum-Modells
In diesem Schritt trainieren wir ein Entscheidungsbaum-Modell auf dem ursprünglichen Datensatz.
reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X, y)
Trainieren eines linearen Regressionsmodells auf dem diskretisierten Datensatz
In diesem Schritt trainieren wir ein lineares Regressionsmodell auf dem diskretisierten Datensatz.
reg = LinearRegression().fit(X_binned, y)
Trainieren eines Entscheidungsbaum-Modells auf dem diskretisierten Datensatz
In diesem Schritt trainieren wir ein Entscheidungsbaum-Modell auf dem diskretisierten Datensatz.
reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X_binned, y)
Visualisiere die Ergebnisse
In diesem Schritt visualisieren wir die Ergebnisse des linearen Regressions- und Entscheidungsbaum-Modells vor und nach der Diskretisierung.
## predict with original dataset
fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True, figsize=(10, 4))
line = np.linspace(-3, 3, 1000, endpoint=False).reshape(-1, 1)
reg = LinearRegression().fit(X, y)
ax1.plot(line, reg.predict(line), linewidth=2, color="green", label="linear regression")
reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X, y)
ax1.plot(line, reg.predict(line), linewidth=2, color="red", label="decision tree")
ax1.plot(X[:, 0], y, "o", c="k")
ax1.legend(loc="best")
ax1.set_ylabel("Regression output")
ax1.set_xlabel("Input feature")
ax1.set_title("Result before discretization")
## predict with transformed dataset
line_binned = enc.transform(line)
reg = LinearRegression().fit(X_binned, y)
ax2.plot(
line,
reg.predict(line_binned),
linewidth=2,
color="green",
linestyle="-",
label="linear regression",
)
reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X_binned, y)
ax2.plot(
line,
reg.predict(line_binned),
linewidth=2,
color="red",
linestyle=":",
label="decision tree",
)
ax2.plot(X[:, 0], y, "o", c="k")
ax2.vlines(enc.bin_edges_[0], *plt.gca().get_ylim(), linewidth=1, alpha=0.2)
ax2.legend(loc="best")
ax2.set_xlabel("Input feature")
ax2.set_title("Result after discretization")
plt.tight_layout()
plt.show()
Zusammenfassung
In diesem Lab haben wir gelernt, wie man kontinuierliche Merkmale mit der KBinsDiscretizer-Klasse in Scikit-learn diskretisiert. Die Diskretisierung kann nützlich sein, wenn man mit linearen Modellen arbeitet oder um die Komplexität von Entscheidungsbäumen zu reduzieren. Wir haben auch gelernt, wie man lineare Regressions- und Entscheidungsbaum-Modelle auf sowohl dem ursprünglichen als auch dem diskretisierten Datensatz trainiert und wie man die Ergebnisse visualisiert.