Einführung
Die Gaussian Process Regression ist eine statistische Modellierungstechnik, die verwendet wird, um das Ergebnis einer Zielvariablen basierend auf Eingabevariablen vorherzusagen. Die Technik modelliert die Verteilung der Zielvariablen als einen Gauß-Prozess, der eine Sammlung von Zufallsvariablen ist, von denen jede endliche Anzahl eine gemeinsame Gauß-Verteilung hat. Die Technik ist besonders nützlich in Fällen, in denen die Beziehung zwischen den Eingabe- und Zielvariablen nicht-linear ist.
In diesem Lab werden wir lernen, wie man Gaussian Process Regression mit Schwellenwertschätzung in Python mit der scikit-learn-Bibliothek verwendet.
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 von 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.
Datenerzeugung
In diesem Schritt werden wir einige Daten mit einem einzelnen Merkmal mithilfe einer Sinusfunktion erzeugen.
import numpy as np
def target_generator(X, add_noise=False):
target = 0.5 + np.sin(3 * X)
if add_noise:
rng = np.random.RandomState(1)
target += rng.normal(0, 0.3, size=target.shape)
return target.squeeze()
X = np.linspace(0, 5, num=30).reshape(-1, 1)
y = target_generator(X, add_noise=False)
Datenvisualisierung
In diesem Schritt werden wir die erzeugten Daten visualisieren.
import matplotlib.pyplot as plt
plt.plot(X, y, label="Expected signal")
plt.legend()
plt.xlabel("X")
_ = plt.ylabel("y")
Hinzufügen von Rauschen
In diesem Schritt werden wir dem erzeugten Datensatz etwas Rauschen hinzufügen, um einen realitätsnäheren Trainingsdatensatz zu erstellen.
rng = np.random.RandomState(0)
X_train = rng.uniform(0, 5, size=20).reshape(-1, 1)
y_train = target_generator(X_train, add_noise=True)
Datenvisualisierung
In diesem Schritt werden wir den rauschenden Trainingsdatensatz zusammen mit dem erwarteten Signal visualisieren.
plt.plot(X, y, label="Expected signal")
plt.scatter(
x=X_train[:, 0],
y=y_train,
color="black",
alpha=0.4,
label="Observations",
)
plt.legend()
plt.xlabel("X")
_ = plt.ylabel("y")
Gaussian-Prozess-Regression
In diesem Schritt werden wir einen Gaussian-Prozess-Regressor erstellen, indem wir einen additiven Kernel verwenden, der einen RBF- und einen WhiteKernel-Kernel hinzufügt. Der WhiteKernel ist ein Kernel, der die Menge an Rauschen im Datensatz abschätzen kann, während der RBF dazu dient, die Nichtlinearität zwischen den Daten und dem Ziel anzupassen.
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel
kernel = 1.0 * RBF(length_scale=1e-1, length_scale_bounds=(1e-2, 1e3)) + WhiteKernel(
noise_level=1e-2, noise_level_bounds=(1e-10, 1e1)
)
gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.0)
gpr.fit(X_train, y_train)
y_mean, y_std = gpr.predict(X, return_std=True)
Datenvisualisierung
In diesem Schritt werden wir die Vorhersagen visualisieren, die der Gaussian-Prozess-Regressor getroffen hat.
plt.plot(X, y, label="Expected signal")
plt.scatter(x=X_train[:, 0], y=y_train, color="black", alpha=0.4, label="Observations")
plt.errorbar(X, y_mean, y_std)
plt.legend()
plt.xlabel("X")
plt.ylabel("y")
_ = plt.title(
(
f"Initial: {kernel}\nOptimum: {gpr.kernel_}\nLog-Marginal-Likelihood: "
f"{gpr.log_marginal_likelihood(gpr.kernel_.theta)}"
),
fontsize=8,
)
Log-Marginal-Likelihood
In diesem Schritt werden wir die Log-Marginal-Likelihood (LML) des GaussianProcessRegressor für verschiedene Hyperparameter untersuchen, um einen Eindruck von den lokalen Minima zu erhalten.
from matplotlib.colors import LogNorm
length_scale = np.logspace(-2, 4, num=50)
noise_level = np.logspace(-2, 1, num=50)
length_scale_grid, noise_level_grid = np.meshgrid(length_scale, noise_level)
log_marginal_likelihood = [
gpr.log_marginal_likelihood(theta=np.log([0.36, scale, noise]))
for scale, noise in zip(length_scale_grid.ravel(), noise_level_grid.ravel())
]
log_marginal_likelihood = np.reshape(
log_marginal_likelihood, newshape=noise_level_grid.shape
)
vmin, vmax = (-log_marginal_likelihood).min(), 50
level = np.around(np.logspace(np.log10(vmin), np.log10(vmax), num=50), decimals=1)
plt.contour(
length_scale_grid,
noise_level_grid,
-log_marginal_likelihood,
levels=level,
norm=LogNorm(vmin=vmin, vmax=vmax),
)
plt.colorbar()
plt.xscale("log")
plt.yscale("log")
plt.xlabel("Length-scale")
plt.ylabel("Noise-level")
plt.title("Log-marginal-likelihood")
plt.show()
Fazit
In diesem Lab haben wir gelernt, wie man in Python die Gaussian-Prozess-Regression mit der Schätzung des Rauschpegels mithilfe der scikit-learn-Bibliothek anwendet. Wir haben einige Daten mit einem einzelnen Merkmal mithilfe einer Sinusfunktion generiert, Rauschen zu den generierten Daten hinzugefügt, um einen realitätsnäheren Trainingsdatensatz zu erstellen und die generierten Daten visualisiert. Wir haben einen Gaussian-Prozess-Regressor mit einem additiven Kernel erstellt, der einen RBF- und einen WhiteKernel-Kernel hinzufügt, und die Vorhersagen des Gaussian-Prozess-Regressors visualisiert. Wir haben auch die Log-Marginal-Likelihood (LML) des GaussianProcessRegressor für verschiedene Hyperparameter untersucht, um einen Eindruck von den lokalen Minima zu erhalten.
Zusammenfassung
Herzlichen Glückwunsch! Sie haben das Gaussian Process Regression Lab abgeschlossen. Sie können in LabEx weitere Labs ausprobieren, um Ihre Fähigkeiten zu verbessern.