def EI(self): """ construct a GP model for scalarized output data applying EI for this model """ kernel = GPy.kern.RBF(self.x_train.shape[1]) self.model = GPy.models.GPRegression(self.x_train, self.f_theta[:, None], kernel=kernel, normalizer=None) self.model['.*Gaussian_noise.variance'].constrain_fixed(1.0e-2) self.model['.*rbf.variance'].constrain_fixed(1.0) #lengthscaleのboundを決定 x_dist = distance.cdist(self.x_train, self.x_train) median = np.median(x_dist) if median == 0: lower = 1.0e-3 upper = 100 else: lower = 1.0e-3 * median upper = 100 * median self.model['.*rbf.lengthscale'].constrain_bounded(lower, upper) self.model.optimize_restarts() #停止条件の計算 array_bounds = np.array(self.x_bounds) max_bound = np.argmax(array_bounds[:, 0] - array_bounds[:, 1]) terminate_vol = (0.1**self.x_train.shape[1]) / ( array_bounds[max_bound, 1] - array_bounds[max_bound, 0]) res = minimize(self.obj, bounds=self.x_bounds, algmethod=1, volper=terminate_vol) return res
def __init__(self, noise_var, seed=1): self.dim = 2 self.bounds = [[-5, 5], [-5, 5]] self.lengthscale_bound = [[0, 5]] super().__init__(self.dim, self.bounds, noise_var, seed) res = minimize(self.value, self.bounds, maxf=self.dim * 1000, algmethod=1) self.x_opt = res['x'] self.y_opt = -self.value(self.x_opt)
def test_minimize(): # basic test bounds = [(-10, 10) for i in range(4)] def func(x): x -= np.array([-1, 2, -4, 3]) return np.dot(x, x) res = minimize(func, bounds) npt.assert_allclose(res.x, np.array([-1, 2, -4, 3]), atol=0.1) # test with function not defined everywhere def func(x): if np.sum(np.abs(x)) > 20: raise Exception("func not defined") x -= np.array([-1, 2, -4, 3]) return np.dot(x, x) res = minimize(func, bounds) npt.assert_allclose(res.x, np.array([-1, 2, -4, 3]), atol=0.1)
def next_point(data,trans): num_fidelities = data['num_fidelities'] multi_fid_values = data['multi_fidelity_params'] bounds = trans.get_bounds() if len(data['data_points']) == 0: first_point = (bounds[:,1]-bounds[:,0])/2 + bounds[:,0] first_fidelity = 0 return first_point,first_fidelity regressors = [] for fidelity in range(num_fidelities): reg = sklearn.gaussian_process.GaussianProcessRegressor( kernel=sklearn.gaussian_process.kernels.RBF(length_scale=1.0),# length scales get handled in data preprocessing alpha=data['guassian_params']['noise'], optimizer=None ) ys,xs = parse_data(data,trans,fidelity) if len(ys) > 0: reg.fit(xs,ys) regressors.append(reg) t = len(data['data_points']) d = len(data['data_points'][0]['data']) beta = 0.2*math.log(t+1)*d #standard formula for beta zetas = multi_fid_values['err_bounds'] + [0.0] def neg_upper_confidence_bound(x): x = np.asarray(x) if len(x.shape) == 1: x = np.stack([x]) ucbs = [] for zeta,reg in zip(zetas,regressors): mean,stdev = reg.predict(x, return_std=True) ucbs.append(mean + stdev * beta + zeta) true_ucb = min(ucbs) return -true_ucb print(bounds) #print("bounds") #print(upper_confidence_bound(np.asarray([[0.00617284, 0.48765432]]))) min_val = scipydirect.minimize(neg_upper_confidence_bound,bounds) xval = min_val.x acc_targets = multi_fid_values['accuracy_targets']+[0.0] out_fid_level = num_fidelities-1# defaults to highest fidelity function for fid_level,(acc,reg) in enumerate(zip(acc_targets,regressors)): mean,stdev = reg.predict([min_val.x], return_std=True) if stdev*beta > acc: out_fid_level = fid_level break yval = -neg_upper_confidence_bound([xval]) return xval,yval,out_fid_level
def _optimize(self) -> Tuple[np.ndarray, np.ndarray]: def objective(x): return self.acquisition_function(x.reshape(1, -1)) res = minimize( objective, bounds=list(zip(self.bounds.lowers, self.bounds.uppers)), **self.direct_kwargs ) x_min = res.x f_min = res.fun return np.array([x_min]), np.array([f_min])
def __init__(self, seed=1): self.dim = 1 self.bounds = [[-3, 3]] self.y_bounds = [-2, 2] super().__init__(self.dim, self.bounds, seed) self.fit() self.min, self.max = self.get_min_max() res = minimize(self.value_std, self.bounds, maxf=self.dim * 1000, algmethod=1) self.x_opt = res['x'][0] self.y_opt = -self.value_std(self.x_opt)
def direct_minimize(acq_function, bounds, return_best_only=True, **kwargs): def obj(x: np.ndarray): if x.ndim == 1: x = x[None, :] x = torch.tensor(x).double().unsqueeze(-2) y = acq_function(x) y = float(y.view(-1).item()) return y res = minimize(obj, bounds.T) return torch.tensor(res.x).float().unsqueeze(0), torch.tensor( res.fun).float().unsqueeze(0)
def maximize(self, model_predict: callable, lower_bound: np.ndarray, upper_bound: np.ndarray): bound = [] dim = len(lower_bound) for i in range(dim): bound.append((lower_bound[i], upper_bound[i])) def acquisition_curve(x: float): _, uncertainty = model_predict(x[None]) return -uncertainty[:, None] res = minimize(acquisition_curve, bound) print("Selected point", res.x, res.fun) # x = np.atleast_2d(np.linspace(lower_bound, upper_bound, 100)) # _, u = model_predict(x) # print("Other vals = ", np.max(u)) return res.x, res.fun
def calc_smsego(self): """ optimize SMSego Returns ------- res : res result of optimization by DIRECT """ #現時点での獲得点が作るパレート超体積を計算 # print(self.x_bounds) # self.MOGPI = MOGPI # res = obj(np.array([1.0])) #停止条件の計算 array_bounds = np.array(self.x_bounds) max_bound = np.argmax(array_bounds[:,0] - array_bounds[:,1]) terminate_vol = (0.1 ** self.x_train.shape[1]) / (array_bounds[max_bound, 1] - array_bounds[max_bound, 0]) res = minimize(self.obj, bounds = self.x_bounds,algmethod=1,volper = terminate_vol) return res
def calc_ieipv(self, MOGPI): """ obtain the results optimize IEIPV Parameters ---------- MOGPI : MultiOutputGPIndep Gaussian Process Regression model for each objective function Returns ------- res : res result of optimization by DIRECT """ #cellの作成 v, w = Create_vw.create_vw(self.y_train, self.v_ref, self.w_ref) def obj(x): if np.any(np.all(self.x_train == x, axis=1)): return 1.0e5 else: # mean, var = MTGPR.multitaskGP_predict(np.atleast_2d(x)) mean, var = MOGPI.predict_one(x) alpha = (mean - v) / np.sqrt(var) beta = (mean - w) / np.sqrt(var) ieipv_each_cell = var * ( (norm.pdf(beta) - norm.pdf(alpha)) + beta * (norm.cdf(beta) - norm.cdf(alpha))) ieipv = (-1) * np.sum(np.prod(ieipv_each_cell, axis=1)) return ieipv #停止条件の計算 array_bounds = np.array(self.x_bounds) max_bound = np.argmax(array_bounds[:, 0] - array_bounds[:, 1]) terminate_vol = (0.1**self.x_train.shape[1]) / ( array_bounds[max_bound, 1] - array_bounds[max_bound, 0]) res = minimize(obj, bounds=self.x_bounds, algmethod=1, volper=terminate_vol) # print(obj([1])) return res
def fit(self, X_train, y_train, noise_var=None, n_iter=8, decompo=None, verbose=True): if self.normalize_X: self.X_train = (X_train - self.lowBounds) / (self.highBounds - self.lowBounds) else: self.X_train = X_train if self.normalize_y: self.mean_y_train = y_train.mean() self.std_y_train = y_train.std() self.y_train = (y_train - self.mean_y_train) / self.std_y_train else: self.y_train = y_train self.nbOfSamples = self.X_train.shape[0] if decompo is None: decompo = self.decompo.copy() if noise_var is None: noise_var = self.alpha tempListOfLogLik = [] tempListOfTheta = [] # Maximize the log-likelihood to find the shared hyperparameter res = scipydirect.minimize(lambda x: -self.loglik(np.exp(x), self.X_train, self.y_train, noise_var, decompo), bounds=np.log([[1e-5,1e5] for i in range(2)]), maxT=n_iter) if verbose: print(res) sol = res.x self.kernel.sigma = np.exp(sol[0]) self.kernel.lengthscale = np.exp(sol[1]) self.K_w_noise = noise_var * np.eye(self.nbOfSamples) for i in range(len(decompo)): self.K_w_noise += self.kernel.compute(self.X_train[:,decompo[i]],self.X_train[:,decompo[i]]) self.L_ = cholesky(self.K_w_noise, lower=True) self.alpha_ = cho_solve((self.L_,True), self.y_train)
def optimize_acq_f(self, n_iter=50, method = "LBFGS"): # optimization of aquisition function to get next query point x def obj_LBFGS(x): return -self.acq_f(x) x_tries = np.random.uniform(self.bounds[0, :], self.bounds[1, :], size=(10000, self.bounds.shape[1])) x_seeds = np.random.uniform(self.bounds[0, :], self.bounds[1, :], size=(n_iter, self.bounds.shape[1])) ys = -obj_LBFGS(x_tries) x_max = x_tries[ys.argmax()].reshape((1, -1)) max_acq = ys.max() if(method == "LBFGS"): for x_try in x_seeds: # Find the minimum of minus the acquisition function res = minimize(obj_LBFGS, x_try.reshape(1, -1), bounds=self.reformat_bounds(self.bounds), method="L-BFGS-B") # See if success if not res.success: continue # Store it if better than previous minimum(maximum). if max_acq is None or -res.fun[0] > max_acq: x_max = res.x max_acq = -res.fun[0] elif(method == "DIRECT"): ys = -obj_LBFGS(x_tries) x_max = x_tries[ys.argmax()].reshape((1, -1)) max_acq = ys.max() x = scipydirect.minimize(obj_LBFGS, self.reformat_bounds(self.bounds)).x acq = -obj_LBFGS(x)[0,0] if (acq > max_acq): x_max = x else: raise NotImplementedError return np.clip(x_max, self.bounds[0, :], self.bounds[1, :]).reshape((1, -1))
paramscomb = params_combination((aenvs, pienvs, maxfs, deltatols)) niter = int(niter) nburnin = int(nburnin) if parametercheck(datadir, sys.argv, paramscomb, nbatch): njob = int(sys.argv[1]) data = [] for i in progressbar(range(nbatch)): n = (njob - 1) * nbatch + i aenv, pienv, maxf, deltatol = paramscomb[n] if disp: print paramscomb[n] args = lambda_, mus, cup, aenv, pienv, niter, nburnin bounds = np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]) res1 = scipydirect.minimize(minus(evolimmune.Lambda_pq), maxf=maxf, args=args, bounds=bounds, disp=disp) if disp: print 'results of first phase optimization', res1 res2 = noisyopt.minimize(minus(evolimmune.Lambda_pq), res1.x, scaling=(1.0, 1.0, 5.0, 1.0), args=args, bounds=bounds, deltainit=deltainit, deltatol=deltatol, alpha=alpha, feps=feps, errorcontrol=True, paired=True,
def runNVOptimize(): global env, countfigure starttime = time.time() res = [] locreslist = [] if (optimizer == 0 or optimizer == 2): numsteps = env.totalsteps env_fn = lambda: env hidden_sizes = np.ones( circuitdepth) * nneurons #size of neural network ac_kwargs = dict(hidden_sizes=hidden_sizes, activation=tf.nn.relu) logger_kwargs = dict( output_dir=output_dir + dataset + "/", exp_name=dataset) #this logger is not used, we have our own if (optimizer == 0): #Use PPO with tf.Graph().as_default(): ppo_tf1(env_fn=env_fn, ac_kwargs=ac_kwargs, steps_per_epoch=(numsteps) * iterations_per_epoch, pi_lr=pi_lr, vf_lr=vf_lr, train_pi_iters=iterations_per_epoch, train_v_iters=iterations_per_epoch, epochs=big_epochs, lam=0.99, logger_kwargs=logger_kwargs, target_kl=100, save_freq=100, clip_ratio=clip_ratio) elif (optimizer == 2): #Use SAC, does not work properly yet with tf.Graph().as_default(): startsteps = 10000 sac_tf1(env_fn, ac_kwargs=ac_kwargs, seed=0, steps_per_epoch=(numsteps) * iterations_per_epoch, epochs=big_epochs, replay_size=1000000, gamma=0.99, polyak=0.995, lr=sac_lr, alpha=0.05, batch_size=500, start_steps=startsteps, max_ep_len=1000, logger_kwargs=logger_kwargs, save_freq=100) tf.reset_default_graph() elif (optimizer == 1): #Use DIRECCT algorithm from scipydirect import minimize print("start DIRECT") bounds = np.transpose([ env.action_space.low[0] * np.ones(env.action_spaceLength * env.totalsteps), env.action_space.high[0] * np.ones(env.totalsteps * env.action_spaceLength) ]) def gymWrapper( x): #Wrap gym environment into format understood by optimizer env.reset() actions = np.reshape(x, [env.totalsteps, env.action_spaceLength]) for i in range(np.shape(actions)[0]): env.step(actions[i]) return -env.fidel_val res = minimize(gymWrapper, bounds, fglobal=-1, maxf=maxiterations, algmethod=1) actions = np.reshape(res["x"], [env.totalsteps, env.action_spaceLength]) print(res) print('DIRECT result', -res["fun"], actions) elif (optimizer == 3): #Use nealder-mead steadytime = False #Keep time per bin constant, but can vary time overall if (len(t_var) > 0 and steadytime == True): actionspace = (env.action_spaceLength - 1) * env.totalsteps + 1 else: actionspace = env.action_spaceLength * env.totalsteps #action is bounded betwen -0.5 and 0.5 bounds = np.transpose([ env.action_space.low[0] * np.ones(actionspace), env.action_space.high[0] * np.ones(actionspace) ]) print("start scipy optimize") def reshapeActions(x): if (len(t_var) > 0 and steadytime == True): xtime = x[0] #time per bin, mapped between -0.5 and 0.5 xrest = np.reshape( x[1:], [env.totalsteps, (env.action_spaceLength - 1)]) actions = np.zeros([env.totalsteps, env.action_spaceLength]) for i in range(env.totalsteps): actions[i] = list(xrest[i]) + [xtime] else: actions = np.reshape(x, [env.totalsteps, env.action_spaceLength]) return actions def gymWrapper(x): env.reset() actions = reshapeActions(x) totalreward = env.fidel_val for i in range(np.shape(actions)[0]): _, reward, done, _ = env.step(actions[i]) totalreward += reward #totalreward=env.fidel_val return -totalreward for i in range( repeatOptimize ): #Repeat optimization repeatOptimize times, with random initial state x0 = (np.random.rand(actionspace) - 0.5) * 0.5 #Random initial parameters res = sp.optimize.minimize(gymWrapper, x0, method="Nelder-Mead", bounds=bounds, options={ "maxiter": maxiterations, "adaptive": True }) actions = reshapeActions(res["x"]) print(res) print('scipy result', -res["fun"], actions) locreslist.append(res) if (-res["fun"] > 0.99): break print(dataset) #Get results from logger in gym environment finalfidelresults = [env.logger[i][0] for i in range(len(env.logger))] #Fidelity at end #fidelresults=[env.logger[i][1] for i in range(len(env.logger))] penaltyresults = [ np.sum(env.logger[i][3]) for i in range(len(env.logger)) ] #Penalty for going out of bounds, decreases to zero over training rewardresults = [ finalfidelresults[i] - penaltyresults[i] for i in range(len(env.logger)) ] #Reward including penalty, e..g. reward=fidelity-penalty omegaresults = [ env.logger[i][2].flatten() for i in range(len(env.logger)) ] #Driving parameters found during training argmax = np.argmax(rewardresults) #Get best result print(rewardresults[argmax], omegaresults[argmax]) #Re/run best result found and store it in variable maxdata env.reset() fidelmaxlist = [] #Best fidelity found fidelmaxlist.append(env.fidel_val) omegamax = np.reshape( omegaresults[argmax], [env.totalsteps, env.action_spaceLength] ) #Best driving parameters found, parameters are mapped between -0.5 and +0.5 for i in range(np.shape(omegamax) [0]): #Run system with driving parameters and save fidelity env.step(omegamax[i]) fidelmaxlist.append(env.fidel_val) tlist = env.tlist #np.linspace(0,t_max,num=N_bins+1) #Time #tlistOmega=env.tlist[1:]#np.linspace(0,t_max,num=N_bins) actualparammax = env.logger[argmax][6] #driving parameters in real values maxdata = [ finalfidelresults[argmax], penaltyresults[argmax], omegaresults[argmax], tlist, actualparammax ] totaltime = time.time() - starttime print(time.time() - starttime) #Total runtime return env.logger, totaltime, maxdata, locreslist #Return result
def twostage_optimization(func, args, kwargs): res1 = scipydirect.minimize(func, args=args, **kwargs) return noisyopt.minimize(func, res1.x, args=args, **kwargs)
def obj(x): """Six-hump camelback function""" x1 = x[0] x2 = x[1] f = (4 - 2.1 * (x1 * x1) + (x1 * x1 * x1 * x1) / 3.0) * (x1 * x1) + x1 * x2 + (-4 + 4 * (x2 * x2)) * (x2 * x2) return f bounds = [(-3, 3), (-2, 2)] res = minimize(obj, bounds) # # Plot the results. # fig = plt.figure() ax = fig.add_subplot(111, projection='3d') x = res.x X, Y = np.mgrid[x[0] - 1:x[0] + 1:50j, x[1] - 1:x[1] + 1:50j] Z = np.zeros_like(X) for i in range(X.size): Z.ravel()[i] = obj([X.flatten()[i], Y.flatten()[i]]) ax.plot_wireframe(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet)
def test_minimize(): bounds = [(-10, 10) for i in range(4)] res = minimize(func, bounds) npt.assert_allclose(res.x, np.array([-1, 2, -4, 3]), atol=0.1)
def opt_x(self): res = minimize(self.mu_minus, self.f.bounds, maxf=self.f.dim * 1000, algmethod=1) return res['x']
def twostage_optimization(func, args, kwargs): res1 = scipydirect.minimize(func, args=args, **kwargs) return noisyopt.minimize(func, res1.x, args=args, **kwargs)
def fit(self): bound = self.f.lengthscale_bound res = minimize(self.marginal_liklihood, bound, maxf=1000, algmethod=1) lengthscale = res['x'][0] self.kernel.lengthscale = lengthscale
def _optimise_acq_func(self, acq, max_or_min='max', acq_opt_params=None): """ Run the chosen optimisation procedure """ if self.verbose: print(f"Optimising acquisition function ({max_or_min})") if acq_opt_params is None: acq_opt_params = self.acq_opt_params if max_or_min == 'max': def optimiser_func(x): return -acq.evaluate(np.atleast_2d(x)) elif max_or_min == 'min': def optimiser_func(x): return acq.evaluate(np.atleast_2d(x)) else: raise NotImplementedError if acq_opt_params['method'] == 'direct': n_direct_evals = acq_opt_params['n_direct_evals'] res = scipydirect.minimize(optimiser_func, self.bounds, maxf=n_direct_evals) elif acq_opt_params['method'] == 'multigrad': num_restarts = acq_opt_params['num_restarts'] if 'minimize_options' in acq_opt_params.keys(): minimize_options = acq_opt_params['minimize_options'] else: minimize_options = None res = minimize_with_restarts(optimiser_func, self.bounds, num_restarts=num_restarts, hard_bounds=self.bounds, minimize_options=minimize_options, verbose=False) elif acq_opt_params['method'] == 'samplegrad': if 'minimize_options' in acq_opt_params.keys(): minimize_options = acq_opt_params['minimize_options'] else: minimize_options = None if 'num_samples' in acq_opt_params.keys(): num_samples = acq_opt_params['num_samples'] else: num_samples = 1000 if 'num_local' in acq_opt_params.keys(): num_local = acq_opt_params['num_local'] else: num_local = 5 if 'num_chunks' in acq_opt_params.keys(): num_chunks = acq_opt_params['num_chunks'] else: num_chunks = 5 if 'evaluate_sequentially' in acq_opt_params.keys(): evaluate_sequentially = \ acq_opt_params['evaluate_sequentially'] else: evaluate_sequentially = True res = sample_then_minimize( optimiser_func, self.bounds, num_samples=num_samples, num_local=num_local, num_chunks=num_chunks, minimize_options=minimize_options, evaluate_sequentially=evaluate_sequentially, verbose=False) else: raise NotImplementedError best_x = np.atleast_2d(res.x) # Return the correct value for the acquisition function depending on # whether we minimized or maximized if max_or_min == 'max': best_eval = best_x, -res.fun elif max_or_min == 'min': best_eval = best_x, res.fun else: raise NotImplementedError return best_eval
def calc_next_point(self): self._update_surface_model() # 1) self._update_acquisition_function() # 2) af = lambda x: -1 * self.acquisition_function(x) # 3) A next_point = minimize(af, self.bounds) # 3) B return next_point
datadir = 'data/' paramscomb = params_combination((aenvs, pienvs, maxfs, deltatols)) niter = int(niter) nburnin = int(nburnin) if parametercheck(datadir, sys.argv, paramscomb, nbatch): njob = int(sys.argv[1]) data = [] for i in progressbar(range(nbatch)): n = (njob-1) * nbatch + i aenv, pienv, maxf, deltatol = paramscomb[n] if disp: print paramscomb[n] args = lambda_, mus, cup, aenv, pienv, niter, nburnin bounds = np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]) res1 = scipydirect.minimize(minus(evolimmune.Lambda_pq), maxf=maxf, args=args, bounds=bounds, disp=disp) if disp: print 'results of first phase optimization', res1 res2 = noisyopt.minimize(minus(evolimmune.Lambda_pq), res1.x, scaling=(1.0, 1.0, 5.0, 1.0), args=args, bounds=bounds, deltainit=deltainit, deltatol=deltatol, alpha=alpha, feps=feps, errorcontrol=True, paired=True, disp=disp) res2.x[res2.free] = np.nan p, q, epsilon, pup = res2.x
def _get_y_min(self): """ Get y_min for EI computation Returns smallest y_min of the model. Can change this to evaluate lowest y over domain later. """ if self.verbose: print("Finding y_min") def optimiser_func(x): return self.surrogate.predict(np.atleast_2d(x))[0].flatten() if self.y_min_opt_params['method'] == 'standard': idx = np.argmin(self.surrogate.Y_raw) x_min = self.surrogate.X[idx] y_min = self.surrogate.Y_raw[idx] elif self.y_min_opt_params['method'] == 'direct': def optimiser_func(x): return self.surrogate.predict(np.array([x]))[0] n_direct_evals = self.y_min_opt_params['n_direct_evals'] res = scipydirect.minimize(optimiser_func, self.bounds, maxf=n_direct_evals) x_min = res.x y_min = res.fun elif self.y_min_opt_params['method'] == 'multigrad': num_restarts = self.y_min_opt_params['num_restarts'] res = minimize_with_restarts(optimiser_func, self.bounds, num_restarts=num_restarts, verbose=False) x_min = res.x y_min = res.fun elif self.y_min_opt_params['method'] == 'samplegrad': op = self.y_min_opt_params if 'minimize_options' in op.keys(): minimize_options = op['minimize_options'] else: minimize_options = None if 'num_samples' in op.keys(): num_samples = op['num_samples'] else: num_samples = 1000 if 'num_local' in op.keys(): num_local = op['num_local'] else: num_local = 5 if 'evaluate_sequentially' in op.keys(): evaluate_sequentially = \ op['evaluate_sequentially'] else: evaluate_sequentially = False res = sample_then_minimize( optimiser_func, self.bounds, num_samples=num_samples, num_local=num_local, minimize_options=minimize_options, evaluate_sequentially=evaluate_sequentially, extra_locs=self.surrogate.X, verbose=False) x_min = res.x y_min = res.fun else: raise NotImplementedError _, var_at_y_min = self.surrogate.predict(np.atleast_2d(x_min)) if self.verbose: print(f"Current y_min = {y_min}") return x_min, y_min.item(), var_at_y_min.item()
from mpl_toolkits.mplot3d import axes3d import matplotlib.pyplot as plt from matplotlib import cm import os def obj(x): """Six-hump camelback function""" x1 = x[0] x2 = x[1] f = (4 - 2.1*(x1*x1) + (x1*x1*x1*x1)/3.0)*(x1*x1) + x1*x2 + (-4 + 4*(x2*x2))*(x2*x2) return f bounds = [(-3, 3), (-2, 2)] res = minimize(obj, bounds) # # Plot the results. # fig = plt.figure() ax = fig.add_subplot(111, projection='3d') x = res.x X, Y = np.mgrid[x[0]-1:x[0]+1:50j, x[1]-1:x[1]+1:50j] Z = np.zeros_like(X) for i in range(X.size): Z.ravel()[i] = obj([X.flatten()[i], Y.flatten()[i]]) ax.plot_wireframe(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet)
def optimize( self, sample_x: np.array, sample_y: np.array ) -> Tuple[np.array, np.array, np.array, np.array, np.array, np.array, np.array, np.array]: """finds the optima of the acquisition function. For that defines a internal function that evaluates the acquisition function and returns it's negative value. Then executes the scipydirect minimization algorithm to find the maxima of the acquisition function. While doing this keeps track of evaluated points :param sample_x: input of samples :param sample_y: outputs of samples :return: input value with maximal acquisition value, mu value for point with maximal acquisition value, sigma value for point with maximal acquisition value, maximal acquisition function value, all mu estimates, all sigma estimates, all acq. values evaluated, all input samples for the acquisition function """ incumbent = np.max(sample_y) incumbent_x = sample_x[np.argmax(sample_y)] mu = [] sigma = [] acq = [] xs = [] def func(x: np.array, inc: float, mu_f: np.array, sigma_f: np.array, acq_f: np.array, x_f: np.array) -> float: """function that is internally used as it is passed to the minimize takes input and calculates the respective acquisition value and negates it as minimize is used but the original problem is maximization :param x: input value :param inc: incumbent :param mu_f: list of mu values to append mu-prediction to for persistence :param sigma_f: list of sigma values to append sigma-prediction to for persistence :param acq_f: list of acquisition function values to append for to persistence :param x_f: list of acquisition function sample inputs to append to for persistence :return: """ m, s = self.context.estimator.regress(np.array([x])) mu_f.append(m) sigma_f.append(s) a = self.context.acq.evaluate(m, s, inc) acq_f.append(a) x_f.append(x) if len(x_f) % 200 == 0: gc.collect() return -a old_stdout = sys.stdout # backup current stdout sys.stdout = open(os.devnull, "w") result = minimize(func, args=(incumbent, mu, sigma, acq, xs), bounds=np.vstack((self.lower_search_bounds, self.upper_search_bounds)).T, maxT=100, maxf=5000) sys.stdout = old_stdout # reset old stdout new_sample_x = result.x new_sample_mu, new_sample_sigma = self.context.estimator.regress( np.array([new_sample_x])) new_sample_acq = result.fun return new_sample_x, new_sample_mu, new_sample_sigma, new_sample_acq, mu, sigma, acq, xs