Scikit-Learn MLPClassifier: Stochastische Lernstrategien

Einführung

In diesem Lab werden Sie durch den Prozess der Verwendung des Scikit-learn MLPClassifier geführt, um die Leistung verschiedener stochastischer Lernstrategien zu vergleichen, einschließlich SGD und Adam. Der MLPClassifier ist ein neuronales Netzwerk-Klassifikator, der Backpropagation verwendet, um die Gewichte des Netzwerks zu optimieren. Das Ziel dieses Labs besteht darin, zu zeigen, wie verschiedene stochastische Lernstrategien die Trainingsverlustkurven des MLPClassifier beeinflussen können. Wir werden für dieses Beispiel mehrere kleine Datensätze verwenden, obwohl der in diesen Beispielen gezeigte allgemeine Trend auch auf größere Datensätze zu übertragen scheint.

Tipps für die virtuelle Maschine (VM)

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

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

Wenn Sie während des Lernens Probleme haben, können Sie sich gerne an Labby wenden. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem umgehend für Sie lösen.

Importieren der erforderlichen Bibliotheken

Zunächst müssen wir die erforderlichen Bibliotheken importieren, darunter MLPClassifier, MinMaxScaler, datasets und matplotlib.pyplot. Wir werden auch ConvergenceWarning importieren, um Konvergenzwarnungen während des Trainings zu ignorieren.

import warnings

import matplotlib.pyplot as plt

from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import MinMaxScaler
from sklearn import datasets
from sklearn.exceptions import ConvergenceWarning

Definieren verschiedener Lernstrategien

Als nächstes müssen wir die verschiedenen Lernstrategien definieren, die wir vergleichen möchten. Wir werden mehrere verschiedene Lernraten-Schedules und Impulsparameter (Momentum-Parameter) definieren, darunter konstante Lernrate, konstante Lernrate mit Impuls, konstante Lernrate mit Nesterov-Impuls, inverse Skalierung der Lernrate, inverse Skalierung der Lernrate mit Impuls, inverse Skalierung der Lernrate mit Nesterov-Impuls und Adam. Wir werden auch Labels und plot_args definieren, die wir später in unserem Diagramm verwenden werden.

## different learning rate schedules and momentum parameters
params = [
    {
        "solver": "sgd",
        "learning_rate": "constant",
        "momentum": 0,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "constant",
        "momentum": 0.9,
        "nesterovs_momentum": False,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "constant",
        "momentum": 0.9,
        "nesterovs_momentum": True,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "invscaling",
        "momentum": 0,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "invscaling",
        "momentum": 0.9,
        "nesterovs_momentum": True,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "invscaling",
        "momentum": 0.9,
        "nesterovs_momentum": False,
        "learning_rate_init": 0.2,
    },
    {"solver": "adam", "learning_rate_init": 0.01},
]

labels = [
    "constant learning-rate",
    "constant with momentum",
    "constant with Nesterov's momentum",
    "inv-scaling learning-rate",
    "inv-scaling with momentum",
    "inv-scaling with Nesterov's momentum",
    "adam",
]

plot_args = [
    {"c": "red", "linestyle": "-"},
    {"c": "green", "linestyle": "-"},
    {"c": "blue", "linestyle": "-"},
    {"c": "red", "linestyle": "--"},
    {"c": "green", "linestyle": "--"},
    {"c": "blue", "linestyle": "--"},
    {"c": "black", "linestyle": "-"},
]

Definieren einer Funktion zum Plotten der Lernkurven

Als nächstes müssen wir eine Funktion definieren, die die Lernkurven für jede Lernstrategie auf jedem Datensatz plottet. Die Funktion nimmt den Datensatz (X, y), eine Achse zum Plotten und einen Namen für den Datensatz entgegen. Wir werden MinMaxScaler verwenden, um die Daten zu skalieren, und MLPClassifier, um das neuronale Netzwerk zu trainieren. Wir werden das Netzwerk mit jeder Lernstrategie trainieren, Konvergenzwarnungen ignorieren und die Lernkurven für jede Strategie in demselben Diagramm plotten.

def plot_on_dataset(X, y, ax, name):
    ## for each dataset, plot learning for each learning strategy
    print("\nlearning on dataset %s" % name)
    ax.set_title(name)

    X = MinMaxScaler().fit_transform(X)
    mlps = []
    if name == "digits":
        ## digits is larger but converges fairly quickly
        max_iter = 15
    else:
        max_iter = 400

    for label, param in zip(labels, params):
        print("training: %s" % label)
        mlp = MLPClassifier(random_state=0, max_iter=max_iter, **param)

        ## some parameter combinations will not converge as can be seen on the
        ## plots so they are ignored here
        with warnings.catch_warnings():
            warnings.filterwarnings(
                "ignore", category=ConvergenceWarning, module="sklearn"
            )
            mlp.fit(X, y)

        mlps.append(mlp)
        print("Training set score: %f" % mlp.score(X, y))
        print("Training set loss: %f" % mlp.loss_)
    for mlp, label, args in zip(mlps, labels, plot_args):
        ax.plot(mlp.loss_curve_, label=label, **args)

Laden oder Generieren kleiner Datensätze

Jetzt müssen wir die kleinen Datensätze laden oder generieren, die wir für dieses Beispiel verwenden werden. Wir werden den Iris-Datensatz, den Digits-Datensatz und zwei Datensätze verwenden, die mit den Funktionen make_circles und make_moons generiert werden.

iris = datasets.load_iris()
X_digits, y_digits = datasets.load_digits(return_X_y=True)
data_sets = [
    (iris.data, iris.target),
    (X_digits, y_digits),
    datasets.make_circles(noise=0.2, factor=0.5, random_state=1),
    datasets.make_moons(noise=0.3, random_state=0),
]

Plotten der Lernkurven für jeden Datensatz

Schließlich können wir die Lernkurven für jeden Datensatz mit der Funktion plot_on_dataset plotten. Wir werden ein 2x2-Diagramm erstellen und jeden Datensatz auf einer separaten Achse plotten.

fig, axes = plt.subplots(2, 2, figsize=(15, 10))

for ax, data, name in zip(
    axes.ravel(), data_sets, ["iris", "digits", "circles", "moons"]
):
    plot_on_dataset(*data, ax=ax, name=name)

fig.legend(ax.get_lines(), labels, ncol=3, loc="upper center")
plt.show()

Zusammenfassung

In diesem Lab haben wir den Scikit-learn MLPClassifier verwendet, um die Leistung verschiedener stochastischer Lernstrategien, einschließlich SGD und Adam, auf mehreren kleinen Datensätzen zu vergleichen. Wir haben verschiedene Lernraten-Schedules und Impulsparameter (Momentum-Parameter) definiert und dann den MLPClassifier mit jeder Strategie trainiert. Wir haben die Lernkurven für jede Strategie auf jedem Datensatz geplottet und beobachtet, wie verschiedene Strategien die Trainingsverlustkurven beeinflussen können. Wir haben die Wichtigkeit der Wahl der richtigen Lernstrategie für den Datensatz und die vorliegende Aufgabe gezeigt.