def create_gp(self): gp_mean = [] gp_std = [] for i in range(self.dim): # gp_mean.append(gaussian_process.GaussianProcessRegressor(kernel=1.0 * RBF(length_scale=1.0) + # ConstantKernel(0.02, constant_value_bounds=(0.01, 0.05)) * \ # WhiteKernel(0.1, noise_level_bounds=(0.01, 0.2)), # n_restarts_optimizer=3)) gp_mean.append( gaussian_process.GaussianProcessRegressor( kernel=1.0 * RBF(length_scale=1.0) + 0.1 * WhiteKernel(0.1, noise_level_bounds=(0.01, 0.2)), n_restarts_optimizer=3)) # gp_std.append(gaussian_process.GaussianProcessRegressor(kernel=1.0 * RBF(length_scale=0.3) + # 0.01 * WhiteKernel(0.01), # n_restarts_optimizer=3)) kernel_std = 1.0 * ExpSineSquared(length_scale=1.0, periodicity=3.0, length_scale_bounds=(0.5, 5.0), periodicity_bounds=(1.0, 10.0)) + \ ConstantKernel(0.1, constant_value_bounds=(0.05, 0.2)) * \ WhiteKernel(0.01, noise_level_bounds=(0.01, 0.1)) gp_std.append( gaussian_process.GaussianProcessRegressor( kernel=kernel_std, n_restarts_optimizer=3)) return gp_mean, gp_std
def loadEmulators(file1=r_sh_file, file2=v_con_file, file3=y_e_file, file4=s_file): r_sh_load = gaussian_process.GaussianProcessRegressor(kernel=kernel_choice) v_con_load = gaussian_process.GaussianProcessRegressor( kernel=kernel_choice) y_e_load = gaussian_process.GaussianProcessRegressor(kernel=kernel_choice) s_load = gaussian_process.GaussianProcessRegressor(kernel=kernel_choice) with open(file1, "rb") as f1: r_sh_load = pickle.load(f1) with open(file2, "rb") as f2: v_con_load = pickle.load(f2) with open(file3, "rb") as f3: y_e_load = pickle.load(f3) with open(file4, "rb") as f4: s_load = pickle.load(f4) global r_sh_emul global v_con_emul global y_e_emul global s_emul r_sh_emul = r_sh_load v_con_emul = v_con_load y_e_emul = y_e_load s_emul = s_load
def fit(self, X, y): self.ages_ = y degree = 4 ages_t = y.reshape(-1, 1) wm_model = sklearn.pipeline.make_pipeline( sklearn.preprocessing.PolynomialFeatures(degree), sklearn.linear_model.LinearRegression()) gm_model = sklearn.pipeline.make_pipeline( sklearn.preprocessing.PolynomialFeatures(1), sklearn.linear_model.LinearRegression()) self.wm_model_ = wm_model.fit(ages_t, X[:, 0]) self.gm_model_ = gm_model.fit(ages_t, X[:, 1]) self.ages_ = y self.ages_grid_ = np.arange(15, 100).reshape(-1, 1) ages_kde = skn.KernelDensity(kernel="gaussian", bandwidth=3) ages_kde.fit(ages_t) prior = np.exp( ages_kde.score_samples(self.ages_grid_)) self.prior_ = prior / np.sum(prior) wm_residuals = np.abs(wm_model.predict(ages_t) - X[:, 0]) gm_kernel = ( 44.7 ** 2 * skg.kernels.RBF(length_scale=30, length_scale_bounds=(10, 60)) + skg.kernels.WhiteKernel(noise_level=1e4, noise_level_bounds=(1e3, 1e5)) ) wm_kernel = ( 44.7 ** 2 * skg.kernels.RBF(length_scale=30, length_scale_bounds=(10, 60)) + skg.kernels.WhiteKernel(noise_level=1e4, noise_level_bounds=(1e3, 1e5)) ) self.wm_gp_ = skg.GaussianProcessRegressor( kernel=wm_kernel, n_restarts_optimizer=0) self.wm_gp_.fit(ages_t, wm_residuals) gm_residuals = np.abs(gm_model.predict(ages_t) - X[:, 1]) self.gm_gp_ = skg.GaussianProcessRegressor( kernel=gm_kernel, n_restarts_optimizer=0) self.gm_gp_.fit(ages_t, gm_residuals) # plt.figure() # plt.scatter(y, X[:, 0]) # plt.plot(self.ages_grid_, wm_model.predict(self.ages_grid_)) # plt.figure() # plt.scatter(y, gm_residuals) # plt.plot(self.ages_grid_, self.gm_gp_.predict(self.ages_grid_)) # plt.show() # input() return self
def build_surrogate(self): """Builds a surrogate based on sample evalations using a Guassian process. Assumptions: None Source: N/A Inputs: self.training. coefficients [-] CM, Cm_alpha, Cn_beta neutral point [meters] NP grid_points [radians,-] angles of attack and mach numbers Outputs: self.surrogates. moment_coefficient <Guassian process surrogate> Cm_alpha_moment_coefficient <Guassian process surrogate> Cn_beta_moment_coefficient <Guassian process surrogate> neutral_point <Guassian process surrogate> Properties Used: No others """ # Unpack data training = self.training AoA_data = training.angle_of_attack mach_data = training.Mach CM_data = training.coefficients[:, 0] Cm_alpha_data = training.coefficients[:, 1] Cn_beta_data = training.coefficients[:, 2] NP_data = training.coefficients[:, 3] xy = training.grid_points # Gaussian Process New regr_cm = gaussian_process.GaussianProcessRegressor() regr_cm_alpha = gaussian_process.GaussianProcessRegressor() regr_cn_beta = gaussian_process.GaussianProcessRegressor() regr_np = gaussian_process.GaussianProcessRegressor() cm_surrogate = regr_cm.fit(xy, CM_data) cm_alpha_surrogate = regr_cm_alpha.fit(xy, Cm_alpha_data) cn_beta_surrogate = regr_cn_beta.fit(xy, Cn_beta_data) neutral_point_surrogate = regr_np.fit(xy, NP_data) self.surrogates.moment_coefficient = cm_surrogate self.surrogates.Cm_alpha_moment_coefficient = cm_alpha_surrogate self.surrogates.Cn_beta_moment_coefficient = cn_beta_surrogate self.surrogates.neutral_point = neutral_point_surrogate return
def from_drpall(cls, drpall, n=None, **kwargs): ''' read in lots of IFUs' LSFs, assume a redshift ''' import sklearn.gaussian_process as gp if n is None: n = len(drpall) lam, specres, dspecres = zip(*[ m.hdu_data_extract(hdulist=m.load_drp_logcube( plate=row['plate'], ifu=row['ifudsgn'], mpl_v=mpl_v), names=['WAVE', 'SPECRES', 'SPECRESD']) for row in drpall[:n] ]) lam = np.concatenate(lam) specres = np.concatenate(specres) dspecres = np.concatenate(dspecres) good = np.logical_and.reduce( list(map(np.isfinite, [lam, specres, dspecres]))) lam, specres, dspecres = lam[good], specres[good], dspecres[good] kernel_ = gp.kernels.RBF( length_scale=1., length_scale_bounds=(.2, 5.)) + \ gp.kernels.WhiteKernel( noise_level=.02, noise_level_bounds=(.002, 2.)) regressor = gp.GaussianProcessRegressor(normalize_y=True, kernel=kernel_) regressor.fit(X=np.atleast_2d(lam).T, y=specres) return cls(LSF_R_obs_gpr=regressor, **kwargs)
def __init__(self, D, K, beta_t, kernel, sigma2): """Initializes a GP contextual bandit object Parameters ---------- D : int Dimension of the context features K : int Number of arms beta_t: float width parameter of the ucb kernel: kernel obj kernel for the gaussian processes from sklearn sigma2: noise level of the observations in the GP """ self.D = D self.K = K self.beta_t = beta_t # TODO: Make this varinputin for the kernel --> default use RBF kernel? self.GpObj = gp.GaussianProcessRegressor(kernel=kernel, alpha=sigma2) # initialization self.S = np.array([]).reshape(0, 1) self.Z = np.array([]).reshape(0, D) self.X = np.hstack((self.S, self.Z)) self.y = np.array([]).reshape(0, 1) self.sigma2 = sigma2
def identify_outliers_GP(x, y, mag): # mag -> magnitude in units std # if len(y)<11 flag all idx = [] if len(y) < 11: print("block too short with length " + str(int(len(y))) + ", values flagged") x_pred = [] y_pred = [] sigma = [] for i in range(len(y)): idx.append(i) x_pred.append(np.nan) y_pred.append(np.nan) sigma.append(np.nan) else: kernel = 1 * RBF(length_scale=1) + WhiteKernel(noise_level=1) gp = gaussian_process.GaussianProcessRegressor(kernel=kernel) gp.fit(x.reshape(-1, 1), y.reshape(-1, 1)) print gp.kernel_ x_pred = x.reshape(-1, 1) y_pred, sigma = gp.predict(x_pred, return_std=True) for i in range(len(y)): if ((y[i] > (y_pred[i] + (mag * sigma[i]))[0]) or (y[i] < (y_pred[i] - (mag * sigma[i]))[0])): idx.append(i) return idx, x_pred, y_pred, sigma
def store_anm(progress_counter, list_data): # For loop for calculating the result for data_num in list_data: file_name = "datasets/" + data_num + ".txt" print(file_name + " In Progress (" + str( float("{0:.2f}".format(progress_counter / len(list_data) * 100))) + " % Done)") progress_counter += 1 df = pd.read_csv(file_name, delim_whitespace=True, header=None) df.columns = ["x", "y"] x = sk.scale(df['x'].tolist()).reshape((-1, 1)) y = sk.scale(df['y'].tolist()).reshape((-1, 1)) gp = sk_gp.GaussianProcessRegressor().fit(x, y) anm = anm_store.ANM_store() anm_result.append(anm.predict_proba(df['x'].tolist(), df['y'].tolist())) # indepscoreX_result.append(anm.anm_score(sk.scale(df['x'].tolist()).reshape((-1, 1)), sk.scale(df['y'].tolist()).reshape((-1, 1)))) # x -> y direction # indepscoreY_result.append(anm.anm_score(sk.scale(df['y'].tolist()).reshape((-1, 1)), # sk.scale(df['x'].tolist()).reshape((-1, 1)))) # y -> x direction y_predict_result.append(y_predict_calculator(x, gp)) y_predict_result.append(y_predict_calculator(y, gp)) y_predict_std.append(y_predict_calculator(x, gp, True, False)) y_predict_std.append(y_predict_calculator(y, gp, True, False)) y_predict_cov.append(y_predict_calculator(x, gp, False, True)) y_predict_cov.append(y_predict_calculator(y, gp, False, True))
def __init__(self, bounds, f=None, init_num=5, inputs=None, vals=None, kernel=gaussian_process.kernels.Matern(nu=1.5), acq_func=EI, explicit_f=True): self._f = f self._iterations = 0 self._bounds = bounds if explicit_f: #if an explicit function is given self._inputs = [] self._func_vals = [] #List of tuples of function inputs and function outputs # Random initial inputs to obtain some function values for i in range(init_num): inputs = (uniform(bounds[0, :], bounds[1, :])) self._inputs.append(inputs) self._func_vals.append(self._f(inputs)) else: #if no explicit function is given self._inputs = inputs self._func_vals = vals id = np.argmax(self._func_vals) self._current_opt = (self._inputs[id], self._func_vals[id]) self._gpr = gaussian_process.GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=2).fit(self._inputs, self._func_vals) self._recommended_point = self._inputs[-1]
def gpr(data, xseq, **params): """ Fit gaussian process """ try: from sklearn import gaussian_process except ImportError: raise PlotnineError( "To use gaussian process smoothing, " "You need to install scikit-learn.") kwargs = params['method_args'] if not kwargs: warnings.warn( "See sklearn.gaussian_process.GaussianProcessRegressor " "for parameters to pass in as 'method_args'") regressor = gaussian_process.GaussianProcessRegressor(**kwargs) X = np.atleast_2d(data['x']).T n = len(data) Xseq = np.atleast_2d(xseq).T regressor.fit(X, data['y']) data = pd.DataFrame({'x': xseq}) if params['se']: y, stderr = regressor.predict(Xseq, return_std=True) data['y'] = y data['se'] = stderr data['ymin'], data['ymax'] = tdist_ci( y, n-1, stderr, params['level']) else: data['y'] = regressor.predict(Xseq, return_std=True) return data
def upper_confidence_bound(param_array, train_dic, greater_is_better=True): pred = {} train_index = train_dic.keys() train_Y = [] train_X = [] test_X = [] test_X_index = [] for i, ele in enumerate(param_array): if i in train_index: train_X.append(param_array[i]) train_Y.append(train_dic[i]) else: test_X.append(param_array[i]) test_X_index.append(i) kernel = Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0), nu=2.5) gpr = gaussian_process.GaussianProcessRegressor(kernel=kernel).fit( train_X, train_Y) avg_pred, std_pred = gpr.predict(test_X, return_std=True, return_cov=False) scaling_factor = (-1)**(not greater_is_better) beta = 1.96 for i, avg_pred_i in enumerate(avg_pred): pred[ test_X_index[i]] = avg_pred_i + scaling_factor * std_pred[i] * beta return pred
def create_model(samples_x, samples_y_aggregation, n_restarts_optimizer=250, is_white_kernel=False): ''' Trains GP regression model ''' kernel = gp.kernels.ConstantKernel(constant_value=1, constant_value_bounds=(1e-12, 1e12)) * \ gp.kernels.Matern(nu=1.5) if is_white_kernel is True: kernel += gp.kernels.WhiteKernel(noise_level=1, noise_level_bounds=(1e-12, 1e12)) regressor = gp.GaussianProcessRegressor( kernel=kernel, n_restarts_optimizer=n_restarts_optimizer, normalize_y=True, alpha=1e-10) regressor.fit(numpy.array(samples_x), numpy.array(samples_y_aggregation)) model = {} model['model'] = regressor model['kernel_prior'] = str(kernel) model['kernel_posterior'] = str(regressor.kernel_) model['model_loglikelihood'] = regressor.log_marginal_likelihood( regressor.kernel_.theta) return model
def fit_gp(x, y, yerr): from sklearn import gaussian_process from sklearn.gaussian_process.kernels import ( Matern, WhiteKernel, # ConstantKernel, ) # _, ystd = eu.stat.sigma_clip(smooth_data_hann3(y) - y) # ystd = (smooth_data_hann3(y) - y).std() spacing = x[1] - x[0] kernel = ( # ConstantKernel() + Matern(length_scale=spacing, nu=5/2) + WhiteKernel(noise_level=yerr**2) ) gp = gaussian_process.GaussianProcessRegressor( kernel=kernel, normalize_y=True, ) X = x.reshape(-1, 1) gp.fit(X, y) return gp
def expected_improvement(param_array, train_dic, greater_is_better=True): train_index = train_dic.keys() train_Y = [] train_X = [] test_X = [] test_X_index = [] for i, ele in enumerate(param_array): if i in train_index: train_X.append(param_array[i]) train_Y.append(train_dic[i]) else: test_X.append(param_array[i]) test_X_index.append(i) kernel = Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0), nu=2.5) gpr = gaussian_process.GaussianProcessRegressor(kernel=kernel).fit( train_X, train_Y) avg_pred, std_pred = gpr.predict(test_X, return_std=True, return_cov=False) if greater_is_better: loss_optimum = np.max(train_Y) else: loss_optimum = np.min(train_Y) scaling_factor = (-1)**(not greater_is_better) # In case sigma equals zero with np.errstate(divide='ignore'): Z = scaling_factor * (avg_pred - loss_optimum) / std_pred expected_improvement = scaling_factor * ( avg_pred - loss_optimum) * norm.cdf(Z) + std_pred * norm.pdf(Z) expected_improvement[std_pred == 0.0] == 0.0 return dict(zip(test_X_index, expected_improvement))
def optimize(self, param_opt, itr): if param_opt == 'MLE': optimizer_input = 'fmin_l_bfgs_b' elif param_opt == 'Not_optimize': optimizer_input = None else: return ( "This library does not support the specified Parameter optimizer" ) self.model = sklearn_gp.GaussianProcessRegressor( kernel=self.kernel_function, n_restarts_optimizer=itr, alpha=self.nugget, optimizer=optimizer_input, normalize_y=self.mean_function, copy_X_train=True, random_state=None) print('Kernel hyperparameters before optimization :\n', self.model.kernel) self.model.fit(self.x_train, self.z_train) print('Kernel hyperparameters after optimization :\n', self.model.kernel_) print("Nuggets before optimization :\n", self.model.alpha)
def __init__(self, objective, max_trials, num_initial_points=None, alpha=1e-4, beta=2.6, seed=None, hyperparameters=None, allow_new_entries=True, tune_new_entries=True): super(BayesianOptimizationOracle, self).__init__(objective=objective, max_trials=max_trials, hyperparameters=hyperparameters, tune_new_entries=tune_new_entries, allow_new_entries=allow_new_entries) self.num_initial_points = num_initial_points self.alpha = alpha self.beta = beta self.seed = seed or random.randint(1, 1e4) self._seed_state = self.seed self._tried_so_far = set() self._max_collisions = 20 self.gpr = gaussian_process.GaussianProcessRegressor( kernel=gaussian_process.kernels.Matern(), n_restarts_optimizer=20, normalize_y=True, alpha=self.alpha, random_state=self.seed)
def test_GaussianProcess_ge_018(self): X = np.atleast_2d([1., 3., 5., 6., 7., 8.]).T y = np.sin(X).ravel() df = pdml.ModelFrame(X, target=y) k1 = (df.gp.kernels.ConstantKernel(1.0, (1e-3, 1e3)) * df.gp.kernels.RBF(10, (1e-2, 1e2))) g1 = df.gp.GaussianProcessRegressor(kernel=k1, n_restarts_optimizer=9, random_state=self.random_state) k2 = (gp.kernels.ConstantKernel(1.0, (1e-3, 1e3)) * gp.kernels.RBF(10, (1e-2, 1e2))) g2 = gp.GaussianProcessRegressor(kernel=k2, n_restarts_optimizer=9, random_state=self.random_state) g1.fit(X, y) g2.fit(X, y) x = np.atleast_2d(np.linspace(0, 10, 1000)).T tdf = pdml.ModelFrame(x) y_result = tdf.predict(g1) y_expected = g2.predict(x) self.assertIsInstance(y_result, pdml.ModelSeries) tm.assert_index_equal(y_result.index, tdf.index) self.assert_numpy_array_almost_equal(y_result, y_expected)
def test_Gaussian2D_std(self): # http://scikit-learn.org/stable/auto_examples/gaussian_process/plot_gp_probabilistic_classification_after_regression.html def g(x): """The function to predict (classification will then consist in predicting whether g(x) <= 0 or not)""" return 5. - x[:, 1] - .5 * x[:, 0]**2. # Design of experiments X = np.array([[-4.61611719, -6.00099547], [4.10469096, 5.32782448], [0.00000000, -0.50000000], [-6.17289014, -4.6984743], [1.3109306, -6.93271427], [-5.03823144, 3.10584743], [-2.87600388, 6.74310541], [5.21301203, 4.26386883]]) y = g(X) df = pdml.ModelFrame(X, target=y) gpm1 = df.gaussian_process.GaussianProcessRegressor() df.fit(gpm1) result, std_result = df.predict(gpm1, return_std=True) gpm2 = gp.GaussianProcessRegressor() gpm2.fit(X, y) expected, std_expected = gpm2.predict(X, return_std=True) self.assert_numpy_array_almost_equal(result.values, expected) self.assert_numpy_array_almost_equal(std_result.values, std_expected)
def __init__(self, kernel, verbose=False): self.K, self.parameters_search_space = kernel() self.model = gp.GaussianProcessRegressor(kernel=self.K) self.verbose = verbose self.logger = config.getlogger("GP") self.best_param = None self.trained = False
def interpolate(x, y, new_x, kind): """Interpolate 1D array y at values x to new_x values. Parameters ---------- x : array x values of input y y : array 1D array to interpolate new_x : array x values of desired interpolated output kind : str Perform either 'cubic' or 'gp' interpolation Returns ------- new_y, interpolated values of y at positions new_x """ if kind == 'cubic': f_y = interp1d(x, y, kind='cubic') new_y = f_y(new_x) elif kind == 'gp': from sklearn import gaussian_process gp = gaussian_process.GaussianProcessRegressor(normalize_y=True, alpha=1e-3, n_restarts_optimizer=5) gp.fit(x.reshape(-1, 1), y.reshape(-1, 1)) new_y = gp.predict(new_x.reshape(-1, 1)) return new_y
def bayesian_optimisation2(n_iters, loss_fn, bounds, x_list=[], y_list=[], n_pre_samples=5, alpha=1e-5, epsilon=1e-7): # Handle any specifically-asked for "guesses" first for i, v in enumerate(y_list): if v[0] is None: print("Running guess values") y_list[i] = loss_fn(x_list[i]) n_pre_samples -= len(x_list) if n_pre_samples > 0: for params in np.random.uniform(bounds[:, 0], bounds[:, 1], (n_pre_samples, bounds.shape[0])): x_list.append(params) y_list.append(loss_fn(params)) xp = np.array(x_list) yp = np.array(y_list) # Create the GP kernel = gp.kernels.Matern() model = gp.GaussianProcessRegressor(kernel=kernel, alpha=alpha, n_restarts_optimizer=10, normalize_y=True) for n in range(n_iters): print("Fitting GP") model.fit(xp, yp) # Sample next hyperparameter next_sample = sample_next_hyperparameter(expected_improvement, model, yp, greater_is_better=True, bounds=bounds, n_restarts=100) # Duplicates will break the GP. In case of a duplicate, we will randomly sample a next query point. if np.any(np.abs(next_sample - xp) <= epsilon): next_sample = np.random.uniform(bounds[:, 0], bounds[:, 1], bounds.shape[0]) # Sample loss for new set of parameters cv_score = loss_fn(next_sample) # Update lists x_list.append(next_sample) y_list.append(cv_score) # Update xp and yp xp = np.array(x_list) yp = np.array(y_list) return xp, yp
def interp_krige(data): stream_trans = data.stream_dist.values sample_z = data.sample_z.values valid = np.isfinite(stream_trans[:, 0]) if valid.sum() == 0: return np.nan # gp = GP.GaussianProcessRegressor(kernel=GP.kernels.ConstantKernel(1.0),n_restarts_optimizer=9) # kernel=GP.kernels.ConstantKernel(1.0)) # kernel=None # takes 4 seconds to fit. #kernel=( GP.kernels.ConstantKernel(1.0,[0.1,10]) * GP.kernels.RBF(1,[0.1,10]) # + GP.kernels.WhiteKernel(noise_level=1) ) # takes 0.4s to fit. kernel = GP.kernels.Matern(length_scale=2, nu=1.5) # Warnings # kernel=GP.kernels.ConstantKernel(1.0,[0.1,10]) # kernel=GP.kernels.RBF(1.0,[0.1,10]) gp = GP.GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=1) offset = sample_z[valid].mean() start = time.time() gp.fit(stream_trans[valid], sample_z[valid] - offset) #print("Fit: %fs"%(time.time()-start)) #import pdb #pdb.set_trace() z_pred = gp.predict(np.array([[0, 0]]))[0] return z_pred + offset
def _make_gpr(self): return gaussian_process.GaussianProcessRegressor( kernel=gaussian_process.kernels.Matern(nu=2.5), n_restarts_optimizer=20, normalize_y=True, alpha=self.alpha, random_state=self.seed)
def loo_rsquared(self): """Get leave-one-out R-squared value Kernel parameters and normalization constants are not changed. The intent is to test holding out the observations but not re-fitting the kernel parameters. """ Xtrans = self.x_scaler.transform(self.X) Ytrans = (self.Y - self.y_mean) / self.y_std preds = [] for i in range(len(Ytrans)): X = np.delete(Xtrans, i, axis=0) Y = np.delete(Ytrans, i) gp = gaussian_process.GaussianProcessRegressor( kernel=self.gp.kernel_, alpha=self.gp.alpha, normalize_y=False, optimizer=None).fit(X, Y) preds.append(gp.predict([Xtrans[i, :]], return_std=False)[0]) return self._rsquared(Ytrans, np.array(preds))
def bayesian_optimization(n_iters, sample_loss, xp, yp): """ Arguments: ---------- n_iters: int. Number of iterations to run the algorithm for. sample_loss: function. Loss function that takes an array of parameters. xp: array-like, shape = [n_samples, n_params]. Array of previously evaluated hyperparameters. yp: array-like, shape = [n_samples, 1]. Array of values of `sample_loss` for the hyperparameters in `xp`. """ # Define the GP kernel = gp.kernels.Matern() model = gp.GaussianProcessRegressor(kernel=kernel, alpha=1e-4, n_restarts_optimizer=10, normalize_y=True) for i in range(n_iters): # Update our belief of the loss function model.fit(xp, yp) # sample_next_hyperparameter is a method that computes the arg # max of the acquisition function next_sample = sample_next_hyperparameter(model, yp) # Evaluate the loss for the new hyperparameters next_loss = sample_loss(next_sample)
def __init__(self, X: np.ndarray, Y: np.ndarray): """ Constructor for PosGP Parameters: X (numpy.ndarray): Training inputs on the form (n, 5) where the innermost dimension corresponds to [p_x, p_y, cog, sog, t] Y (numpy.ndarray): Training outputs on the form (n, 2) where the innermost dimension is the true position at time t variance (float): Kernel amplitude/variance center (numpy.ndarray): Position used to calculate distance to each position in X. Used to sort the input data by distance. N (int): Number of samples to include in the model. If N is less than the number of samples in (X, Y), N samples are collected. If center != None, the N samples with shortest distance between center and X[:, :2] are used, otherwise random. """ assert X.shape[0] == Y.shape[0], "Shapes not matching" kernel = sgp.kernels.ConstantKernel(1.0) * sgp.kernels.RBF(length_scale=[1000.0, 1000.0, 50.0, 50.0, 60.0]) \ + sgp.kernels.ConstantKernel(1.0) * sgp.kernels.RBF(length_scale=[1.0, 1.0, 1.0, 1.0, 1.0]) \ + sgp.kernels.WhiteKernel(1) Y = Y[:, :2] self.y_mean = Y.mean(axis=0) self.y_scale = Y.std(axis=0) self.gp = sgp.GaussianProcessRegressor( kernel=kernel, n_restarts_optimizer=10, ) self.gp.fit(X, (Y - self.y_mean) / self.y_scale)
def gausian_model(kern, xx, yy): model = gp.GaussianProcessRegressor(kernel=kern, alpha=noise_level, n_restarts_optimizer=10, normalize_y=True) model.fit(xx, yy) return model
def fit_gps(signals, length=None, samples=8, kernel=None, noise_tolerance=5, truncate=False): if kernel is None: kernel = ( sgp.kernels.ConstantKernel(1) * sgp.kernels.RBF(1e7, (1e6, 1e8)) + sgp.kernels.ConstantKernel(1) * sgp.kernels.RBF(1.5e6, (1e6, 1e7)) + sgp.kernels.ConstantKernel(.0001) * sgp.kernels.RBF(1.5e4, (1e4, 1e5))) gp = sgp.GaussianProcessRegressor(kernel=kernel, alpha=noise_tolerance, n_restarts_optimizer=12) if length is None: longest = max(max(x) for x, y in signals) else: longest = length fit_gp_to_length = partial(fit_gp, longest, gp, 2**samples, truncate) with Pool(cpu_count() - 1) as p: results = p.map(fit_gp_to_length, signals) return zip(*results)
def __init__(self, configs, pred_model, datahandler, random_search=False, param_range=[1, 30], num_iterations=10, init_params=None, alpha=1e-5, epsilon=1e-7): self.configs = configs self.pred_model = pred_model self.datahandler = datahandler self.param_range = np.array(param_range) self.num_iterations = num_iterations self.random_search = random_search self.alpha = alpha self.epsilon = epsilon if init_params is not None: self.xp = np.array(init_params[0]) self.yp = np.array(init_params[1]) else: self.init_params = None self.kernel = Matern() self.gp = gp.GaussianProcessRegressor(kernel=self.kernel, alpha=alpha, n_restarts_optimizer=10, normalize_y=True)
def gpr_forecast(columns, df_in, df_forecast, df_out): X_train = df_in[columns] y_train = df_out X_test = df_forecast[columns] # normalise the inputs sc_x = StandardScaler() sc_y = StandardScaler() X_train = sc_x.fit_transform(X_train.values.astype(np.float32)) y_train = sc_y.fit_transform( y_train.values.astype(np.float32).reshape(-1, 1)) # normalise the inputs (using same max as for the model) X_test = sc_x.transform(X_test.values.astype(np.float32)) kernel = gp.kernels.ConstantKernel(1.0, (1e-1, 1e3)) * gp.kernels.RBF( 10.0, (1e-3, 1e8)) model = gp.GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10, alpha=0.1, normalize_y=False, random_state=0) model.fit(X_train, y_train) y_pred, std = model.predict(X_test, return_std=True) y_pred = y_pred.reshape(len(X_test), ) y_pred = sc_y.inverse_transform(y_pred) return y_pred