def test_noise_equals_gaussian(): gpr1 = GaussianProcessRegressor(rbf + wk).fit(X, y) # gpr2 sets the noise component to zero at predict time. gpr2 = GaussianProcessRegressor(rbf, noise="gaussian").fit(X, y) assert_false(gpr1.noise_) assert_true(gpr2.noise_) assert_almost_equal(gpr1.kernel_.k2.noise_level, gpr2.noise_, 4) mean1, std1 = gpr1.predict(X, return_std=True) mean2, std2 = gpr2.predict(X, return_std=True) assert_array_almost_equal(mean1, mean2, 4) assert_false(np.any(std1 == std2))
def interpolate(thetas, z_thetas, xx, yy, method='linear', z_uncertainties_thetas=None, matern_exponent=0.5, length_scale_min=0.001, length_scale_default=1., length_scale_max=1000., noise_level=0.001, subtract_min=False): if method == 'cubic': interpolator = CloughTocher2DInterpolator(thetas[:], z_thetas) zz = interpolator(np.dstack((xx.flatten(), yy.flatten()))) zi = zz.reshape(xx.shape) elif method == 'gp': if z_uncertainties_thetas is not None: gp = GaussianProcessRegressor( normalize_y=True, kernel=ConstantKernel(1.0, (1.e-9, 1.e9)) * Matern( length_scale=[length_scale_default], length_scale_bounds=[(length_scale_min, length_scale_max)], nu=matern_exponent) + WhiteKernel(noise_level), n_restarts_optimizer=10, alpha=z_uncertainties_thetas) else: gp = GaussianProcessRegressor( normalize_y=True, kernel=ConstantKernel(1.0, (1.e-9, 1.e9)) * Matern( length_scale=length_scale_default, length_scale_bounds=(length_scale_min, length_scale_max), nu=matern_exponent) + WhiteKernel(noise_level), n_restarts_optimizer=10) gp.fit(thetas[:], z_thetas[:]) zz, _ = gp.predict(np.c_[xx.ravel(), yy.ravel()], return_std=True) zi = zz.reshape(xx.shape) elif method == 'linear': interpolator = LinearNDInterpolator(thetas[:], z_thetas) zz = interpolator(np.dstack((xx.flatten(), yy.flatten()))) zi = zz.reshape(xx.shape) else: raise ValueError mle = np.unravel_index(zi.argmin(), zi.shape) if subtract_min: zi -= zi[mle] return zi, mle
def test_white_kernel_as_noise(): # first .fit() gpr1 = GaussianProcessRegressor(rbf + wk).fit(X, y) gpr2 = GaussianProcessRegressor(rbf, noise="gaussian").fit(X, y) mean1, std1 = gpr1.predict(X, return_std=True) mean2, std2 = gpr2.predict(X, return_std=True) assert_almost_equal(gpr1.kernel_.k2.noise_level, gpr2.noise_, 4) assert not np.any(std1 == std2) assert _param_for_white_kernel_in_Sum(gpr1.kernel_)[1] == 'k2' assert _param_for_white_kernel_in_Sum(gpr2.kernel_)[1] == 'k2' # second .fit() gpr1 = gpr1.fit(X, y) gpr2 = gpr2.fit(X, y) mean1, std1 = gpr1.predict(X, return_std=True) mean2, std2 = gpr2.predict(X, return_std=True) assert_almost_equal(gpr1.kernel_.k2.noise_level, gpr2.noise_, 4) assert _param_for_white_kernel_in_Sum(gpr1.kernel_)[1] == 'k2' assert _param_for_white_kernel_in_Sum(gpr2.kernel_)[1] == 'k2' assert not np.any(std1 == std2)
def test_gpr_uses_noise(): """ Test that gpr is using WhiteKernel by default""" X = np.random.normal(size=[100, 2]) Y = np.random.normal(size=[100]) g_gaussian = GaussianProcessRegressor() g_gaussian.fit(X, Y) m, sigma = g_gaussian.predict(X[0:1], return_cov=True) assert sigma > 0
def test_gpr_uses_noise(): """ Test that gpr is using WhiteKernel""" X = np.random.normal(size=[100, 2]) Y = np.random.normal(size=[100]) g_gaussian = GaussianProcessRegressor(noise='gaussian') g_gaussian.fit(X, Y) m, sigma = g_gaussian.predict(X[0:1], return_cov=True) assert sigma > 0
def test_mean_gradient(): length_scale = np.arange(1, 6) X = rng.randn(10, 5) y = rng.randn(10) X_new = rng.randn(5) rbf = RBF(length_scale=length_scale, length_scale_bounds="fixed") gpr = GaussianProcessRegressor(rbf, random_state=0).fit(X, y) mean, std, mean_grad = gpr.predict( np.expand_dims(X_new, axis=0), return_std=True, return_cov=False, return_mean_grad=True) num_grad = optimize.approx_fprime( X_new, lambda x: predict_wrapper(x, gpr)[0], 1e-4) assert_array_almost_equal(mean_grad, num_grad, decimal=3)
from skopt.learning.gaussian_process.kernels import RBF all_x = np.reshape(np.linspace(0, 6, 100), (-1, 1)) all_f = [black_box(xi) for xi in all_x] # Plot all points. plt.plot(all_x, all_f) # Train only one third of the training data. X = np.reshape(np.linspace(4, 6, 10), (-1, 1)) y = [black_box(xi) for xi in X] # Use RBF kernel. rbf = RBF(length_scale=1.0) gpr = GaussianProcessRegressor(kernel=rbf, alpha=1e-12) gpr.fit(X, y) plt.plot(np.ravel(X), y, "ro", label="Fit points") # Predict on all data. y_pred, y_std = gpr.predict(all_x, return_std=True) all_x_plot = np.ravel(all_x) upper_bound = y_pred + 1.96 * y_std lower_bound = y_pred - 1.96 * y_std plt.plot(all_x_plot, y_pred, "r--", label="Predictions") plt.plot(all_x_plot, lower_bound, color="red") plt.plot(all_x_plot, upper_bound, color="red") plt.fill_between(all_x_plot, lower_bound, upper_bound, facecolor="lightcoral") plt.legend() plt.show()
krigingModel = GaussianProcessRegressor(random_state=0) krigingModel.fit(XSobol, YSobol) # Compute the XGBoost surrogate print("Fitting the XGBoost Model") XGBoostModel = fitXGBoost(XSobol, YSobol) # At this point, we have the XGBoost surrogate model. What we need next is the bit which returns the parameterisations # for positive calibrations. nbModels = 2 predictions = [None] * nbModels # This is not nice at all print("Predicting on the two models") predictions[0] = krigingModel.predict(XOSS).flatten() predictions[1] = XGBoostModel.predict(XOSS).flatten() print("Evaluating MSE Performance") MSEperf = np.zeros((nbModels, monteCarlos)) for modelIndex in range(len(predictions)): for i in range(monteCarlos): MSEperf[modelIndex, i] = mean_squared_error(YOSS[i * testSize:(i + 1) * testSize], predictions[int(modelIndex)][i * testSize:(i + 1) * testSize]) print("Plotting") experiment_labels = ["Kriging", "XGBoost (Batch)"] MSEperf = pd.DataFrame(MSEperf, index=experiment_labels)