Wahrscheinlichkeitsprognosen mit Gaussian Process Classification

Einführung

In diesem Lab werden wir die Gaussian Process Classification (GPC) mit einem RBF-Kern und verschiedenen Hyperparameterauswahlmöglichkeiten untersuchen. Wir werden Daten generieren, das GPC-Modell mit sowohl festen als auch optimierten Hyperparametern trainieren und die Posterioren und die Landschaft der logarithmischen marginalen Wahrscheinlichkeit darstellen. Wir werden auch die Genauigkeit und die Log-Loss des Modells auswerten.

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 öffnen.

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

Bibliotheken importieren

Wir werden die erforderlichen Bibliotheken für dieses Lab importieren.

import numpy as np
from matplotlib import pyplot as plt
from sklearn.metrics import accuracy_score, log_loss
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF

Daten generieren

Wir werden Daten mit NumPy generieren. Wir werden 100 Datenpunkte mit einer gleichmäßigen Verteilung zwischen 0 und 5 generieren. Wir werden den Schwellenwert auf 2,5 setzen und die Labels mit einem booleschen Ausdruck generieren. Wir werden die ersten 50 Datenpunkte als Trainingsdaten und die verbleibenden als Testdaten verwenden.

train_size = 50
rng = np.random.RandomState(0)
X = rng.uniform(0, 5, 100)[:, np.newaxis]
y = np.array(X[:, 0] > 2.5, dtype=int)

Modell trainieren

Wir werden das GPC-Modell mit sowohl festen als auch optimierten Hyperparametern trainieren. Wir werden die logarithmische marginale Wahrscheinlichkeit, die Genauigkeit und den Log-Loss der Modelle ausgeben.

## Fixed Hyperparameters
gp_fix = GaussianProcessClassifier(kernel=1.0 * RBF(length_scale=1.0), optimizer=None)
gp_fix.fit(X[:train_size], y[:train_size])

## Optimized Hyperparameters
gp_opt = GaussianProcessClassifier(kernel=1.0 * RBF(length_scale=1.0))
gp_opt.fit(X[:train_size], y[:train_size])

## Results
print("Log Marginal Likelihood (initial): %.3f" % gp_fix.log_marginal_likelihood(gp_fix.kernel_.theta))
print("Log Marginal Likelihood (optimized): %.3f" % gp_opt.log_marginal_likelihood(gp_opt.kernel_.theta))
print("Accuracy: %.3f (initial) %.3f (optimized)" % (accuracy_score(y[:train_size], gp_fix.predict(X[:train_size])), accuracy_score(y[:train_size], gp_opt.predict(X[:train_size]))))
print("Log-loss: %.3f (initial) %.3f (optimized)" % (log_loss(y[:train_size], gp_fix.predict_proba(X[:train_size])[:, 1]), log_loss(y[:train_size], gp_opt.predict_proba(X[:train_size])[:, 1])))

Posterioren plotten

Wir werden die Posterioren des GPC-Modells mit sowohl festen als auch optimierten Hyperparametern plotten. Wir werden die Trainingsdaten, die Testdaten und die vorhergesagte Wahrscheinlichkeit für Klasse 1 plotten. Wir werden auch die Plots beschriften.

## Plot posteriors
plt.figure()
plt.scatter(X[:train_size, 0], y[:train_size], c="k", label="Train data", edgecolors=(0, 0, 0))
plt.scatter(X[train_size:, 0], y[train_size:], c="g", label="Test data", edgecolors=(0, 0, 0))
X_ = np.linspace(0, 5, 100)
plt.plot(X_, gp_fix.predict_proba(X_[:, np.newaxis])[:, 1], "r", label="Initial kernel: %s" % gp_fix.kernel_)
plt.plot(X_, gp_opt.predict_proba(X_[:, np.newaxis])[:, 1], "b", label="Optimized kernel: %s" % gp_opt.kernel_)
plt.xlabel("Feature")
plt.ylabel("Class 1 probability")
plt.xlim(0, 5)
plt.ylim(-0.25, 1.5)
plt.legend(loc="best")

Log-Marginal-Likelihood-Landschaft plotten

Wir werden die Log-Marginal-Likelihood-Landschaft des GPC-Modells mit verschiedenen Hyperparameterauswahlen plotten. Wir werden die Hyperparameter, die im vorherigen Plot verwendet wurden, hervorheben. Wir werden auch die Plots beschriften.

## Plot LML landscape
plt.figure()
theta0 = np.logspace(0, 8, 30)
theta1 = np.logspace(-1, 1, 29)
Theta0, Theta1 = np.meshgrid(theta0, theta1)
LML = [[gp_opt.log_marginal_likelihood(np.log([Theta0[i, j], Theta1[i, j]])) for i in range(Theta0.shape[0])] for j in range(Theta0.shape[1])]
LML = np.array(LML).T
plt.plot(np.exp(gp_fix.kernel_.theta)[0], np.exp(gp_fix.kernel_.theta)[1], "ko", zorder=10)
plt.plot(np.exp(gp_opt.kernel_.theta)[0], np.exp(gp_opt.kernel_.theta)[1], "ko", zorder=10)
plt.pcolor(Theta0, Theta1, LML)
plt.xscale("log")
plt.yscale("log")
plt.colorbar()
plt.xlabel("Magnitude")
plt.ylabel("Length-scale")
plt.title("Log-marginal-likelihood")

Zusammenfassung

In diesem Lab haben wir die Gaussian Process Classification (GPC) mit einem RBF-Kern und verschiedenen Hyperparameterauswahlen untersucht. Wir haben Daten generiert, das GPC-Modell mit sowohl festen als auch optimierten Hyperparametern trainiert und die Posterioren und die Log-Marginal-Likelihood-Landschaft geplottet. Wir haben auch die Genauigkeit und den Log-Loss des Modells ausgewertet.