Gaussian Process Regression und Klassifikation

Einführung

In diesem Lab werden wir Gaussian Prozesse (GP), eine Methode für das überwachte Lernen, die für Regressions- und probabilistische Klassifizierungsprobleme verwendet wird, erkunden. Gaussian Prozesse sind vielseitig und können Beobachtungen interpolieren, probabilistische Vorhersagen liefern und verschiedene Arten von Kernen verarbeiten. In diesem Lab werden wir uns auf die Gaussian Process Regression (GPR) und die Gaussian Process Classification (GPC) mit der scikit-learn-Bibliothek konzentrieren.

VM-Tipps

Nachdem die VM gestartet 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 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

Gaussian Process Regression (GPR)

Die GaussianProcessRegressor-Klasse implementiert Gaussian Prozesse für Regressionsaufgaben. Es ist erforderlich, einen Prior für den GP anzugeben, wie z. B. die Mittel- und Kovarianzfunktionen. Die Hyperparameter des Kerns werden während des Anpassungsprozesses optimiert. Schauen wir uns ein Beispiel für die Verwendung von GPR für die Regression an.

from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF

## Erstellen eines GPR-Modells mit einem RBF-Kern
kernel = RBF()
model = GaussianProcessRegressor(kernel=kernel)

## Anpassen des Modells an die Trainingsdaten
model.fit(X_train, y_train)

## Vorhersage mit dem trainierten Modell
y_pred = model.predict(X_test)

GPR-Beispiele

GPR mit Schätzung des Rauschpegels: In diesem Beispiel wird GPR mit einem Summen-Kern veranschaulicht, der einen WhiteKernel zur Schätzung des Rauschpegels der Daten enthält.

from sklearn.gaussian_process.kernels import WhiteKernel

## Erstellen eines GPR-Modells mit einem RBF-Kern und einem WhiteKernel
kernel = RBF() + WhiteKernel()
model = GaussianProcessRegressor(kernel=kernel)

## Anpassen des Modells an die Trainingsdaten
model.fit(X_train, y_train)

## Vorhersage mit dem trainierten Modell
y_pred = model.predict(X_test)

Vergleich von GPR und Kernel Ridge Regression: Sowohl die Kernel Ridge Regression (KRR) als auch die GPR lernen eine Zielfunktion mithilfe des "Kernel Tricks". Die GPR lernt ein generatives, probabilistisches Modell und kann Konfidenzintervalle liefern, während die KRR nur Vorhersagen liefert.

from sklearn.kernel_ridge import KernelRidge

## Erstellen eines Kernel Ridge Regression-Modells
krr_model = KernelRidge(kernel='rbf')

## Anpassen des KRR-Modells an die Trainingsdaten
krr_model.fit(X_train, y_train)

## Vorhersage mit dem KRR-Modell
krr_y_pred = krr_model.predict(X_test)

## Vergleich der Ergebnisse mit GPR
gpr_model = GaussianProcessRegressor(kernel=RBF())
gpr_model.fit(X_train, y_train)
gpr_y_pred = gpr_model.predict(X_test)

GPR auf Mauna Loa CO2-Daten: In diesem Beispiel wird die komplexe Kernel-Engineering und die Hyperparameter-Optimierung mithilfe des Gradientenanstiegs auf der logarithmischen marginalen Wahrscheinlichkeit demonstriert. Die Daten bestehen aus monatlichen Durchschnittskonzentrationen von atmosphärischem CO2, die am Mauna Loa Observatorium in Hawaii gesammelt wurden. Das Ziel ist, die CO2-Konzentration als Funktion der Zeit zu modellieren.

from sklearn.gaussian_process.kernels import RBF, ExpSineSquared, RationalQuadratic, WhiteKernel

## Erstellen eines GPR-Modells mit einem zusammengesetzten Kern
kernel = 34.4**2 * RBF(length_scale=41.8) + 3.27**2 * RBF(length_scale=180) * ExpSineSquared(length_scale=1.44, periodicity=1) + 0.446**2 * RationalQuadratic(alpha=17.7, length_scale=0.957) + 0.197**2 * RBF(length_scale=0.138) + WhiteKernel(noise_level=0.0336)
model = GaussianProcessRegressor(kernel=kernel)

## Anpassen des Modells an die Daten
model.fit(X_train, y_train)

## Vorhersage mit dem trainierten Modell
y_pred = model.predict(X_test)

Gaussian Process Classification (GPC)

Die GaussianProcessClassifier-Klasse implementiert die GPC für die probabilistische Klassifizierung. Sie legt einen GP-Prior auf eine latente Funktion fest, die dann durch eine Link-Funktion abgesquasht wird, um die Klassenwahrscheinlichkeiten zu erhalten. Die GPC unterstützt die Mehrklassen-Klassifizierung, indem sie entweder eine One-versus-rest- oder eine One-versus-one-Basierte-Trainings- und Vorhersage durchführt.

from sklearn.gaussian_process import GaussianProcessClassifier

## Erstellen eines GPC-Modells mit einem RBF-Kern
kernel = RBF()
model = GaussianProcessClassifier(kernel=kernel)

## Anpassen des Modells an die Trainingsdaten
model.fit(X_train, y_train)

## Vorhersage mit dem trainierten Modell
y_pred = model.predict(X_test)

GPC-Beispiele

Probabilistische Vorhersagen mit GPC: In diesem Beispiel wird die vorhergesagte Wahrscheinlichkeit der GPC mit verschiedenen Auswahlmöglichkeiten von Hyperparametern veranschaulicht.

## Erstellen eines GPC-Modells mit einem RBF-Kern
kernel = RBF()
model = GaussianProcessClassifier(kernel=kernel)

## Anpassen des Modells an die Trainingsdaten
model.fit(X_train, y_train)

## Vorhersagen der Klassenwahrscheinlichkeiten der Testdaten
y_prob = model.predict_proba(X_test)

Veranschaulichung von GPC auf dem XOR-Datensatz: In diesem Beispiel wird die Verwendung von GPC auf dem XOR-Datensatz demonstriert. Wir vergleichen die Ergebnisse der Verwendung eines stationären, isotropen Kerns (RBF) und eines nicht-stationären Kerns (DotProduct).

## Erstellen von GPC-Modellen mit verschiedenen Kernen
isotropischer_kernel = RBF(length_scale=1.0)
nicht-stationärer_kernel = DotProduct(sigma_0=1.0)

## Anpassen der Modelle an den XOR-Datensatz
isotropisches_model = GaussianProcessClassifier(kernel=isotropischer_kernel)
nicht-stationäres_model = GaussianProcessClassifier(kernel=nicht-stationärer_kernel)
isotropisches_model.fit(X_xor, y_xor)
nicht-stationäres_model.fit(X_xor, y_xor)

## Vorhersagen mit den trainierten Modellen
isotropische_y_pred = isotropisches_model.predict(X_test)
nicht-stationäre_y_pred = nicht-stationäres_model.predict(X_test)

GPC auf dem iris-Datensatz: In diesem Beispiel wird GPC auf dem iris-Datensatz mit einem isotropen RBF-Kern und einem anisotropen RBF-Kern veranschaulicht. Es wird gezeigt, wie verschiedene Auswahlmöglichkeiten von Hyperparametern die vorhergesagte Wahrscheinlichkeit beeinflussen können.

## Erstellen von GPC-Modellen mit verschiedenen Kernen und Anpassen an den iris-Datensatz
isotropischer_kernel = RBF(length_scale=1.0)
anisotropischer_kernel = RBF(length_scale=[1.0, 2.0])
isotropisches_model = GaussianProcessClassifier(kernel=isotropischer_kernel)
anisotropisches_model = GaussianProcessClassifier(kernel=anisotropischer_kernel)
isotropisches_model.fit(X_train, y_train)
anisotropisches_model.fit(X_train, y_train)

## Vorhersagen der Klassenwahrscheinlichkeiten
isotropische_y_prob = isotropisches_model.predict_proba(X_test)
anisotropische_y_prob = anisotropisches_model.predict_proba(X_test)

Zusammenfassung

In diesem Lab haben wir Gaussian Prozesse (GP) und ihre Anwendungen für Regressions- und Klassifizierungsaufgaben untersucht. Wir haben gelernt, wie man die GaussianProcessRegressor- und GaussianProcessClassifier-Klassen aus scikit-learn verwendet und wie man verschiedene Typen von Kernen für GPs angibt. Wir haben auch Beispiele von GPR für Regressionsaufgaben und GPC für Mehrklassen-Klassifizierungsaufgaben gesehen, was die Vielseitigkeit und die Fähigkeiten von Gaussian Prozessen demonstriert.