Einführung
In diesem Lab wird gezeigt, wie die Regularisierung in einem Multi-Layer Perceptron (MLP) eingesetzt werden kann, um das Overfitting zu bekämpfen. Wir werden verschiedene Werte für den Regularisierungsparameter alpha vergleichen und beobachten, wie sich die Entscheidungsfunktionen ändern.
Tipps für die VM
Nachdem der VM-Start 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 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 lösen.
Bibliotheken importieren
Wir beginnen mit dem Import der erforderlichen Bibliotheken für dieses Lab. Wir werden scikit-learn verwenden, um synthetische Datensätze zu erstellen, MLPClassifier, um das MLP-Modell zu erstellen, StandardScaler, um die Daten zu standardisieren, und make_pipeline, um eine Pipeline von Transformationen und Klassifizierern zu erstellen.
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
Definiere Alphas
Wir werden verschiedene Werte für den Regularisierungsparameter alpha definieren. Wir werden np.logspace verwenden, um 5 logarithmisch gleichmäßig verteilte Werte zwischen 0,1 und 10 zu generieren.
alphas = np.logspace(-1, 1, 5)
Erstelle Klassifizierer
Wir werden für jeden Wert von alpha MLP-Klassifizierer erstellen. Wir werden eine Pipeline erstellen, die StandardScaler enthält, um die Daten zu standardisieren, und MLPClassifier mit unterschiedlichen Werten von alpha. Wir werden den Solver auf 'lbfgs' setzen, was ein Optimierer in der Familie der quasi-Newton-Methoden ist. Wir werden max_iter auf 2000 und early_stopping auf True setzen, um das Overfitting zu vermeiden. Wir werden zwei versteckte Schichten mit jeweils 10 Neuronen verwenden.
classifiers = []
names = []
for alpha in alphas:
classifiers.append(
make_pipeline(
StandardScaler(),
MLPClassifier(
solver="lbfgs",
alpha=alpha,
random_state=1,
max_iter=2000,
early_stopping=True,
hidden_layer_sizes=[10, 10],
),
)
)
names.append(f"alpha {alpha:.2f}")
Erstelle Datensätze
Wir werden drei synthetische Datensätze mit den Funktionen make_classification, make_moons und make_circles aus scikit-learn erstellen. Wir werden jeden Datensatz in Trainings- und Testsets unter Verwendung von train_test_split unterteilen.
X, y = make_classification(
n_features=2, n_redundant=0, n_informative=2, random_state=0, n_clusters_per_class=1
)
rng = np.random.RandomState(2)
X += 2 * rng.uniform(size=X.shape)
linearly_separable = (X, y)
datasets = [
make_moons(noise=0.3, random_state=0),
make_circles(noise=0.2, factor=0.5, random_state=1),
linearly_separable,
]
figure = plt.figure(figsize=(17, 9))
i = 1
## iterate over datasets
for X, y in datasets:
## split into training and test part
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.4, random_state=42
)
Zeichne Datensätze
Wir werden jeden Datensatz zeichnen und die Trainings- und Testpunkte unterschiedlich färben.
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
## just plot the dataset first
cm = plt.cm.RdBu
cm_bright = ListedColormap(["#FF0000", "#0000FF"])
ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
## Plot the training points
ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
## and testing points
ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
i += 1
Trainiere Klassifizierer und zeichne Entscheidungsgrenzen
Wir werden jeden Klassifizierer auf jedem Datensatz trainieren und die Entscheidungsgrenzen zeichnen. Wir werden contourf verwenden, um die Entscheidungsgrenze zu zeichnen und scatter, um die Trainings- und Testpunkte zu zeichnen. Wir werden auch die Genauigkeit auf jedem Plot anzeigen.
## iterate over classifiers
for name, clf in zip(names, classifiers):
ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)
## Plot the decision boundary. For that, we will assign a color to each
## point in the mesh [x_min, x_max] x [y_min, y_max].
if hasattr(clf, "decision_function"):
Z = clf.decision_function(np.column_stack([xx.ravel(), yy.ravel()]))
else:
Z = clf.predict_proba(np.column_stack([xx.ravel(), yy.ravel()]))[:, 1]
## Put the result into a color plot
Z = Z.reshape(xx.shape)
ax.contourf(xx, yy, Z, cmap=cm, alpha=0.8)
## Plot also the training points
ax.scatter(
X_train[:, 0],
X_train[:, 1],
c=y_train,
cmap=cm_bright,
edgecolors="black",
s=25,
)
## and testing points
ax.scatter(
X_test[:, 0],
X_test[:, 1],
c=y_test,
cmap=cm_bright,
alpha=0.6,
edgecolors="black",
s=25,
)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
ax.set_title(name)
ax.text(
xx.max() - 0.3,
yy.min() + 0.3,
f"{score:.3f}".lstrip("0"),
size=15,
horizontalalignment="right",
)
i += 1
Zeige Plots
Schließlich werden wir das Layout der Teilplots anpassen und die Plots anzeigen.
figure.subplots_adjust(left=0.02, right=0.98)
plt.show()
Zusammenfassung
In diesem Lab haben wir gelernt, wie Regularisierung in einem Multilayer-Perzeptron eingesetzt werden kann, um Overfitting zu bekämpfen. Wir haben verschiedene Werte des Regularisierungsparameters alpha verglichen und beobachtet, wie sich die Entscheidungsfunktionen geändert haben. Wir haben auch gelernt, wie synthetische Datensätze erstellt, die Daten standardisiert, MLP-Klassifizierer erstellt und Entscheidungsgrenzen gezeichnet werden.