def optimize(self, f, maximize=True, pmap=map): seed = self.seed if self.seed else random.randint(0, 9999) params = {'n_iterations': self.num_evals, 'random_seed': seed, 'n_iter_relearn': 3, 'verbose_level': 0} n_dimensions = len(self.lb) print('lb %s' % str(self.lb)) print('ub %s' % str(self.ub)) if maximize: def obj(args): kwargs = dict([(k, v) for k, v in zip(sorted(self.bounds.keys()), args)]) return -f(**kwargs) else: def obj(args): kwargs = dict([(k, v) for k, v in zip(sorted(self.bounds.keys()), args)]) return f(**kwargs) mvalue, x_out, error = bayesopt.optimize(obj, n_dimensions, self.lb, self.ub, params) best = dict([(k, v) for k, v in zip(sorted(self.bounds.keys()), x_out)]) return best, None
def optimize(self, f, maximize=True, pmap=map): seed = self.seed if self.seed else random.randint(0, 9999) params = { 'n_iterations': self.num_evals, 'random_seed': seed, 'n_iter_relearn': 3, 'verbose_level': 0 } n_dimensions = len(self.lb) print('lb %s' % str(self.lb)) print('ub %s' % str(self.ub)) if maximize: def obj(args): kwargs = dict([ (k, v) for k, v in zip(sorted(self.bounds.keys()), args) ]) return -f(**kwargs) else: def obj(args): kwargs = dict([ (k, v) for k, v in zip(sorted(self.bounds.keys()), args) ]) return f(**kwargs) mvalue, x_out, error = bayesopt.optimize(obj, n_dimensions, self.lb, self.ub, params) best = dict([(k, v) for k, v in zip(sorted(self.bounds.keys()), x_out)]) return best, None
def tune(): """Tunes hyperparameters of a feed forward net using Bayesian Optimization. Returns: mvalue: float. Best value of the cost function found using BayesOpt. x_out: 1D array. Best hyper-parameters found. """ params = {} params['n_iterations'] = 50 params['n_iter_relearn'] = 1 params['n_init_samples'] = 2 print "*** Model Selection with BayesOpt ***" n = 6 # n dimensions # params: #layer, width, dropout, nonlinearity, l1_rate, l2_rate lb = np.array([1 , 10 , 0., 0., 0., 0.]) ub = np.array([10, 500, 1., 1., 0., 0.]) start = clock() mvalue, x_out, _ = bayesopt.optimize(cost_func, n, lb, ub, params) # Usage of BayesOpt with discrete set of values for hyper-parameters. #layers = [1, 3, 5, 7, 9, 10] #hsizes = [10, 50, 100, 150, 200, 300] #drates = [0.0, .1, .3, .5, .7, .9] #x_set = np.array([[layers, hsizes, drates], dtype=float).transpose() #mvalue, x_out, _ = bayesopt.optimize_discrete(cost_func, x_set, params) print "Result", mvalue, "at", x_out print "Running time:", clock() - start, "seconds" return mvalue, x_out
def tune(i, nonlin): params = {} params['n_iterations'] = 300 params['n_iter_relearn'] = 1 params['n_init_samples'] = 2 print "*** Model Selection with BayesOpt ***" n = 6 # n dimensions if (nonlin == theano.tensor.nnet.relu): lb = np.array([1, 10, .0005, .0009, 0, i]) ub = np.array([5, 300, .00121, .001, .5, i]) else: lb = np.array([1, 10, .0005, .0005, 0, i]) ub = np.array([5, 300, .1, .1, .5, i]) start = clock() mvalue, x_out, error = bayesopt.optimize(bo_costfunc, n, lb, ub, params) #mvalue, x_out, error = bayesopt.optimize_discrete(bo_costfunc, x_set, params) print "Result", mvalue, "at", x_out print "Running time:", clock() - start, "seconds" return mvalue, x_out, error
# to a default value. params = {} params['n_iterations'] = 50 params['n_init_samples'] = 20 params['crit_name'] = "cSum(cEI,cDistance)" params['crit_params'] = [1, 0.5] params['kernel_name'] = "kMaternISO3" print "Callback implementation" n = 2 # n dimensions lb = np.zeros((n, )) ub = np.ones((n, )) start = clock() mvalue, x_out, error = bayesopt.optimize(testfunc, n, lb, ub, params) print "Result", x_out print "Seconds", clock() - start print "OO implementation" bo_test = BayesOptTest(n) bo_test.parameters = params bo_test.lower_bound = lb bo_test.upper_bound = ub start = clock() mvalue, x_out, error = bo_test.optimize() print "Result", x_out print "Seconds", clock() - start
#print "target", target e = quad(x, target) return e # Initialize the parameters by default params = {} #bayesopt.initialize_params() # We decided to change some of them params['n_init_samples'] = 30 params['n_iter_relearn'] = 20 params['noise'] = 1e-10 params['kernel_name'] = "kMaternISO5" params['kernel_hp_mean'] = [1] params['kernel_hp_std'] = [5] params['surr_name'] = "sStudentTProcessNIG" #params['crit_name'] = "cMI" dim = 20 lb = np.ones((dim, )) * 0 ub = np.ones((dim, )) * 20 mvalue, x_out, error = bayesopt.optimize(func, dim, lb, ub, params) print "Result", mvalue, x_out print "Global optimal", 0, np.arange(1, 1 + dim) print "Y Gap", mvalue print "X Gap", math.sqrt(mvalue * dim)
def optimize(self): min_val, x_out, error = bo.optimize(self.evaluateSample, self.n_dim, self.lb, self.ub, self.params) return min_val, x_out, error
# to a default value. params = {} params['n_iterations'] = 50 params['n_init_samples'] = 20 params['crit_name'] = "cSum(cEI,cDistance)" params['crit_params'] = [1, 0.5] params['kernel_name'] = "kMaternISO3" print "Callback implementation" n = 2 # n dimensions lb = np.zeros((n,)) ub = np.ones((n,)) start = clock() mvalue, x_out, error = bayesopt.optimize(testfunc, n, lb, ub, params) print "Result", x_out print "Seconds", clock() - start print "OO implementation" bo_test = BayesOptTest(n) bo_test.parameters = params bo_test.lower_bound = lb bo_test.upper_bound = ub start = clock() mvalue, x_out, error = bo_test.optimize() print "Result", x_out
params = {} #bayesopt.initialize_params() # We decided to change some of them params['n_iterations'] = 200 params['n_init_samples'] = 5 params['n_iter_relearn'] = 5 # params['l_type'] = "mcmc" params['noise'] = 1 params['kernel_name'] = "kMaternARD5" # params['kernel_hp_mean'] = [1] # params['kernel_hp_std'] = [5] # params['surr_name'] = "sStudentTProcessNIG" # params['surr_name'] = "sStudentTProcessNIG" params['load_save_flag'] = 2 dim = 7 lb = np.ones((dim, )) * 0. ub = np.ones((dim, )) * 1. mvalue, x_out, error = bayesopt.optimize(compute_marginals, dim, lb, ub, params) params = np.array([ 3.0000, 0.0911, 0, 21.9868, 0, 22.3006, 0.2053, 0.7538, -1.4208, 0.8877, 1.0000, 0, 0, 0 ]) params = np.array([0.0911, 21.9868, 22.3006, 0.2053, 0.7538, -1.4208, 0.8877]) #python /Users/csmfindling/spearmint/spearmint/spearmint/main.py --driver=local --method=GPEIOptChooser config.pb
with open('/tmp/results.pkl', 'w') as f: data["kwargs"].append(kwargs) data["results"].append(result) pickle.dump(data, f) return result return wrapper if __name__ == '__main__': with open('/tmp/data.pkl', 'r') as f: context = pickle.load(f) objfun = context['objfun'] search = context['search'] typemap = context['typemap'] objfun = prepare_objfun(objfun, search) params = {} params['n_iterations'] = 150 # params['n_iter_relearn'] = 5 # configuration used throughout experiments # search={'logC': [-8, 1], 'logGamma': [-8, 1]} n = 2 # n dimensions lb = -8 * np.ones((n,)) ub = np.ones((n,)) mvalue, x_out, error = bayesopt.optimize(objfun, n, lb, ub, params) print('mvalue: %1.3f' % mvalue)
import traceback from bayesian_tools import evaluate_old, evaluate_MT_linear parser = argparse.ArgumentParser("") parser.add_argument('-d', '--ndim', type=int, required=True) parser.add_argument('--device', default="cpu") parser.add_argument('-n', '--norm', action="store_true") args = parser.parse_args() def evaluate(vec): #return -evaluate_old(vec) return -evaluate_MT_linear(vec, norm=args.norm, device=args.device) params = {} params['n_iterations'] = 1000 params['n_iter_relearn'] = 5 params['n_init_samples'] = 2 n = args.ndim # n dimensions lb = numpy.zeros((n, )) ub = numpy.ones((n, )) if __name__ == "__main__": start = clock() mvalue, x_out, error = bayesopt.optimize(evaluate, n, lb, ub, params) print("Result", mvalue, "at", x_out) print("Running time:", clock() - start, "seconds")
'edge.fused(flat-map, filter)-group-and-aggregate-prepare.queueSize', 'edge.group-and-aggregate-prepare-group-and-aggregate.queueSize', 'edge.group-and-aggregate-mapSink(counts).queueSize' ] # Function for testing. def run_pipeline(Xin): params = ['/usr/bin/java', '-cp', 'wordcount-1.0-SNAPSHOT.jar', 'com.hazelcast.jet.WordCount'] try: for i, x in enumerate(Xin.tolist()): params.append('%s=%d' % (options[i], x)) start_time = time.time() subprocess.call(params, stderr=DEVNULL) elapsed_time = time.time() - start_time return elapsed_time except Exception, err: traceback.print_exc() pass lower = np.array([1, 1, 1, 1, 1, 128, 128, 128, 128]).astype('double') upper = np.array([36, 36, 36, 36, 36, 4096, 4096, 4096, 4096]).astype('double') y_out, x_out, error = bayesopt.optimize(run_pipeline, len(options), lower, upper, {}) defaults = np.array([36, 36, 36, 36, 36, 1024, 1024, 1024, 1024]) print("Running with defaults: %s" % defaults) print(run_pipeline(defaults)) print("Running with best outcome %s" % x_out) print(run_pipeline(x_out))
def optimize(self): min_val, x_out, error = bo.optimize(self.evalfunc, self.n_dim, self.lower_bound, self.upper_bound, self.params) return min_val, x_out, error
def optimize(self): return bayesopt.optimize(self.train_valid, self.dim, self.lower_bound, self.upper_bound, self.hyperparams)
def run(self, problem): """Optimize the problem using your choice of Scipy optimizer. Args ---- problem : `Problem` Our parent `Problem`. """ # Metadata Setup self.metadata = create_local_meta(None, "BayesOpt") self.iter_count = 0 update_local_meta(self.metadata, (self.iter_count, )) # Initial Run with problem.root._dircontext: problem.root.solve_nonlinear(metadata=self.metadata) pmeta = self.get_desvar_metadata() self.params = list(pmeta) self.objs = list(self.get_objectives()) con_meta = self.get_constraint_metadata() self.cons = list(con_meta) self.con_cache = self.get_constraints() self.opt_settings['disp'] = self.options['disp'] bopt_params = {} bopt_params['n_iterations'] = self.options['n_iterations'] bopt_params['n_inner_iterations'] = self.options['n_inner_iterations'] bopt_params['n_iter_relearn'] = self.options['n_iter_relearn'] bopt_params['n_init_samples'] = self.options['n_init_samples'] bopt_params['noise'] = self.options['noise'] bopt_params['surr_name'] = self.options['surr_name'] # Size Problem nparam = 0 for param in itervalues(pmeta): nparam += param['size'] x_init = np.empty(nparam) i = 0 # Initial Parameters lower_bounds = [] upper_bounds = [] for name, val in iteritems(self.get_desvars()): size = pmeta[name]['size'] x_init[i:i + size] = val i += size # Bounds if our optimizer supports them meta_low = pmeta[name]['lower'] meta_high = pmeta[name]['upper'] for j in range(0, size): if isinstance(meta_low, np.ndarray): p_low = meta_low[j] else: p_low = meta_low if isinstance(meta_high, np.ndarray): p_high = meta_high[j] else: p_high = meta_high lower_bounds.append(p_low) upper_bounds.append(p_high) # optimize self._problem = problem min_value, xout, error = bayesopt.optimize(self._objfunc, len(lower_bounds), np.asarray(lower_bounds), np.asarray(upper_bounds), bopt_params) # Run one more iteration, at the computed minimum self._objfunc(xout) self._problem = None self.result = min_value # TODO: what is this supposed to return? self.exit_flag = 1 # TODO: handle optimization failure? if self.options['disp']: print('Optimization Complete') print('-' * 35)
''' listas = [] param_solution = [] n_experimentos = 5 function = fun.PushButton(headless_mode=True, variation=VARIATION) # Inicializacion # Coordenadas de la tarea avoid_obstacle # function.set_coords(coords=VARIATION) for i in range(n_experimentos): print(i) function.clean_lists() mvalue, x_out, error = bayesopt.optimize(function.push_button, n, lb, ub, params) print("Result", mvalue, "at", x_out) listas_optimizacion = function.return_lists() listas.append(listas_optimizacion) param_solution.append(x_out) pickle.dump( listas, open(TASK_DIR + "listas_bayesopt_" + TASK_NAME + "_" + VARIATION + ".p", "wb")) pickle.dump( param_solution, open(TASK_DIR + "solucion_bayesopt_" + TASK_NAME + "_" + VARIATION + ".p", "wb")) function.shutdown() # Apagado
target = np.arange(1, 1 + len(x)) target2 = np.ones(len(x)) * 10 # print "target", target e = quad(x, target) return e # Initialize the parameters by default params = bayesopt.initialize_params() # We decided to change some of them params["n_init_samples"] = 150 params["n_iter_relearn"] = 20 # params['noise'] = 0.01 params["kernel_name"] = "kMaternISO3" params["kernel_hp_mean"] = [1] params["kernel_hp_std"] = [5] params["surr_name"] = "sStudentTProcessNIG" dim = 20 lb = np.ones((dim,)) * 0 ub = np.ones((dim,)) * 20 mvalue, x_out, error = bayesopt.optimize(func, dim, lb, ub, params) print "Result", mvalue, x_out print "Global optimal", 0, np.arange(1, 1 + dim) print "Distance", math.sqrt(mvalue * dim)
with open('/tmp/results.pkl', 'w') as f: data["kwargs"].append(kwargs) data["results"].append(result) pickle.dump(data, f) return result return wrapper if __name__ == '__main__': with open('/tmp/data.pkl', 'r') as f: context = pickle.load(f) objfun = context['objfun'] search = context['search'] typemap = context['typemap'] objfun = prepare_objfun(objfun, search) params = {} params['n_iterations'] = 150 # params['n_iter_relearn'] = 5 # configuration used throughout experiments # search={'logC': [-8, 1], 'logGamma': [-8, 1]} n = 2 # n dimensions lb = -8 * np.ones((n, )) ub = np.ones((n, )) mvalue, x_out, error = bayesopt.optimize(objfun, n, lb, ub, params) print('mvalue: %1.3f' % mvalue)
import numpy as np import bayesopt as bo import RNN_train_wrapper as rtw # from bayesoptmodule import BayesOptDiscrete params = {} # params['n_iterations'] = 50 # params['n_iter_relearn'] = 5 # params['n_init_samples'] = 2 dim = 4 # n dimensions # lb = np.array([500.0,100.0,100.0,100.0]) # ub = np.array([2000.0,512.0,256.0,1000.0]) lb = np.ones((dim, )) * 0 ub = np.ones((dim, )) * 20 print "Callback implementation" mvalue, x_out, error = bo.optimize(rtw.wrapper, dim, lb, ub, params) print "Result", mvalue, "at", x_out