Einführung
In diesem Lab werden die Unterschiede zwischen einer Kernel Ridge Regression und einer Gaussian Process Regression veranschaulicht und gezeigt, wie diese zur Anpassung an einen Datensatz verwendet werden. Wir werden uns auch auf die Optimierung der Kernel-Hyperparameter konzentrieren.
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 während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.
Erzeugen eines Datensatzes
Wir erstellen einen synthetischen Datensatz. Der wahre Generierungsprozess wird einen eindimensionalen Vektor nehmen und dessen Sinus berechnen.
import numpy as np
rng = np.random.RandomState(0)
data = np.linspace(0, 30, num=1_000).reshape(-1, 1)
target = np.sin(data).ravel()
training_sample_indices = rng.choice(np.arange(0, 400), size=40, replace=False)
training_data = data[training_sample_indices]
training_noisy_target = target[training_sample_indices] + 0.5 * rng.randn(
len(training_sample_indices)
)
Einschränkungen eines einfachen linearen Modells
Wir trainieren ein Ridge-Modell und überprüfen die Vorhersagen dieses Modells auf unserem Datensatz.
from sklearn.linear_model import Ridge
import matplotlib.pyplot as plt
ridge = Ridge().fit(training_data, training_noisy_target)
plt.plot(data, target, label="True signal", linewidth=2)
plt.scatter(
training_data,
training_noisy_target,
color="black",
label="Noisy measurements",
)
plt.plot(data, ridge.predict(data), label="Ridge regression")
plt.legend()
plt.xlabel("data")
plt.ylabel("target")
_ = plt.title("Limitation of a linear model such as ridge")
Kernel-Methoden: Kernel Ridge und Gaussian Process
Kernel Ridge
Wir verwenden einen KernelRidge mit einem ExpSineSquared-Kernel, der es ermöglicht, die Periodizität wiederzugewinnen.
from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process.kernels import ExpSineSquared
kernel_ridge = KernelRidge(kernel=ExpSineSquared())
kernel_ridge.fit(training_data, training_noisy_target)
plt.plot(data, target, label="True signal", linewidth=2, linestyle="dashed")
plt.scatter(
training_data,
training_noisy_target,
color="black",
label="Noisy measurements",
)
plt.plot(
data,
kernel_ridge.predict(data),
label="Kernel ridge",
linewidth=2,
linestyle="dashdot",
)
plt.legend(loc="lower right")
plt.xlabel("data")
plt.ylabel("target")
_ = plt.title(
"Kernel ridge regression with an exponential sine squared\n "
"kernel using default hyperparameters"
)
Gaussian Process Regression
Wir verwenden einen GaussianProcessRegressor, um dasselbe Datenset anzupassen. Beim Training eines Gaussian Processes werden die Hyperparameter des Kerns während des Anpassungsprozesses optimiert.
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import WhiteKernel
kernel = 1.0 * ExpSineSquared(1.0, 5.0, periodicity_bounds=(1e-2, 1e1)) + WhiteKernel(
1e-1
)
gaussian_process = GaussianProcessRegressor(kernel=kernel)
gaussian_process.fit(training_data, training_noisy_target)
mean_predictions_gpr, std_predictions_gpr = gaussian_process.predict(
data, return_std=True,
)
plt.plot(data, target, label="True signal", linewidth=2, linestyle="dashed")
plt.scatter(
training_data,
training_noisy_target,
color="black",
label="Noisy measurements",
)
plt.plot(
data,
mean_predictions_gpr,
label="Gaussian process regressor",
linewidth=2,
linestyle="dotted",
)
plt.fill_between(
data.ravel(),
mean_predictions_gpr - std_predictions_gpr,
mean_predictions_gpr + std_predictions_gpr,
color="tab:green",
alpha=0.2,
)
plt.legend(loc="lower right")
plt.xlabel("data")
plt.ylabel("target")
_ = plt.title("Gaussian process regressor")
Endgültige Schlussfolgerung
Wir können ein abschließendes Wort über die Möglichkeit der beiden Modelle zur Extrapolation sagen. Wir stellen fest, dass die Modelle das Sinusmuster weiterhin vorhersagen werden.
kernel = 1.0 * ExpSineSquared(1.0, 5.0, periodicity_bounds=(1e-2, 1e1)) * RBF(
length_scale=15, length_scale_bounds="fixed"
) + WhiteKernel(1e-1)
gaussian_process = GaussianProcessRegressor(kernel=kernel)
gaussian_process.fit(training_data, training_noisy_target)
mean_predictions_gpr, std_predictions_gpr = gaussian_process.predict(
data, return_std=True,
)
plt.plot(data, target, label="True signal", linewidth=2, linestyle="dashed")
plt.scatter(
training_data,
training_noisy_target,
color="black",
label="Noisy measurements",
)
plt.plot(
data,
mean_predictions_gpr,
label="Gaussian process regressor",
linewidth=2,
linestyle="dotted",
)
plt.fill_between(
data.ravel(),
mean_predictions_gpr - std_predictions_gpr,
mean_predictions_gpr + std_predictions_gpr,
color="tab:green",
alpha=0.2,
)
plt.legend(loc="lower right")
plt.xlabel("data")
plt.ylabel("target")
_ = plt.title("Comparison between kernel ridge and gaussian process regressor")
Zusammenfassung
In diesem Lab haben wir die Kernel Ridge Regression und die Gaussian Process Regression verglichen. Wir haben gelernt, dass der Gaussian Process Regressor eine Unsicherheitsinformation liefert, die nicht mit einer Kernel Ridge erhältlich ist. Der Gaussian Process ermöglicht es, Kerne zusammenzusetzen.