Gaussian Processes (GP) es un método genérico de aprendizaje supervisado diseñado para resolver problemas de regresión y clasificación probabilística.

Las ventajas de los procesos gaussianos son:

• La predicción interpola las observaciones (al menos para los núcleos regulares).
• La predicción es probabilística (Gaussian) de manera que se pueden calcular intervalos empíricos de confianza y decidir en base a los mismos si se debe volver a ajustar (ajuste en línea, ajuste adaptativo) la predicción en alguna región de interés.
• Versátil: se pueden especificar diferentes kernels. Se proporcionan kernels comunes, pero también es posible especificar kernels personalizados.

Las desventajas de los procesos gaussianos incluyen:

• No son escasos, es decir, utilizan la información de muestras/características completas para realizar la predicción.
• Pierden eficiencia en espacios de grandes dimensiones, sobre todo cuando el número de prestaciones supera algunas docenas.

Regresión del Proceso Gaussiano (GPR)

El GaussianProcessRegressor implementa los procesos gaussianos (GP) para propósitos de regresión. Para ello, es necesario especificar la prioridad del GP. Se asume que la media anterior es constante y cero (para normalizar_y=Falso) o la media de los datos de entrenamiento (para normalizar_y=True). La covarianza del anterior se especifica pasando un objeto kernel. Los hiperparámetros del kernel se optimizan durante el ajuste de GaussianProcessRegressor maximizando la probabilidad marginal de log-marginal (LML) basada en el optimizador pasado. Como el LML puede tener múltiples óptimos locales, el optimizador se puede iniciar repetidamente especificando n_restarts_optimizer. La primera ejecución siempre se realiza a partir de los valores iniciales del hiperparámetro del kernel; las ejecuciones posteriores se realizan a partir de los valores del hiperparámetro que se han seleccionado aleatoriamente del rango de valores permitidos. Si los hiperparámetros iniciales deben mantenerse fijos, ninguno puede pasarse como optimizador.

El nivel de ruido en los objetivos puede especificarse pasándolo a través del parámetro alfa, ya sea globalmente como escalar o por punto de datos. Tenga en cuenta que un nivel de ruido moderado también puede ser útil para tratar los problemas numéricos durante el ajuste, ya que se implementa efectivamente como regularización de Tikhonov, es decir, añadiéndolo a la diagonal de la matriz del núcleo. Una alternativa a la especificación explícita del nivel de ruido es incluir un componente WhiteKernel en el kernal, que puede estimar el nivel de ruido global a partir de los datos (véase el ejemplo siguiente).

Los estimadores estándar de Scikit-learning, GaussianProcessRegressor:

• permite la predicción sin necesidad de ajuste previo (basado en el GP anterior)
• proporciona un método adicional sample_y (X), que evalúa las muestras extraídas del GPR (anterior o posterior) en las entradas dadas
• expone un método log_marginal_likelihood (theta), que se puede utilizar externamente para otras formas de seleccionar hiperparámetros, por ejemplo, a través de la cadena de Markov Monte Carlo.

Regresión del proceso gaussiano (GPR) con estimación del nivel de ruido

Este ejemplo ilustra que GPR con un núcleo de suma incluyendo un WhiteKernel puede estimar el nivel de ruido de los datos. Una ilustración del paisaje log-marginal-likelihood (LML) muestra que existen dos máximos locales de LML. El primero corresponde a un modelo con un alto nivel de ruido y una gran escala de longitud, lo que explica todas las variaciones en los datos por ruido. El segundo tiene un menor nivel de ruido y una escala de longitud más corta, lo que explica la mayor parte de la variación por la relación funcional sin ruido. El segundo modelo tiene una probabilidad más alta; sin embargo, dependiendo del valor inicial de los hiperparámetros, la optimización basada en gradientes también podría converger a la solución de alto ruido. Por lo tanto, es importante repetir la optimización varias veces para diferentes inicializaciones.
you will find a lot of top quality and fashionable bv rolex daytona rolex calibre 7750 mingzhu engine 116508cso mens hands. swiss yocan vape gentle as well as the construction with the discussion regarding unusual, showcasing the particular movements with the three-dimensional construction.

[php]
import numpy as np

from matplotlib import pyplot as plt
from matplotlib.colors import LogNorm

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

rng = np.random.RandomState(0)
X = rng.uniform(0, 5, 20)[:, np.newaxis]
y = 0.5 * np.sin(3 * X[:, 0]) + rng.normal(0, 0.5, X.shape[0])

# primero
plt.figure(0)
kernel = 1.0 * RBF(length_scale=100.0, length_scale_bounds=(1e-2, 1e3)) \
+ WhiteKernel(noise_level=1, noise_level_bounds=(1e-10, 1e+1))
gp = GaussianProcessRegressor(kernel=kernel,
alpha=0.0).fit(X, y)
X_ = np.linspace(0, 5, 100)
y_mean, y_cov = gp.predict(X_[:, np.newaxis], return_cov=True)
plt.plot(X_, y_mean, ‘k’, lw=3, zorder=9)
plt.fill_between(X_, y_mean – np.sqrt(np.diag(y_cov)),
y_mean + np.sqrt(np.diag(y_cov)),
alpha=0.5, color=’k’)
plt.plot(X_, 0.5*np.sin(3*X_), ‘g’, lw=3, zorder=9)
plt.scatter(X[:, 0], y, c=’g’, s=50, zorder=10, edgecolors=(0, 0, 0))
plt.title("Initial: %s\nOptimum: %s\nLog-Marginal-Likelihood: %s"
% (kernel, gp.kernel_,
gp.log_marginal_likelihood(gp.kernel_.theta)))
plt.tight_layout()

# segundo
plt.figure(1)
kernel = 1.0 * RBF(length_scale=1.0, length_scale_bounds=(1e-2, 1e3)) \
+ WhiteKernel(noise_level=1e-5, noise_level_bounds=(1e-10, 1e+1))
gp = GaussianProcessRegressor(kernel=kernel,
alpha=0.0).fit(X, y)
X_ = np.linspace(0, 5, 100)
y_mean, y_cov = gp.predict(X_[:, np.newaxis], return_cov=True)
plt.plot(X_, y_mean, ‘k’, lw=3, zorder=9)
plt.fill_between(X_, y_mean – np.sqrt(np.diag(y_cov)),
y_mean + np.sqrt(np.diag(y_cov)),
alpha=0.5, color=’k’)
plt.plot(X_, 0.5*np.sin(3*X_), ‘g’, lw=3, zorder=9)
plt.scatter(X[:, 0], y, c=’g’, s=50, zorder=10, edgecolors=(0, 0, 0))
plt.title("Initial: %s\nOptimum: %s\nLog-Marginal-Likelihood: %s"
% (kernel, gp.kernel_,
gp.log_marginal_likelihood(gp.kernel_.theta)))
plt.tight_layout()

# Plotea LML landscape
plt.figure(2)
theta0 = np.logspace(-2, 3, 49)
theta1 = np.logspace(-2, 0, 50)
Theta0, Theta1 = np.meshgrid(theta0, theta1)
LML = [[gp.log_marginal_likelihood(np.log([0.36, 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

vmin, vmax = (-LML).min(), (-LML).max()
vmax = 50
level = np.around(np.logspace(np.log10(vmin), np.log10(vmax), 50), decimals=1)
plt.contour(Theta0, Theta1, -LML,
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.tight_layout()

plt.show()

[/php]

➡ Aprende mucho mas de Machine Learning con nuestro curso:

Curso de Machine Learning en Python