Bias-Varianz-Zerlegung mit Bagging

Einführung

In diesem Lab werden wir das Konzept der Bias-Varianz-Zerlegung untersuchen und wie es sich auf einzelne Schätzer im Vergleich zu Bagging-Ensembles bezieht. Wir werden scikit-learn verwenden, um toy-Regressionsprobleme zu generieren und zu visualisieren und den erwarteten mittleren quadratischen Fehler eines einzelnen Schätzers im Vergleich zu einem Bagging-Ensemble von Entscheidungsbäumen zu vergleichen.

VM-Tipps

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 beheben.

Skills Graph

Importieren der erforderlichen Bibliotheken

Zunächst müssen wir die erforderlichen Bibliotheken importieren, um Daten zu generieren, Modelle zu trainieren und die Ergebnisse zu visualisieren.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor

Parameter festlegen

Wir müssen die Parameter festlegen, die die Größe der Datensätze, die Anzahl der Iterationen und die Standardabweichung des Rauschens steuern.

n_repeat = 50  ## Anzahl der Iterationen zur Berechnung von Erwartungswerten
n_train = 50  ## Größe des Trainingssatzes
n_test = 1000  ## Größe des Testsatzes
noise = 0.1  ## Standardabweichung des Rauschens
np.random.seed(0)

Daten generieren

Wir werden ein einfaches eindimensionales Regressionsproblem mit einer bekannten Funktion generieren und zufälliges Rauschen zu den Trainings- und Testsets hinzufügen. Wir werden mehrere Trainingssets generieren, um den erwarteten mittleren quadratischen Fehler zu berechnen.

def f(x):
    x = x.ravel()
    return np.exp(-(x**2)) + 1.5 * np.exp(-((x - 2) ** 2))

def generate(n_samples, noise, n_repeat=1):
    X = np.random.rand(n_samples) * 10 - 5
    X = np.sort(X)

    if n_repeat == 1:
        y = f(X) + np.random.normal(0.0, noise, n_samples)
    else:
        y = np.zeros((n_samples, n_repeat))

        for i in range(n_repeat):
            y[:, i] = f(X) + np.random.normal(0.0, noise, n_samples)

    X = X.reshape((n_samples, 1))

    return X, y

X_train = []
y_train = []

for i in range(n_repeat):
    X, y = generate(n_samples=n_train, noise=noise)
    X_train.append(X)
    y_train.append(y)

X_test, y_test = generate(n_samples=n_test, noise=noise, n_repeat=n_repeat)

Die Modelle definieren, die verglichen werden sollen

Wir werden zwei Modelle definieren, um sie zu vergleichen: einen einzelnen Entscheidungsbaum und ein Bagging-Ensemble von Entscheidungsbäumen.

estimators = [
    ("Tree", DecisionTreeRegressor()),
    ("Bagging(Tree)", BaggingRegressor(DecisionTreeRegressor())),
]
n_estimators = len(estimators)

Trainieren der Modelle und Berechnung des erwarteten mittleren quadratischen Fehlers

Wir werden über die Schätzer iterieren, sie auf den mehreren Trainingssets trainieren und den erwarteten mittleren quadratischen Fehler berechnen, indem wir ihn in Bias, Varianz und Rauschterme zerlegen. Wir werden auch die Vorhersagen der Modelle und die Bias-Varianz-Zerlegung plotten.

plt.figure(figsize=(10, 8))

## Schleife über die Schätzer zum Vergleichen
for n, (name, estimator) in enumerate(estimators):
    ## Berechnung der Vorhersagen
    y_predict = np.zeros((n_test, n_repeat))

    for i in range(n_repeat):
        estimator.fit(X_train[i], y_train[i])
        y_predict[:, i] = estimator.predict(X_test)

    ## Bias^2 + Varianz + Rausch-Zerlegung des mittleren quadratischen Fehlers
    y_error = np.zeros(n_test)

    for i in range(n_repeat):
        for j in range(n_repeat):
            y_error += (y_test[:, j] - y_predict[:, i]) ** 2

    y_error /= n_repeat * n_repeat

    y_noise = np.var(y_test, axis=1)
    y_bias = (f(X_test) - np.mean(y_predict, axis=1)) ** 2
    y_var = np.var(y_predict, axis=1)

    print(
        "{0}: {1:.4f} (error) = {2:.4f} (bias^2) "
        " + {3:.4f} (var) + {4:.4f} (noise)".format(
            name, np.mean(y_error), np.mean(y_bias), np.mean(y_var), np.mean(y_noise)
        )
    )

    ## Plot der Grafiken
    plt.subplot(2, n_estimators, n + 1)
    plt.plot(X_test, f(X_test), "b", label="$f(x)$")
    plt.plot(X_train[0], y_train[0], ".b", label="LS ~ $y = f(x)+noise$")

    for i in range(n_repeat):
        if i == 0:
            plt.plot(X_test, y_predict[:, i], "r", label=r"$\^y(x)$")
        else:
            plt.plot(X_test, y_predict[:, i], "r", alpha=0.05)

    plt.plot(X_test, np.mean(y_predict, axis=1), "c", label=r"$\mathbb{E}_{LS} \^y(x)$")

    plt.xlim([-5, 5])
    plt.title(name)

    if n == n_estimators - 1:
        plt.legend(loc=(1.1, 0.5))

    plt.subplot(2, n_estimators, n_estimators + n + 1)
    plt.plot(X_test, y_error, "r", label="$error(x)$")
    plt.plot(X_test, y_bias, "b", label="$bias^2(x)$"),
    plt.plot(X_test, y_var, "g", label="$variance(x)$"),
    plt.plot(X_test, y_noise, "c", label="$noise(x)$")

    plt.xlim([-5, 5])
    plt.ylim([0, 0.1])

    if n == n_estimators - 1:
        plt.legend(loc=(1.1, 0.5))

plt.subplots_adjust(right=0.75)
plt.show()

Die Ergebnisse interpretieren

Wir können die Bias-Varianz-Zerlegung des erwarteten mittleren quadratischen Fehlers für jedes Modell sowie die Vorhersagen der Modelle beobachten. Wir können auch die Gesamtfehler der beiden Modelle vergleichen und ihren Kompromiss zwischen Bias und Varianz betrachten.

Zusammenfassung

In diesem Lab haben wir das Konzept der Bias-Varianz-Zerlegung untersucht und wie es sich auf einzelne Schätzer im Vergleich zu Bagging-Ensembles bezieht. Wir haben mit scikit-learn einfache Regressionsprobleme generiert und visualisiert und den erwarteten mittleren quadratischen Fehler eines einzelnen Entscheidungsbaums im Vergleich zu einem Bagging-Ensemble von Entscheidungsbäumen verglichen. Wir haben festgestellt, dass der Kompromiss zwischen Bias und Varianz für Bagging besser ist, da es den Bias-Term leicht erhöht, aber eine größere Reduzierung der Varianz ermöglicht, was zu einem niedrigeren Gesamtmittelquadratfehler führt.