def run_hartmann6_benchmarks(D, rep, random_subspace=False): if D == 100: problem = hartmann6_100 elif D == 1000 and not random_subspace: problem = hartmann6_1000 elif D == 1000 and random_subspace: problem = hartmann6_random_subspace_1000 experiment, f = benchmark_minimize_callable( problem=problem, num_trials=200, method_name='cmaes', replication_index=rep, ) try: cma.fmin( objective_function=f, x0=[0.5] * D, sigma0=0.25, options={ 'bounds': [[0] * D, [1] * D], 'maxfevals': 200 }, ) except ValueError: pass # CMA-ES doesn't always terminate at exactly maxfevals rs_str = 'random_subspace_' if random_subspace else '' with open(f'results/hartmann6_{rs_str}{D}_cmaes_rep_{rep}.json', "w") as fout: json.dump(object_to_json(experiment), fout)
def launchCMAESForSpecificTargetSize(target_size, rs, save): ''' Run cmaes for a specific target size Input: -target_size, size of the target, float -setuFile, file of setup, string -save: do we use a previous Best.theta file? True = Yes, False = use current controller, None = random controller ''' print("Starting the CMAES Optimization for target " + str(target_size) + " !") foldername = rs.OPTIpath + str(target_size) + "/" if save: thetaname = foldername + rs.thetaFile copyRegressiontoCMAES(rs, rs.thetaFile, target_size) else: thetaname = foldername + "Best" #Initializes all the class used to generate trajectory exp = Experiments(rs, target_size, False, foldername, thetaname,rs.popsizeCmaes,rs.period) theta = exp.tm.controller.getTheta() thetaCMA = theta.flatten() #run the optimization (cmaes) cma.fmin(exp.runTrajectoriesCMAES, thetaCMA, rs.sigmaCmaes, options={'maxiter':rs.maxIterCmaes, 'popsize':rs.popsizeCmaes, 'CMA_diagonal':True, 'verb_log':50, 'verb_disp':1,'termination_callback':term()}) print("End of optimization for target " + str(target_size) + " !")
def run(self): if self._is_restart: x0 = '{lb} + ({delta})*(np.random.random({d}))'.format( lb=list(self._opts['bounds'][0]), delta=list( np.array(self._opts['bounds'][1]) - self._opts['bounds'][0]), d=self._dim_cma) res = cma.fmin(lambda x: self._fct(x[:self._dim]), x0, 0.25, self._opts, eval_initial_x=True, restarts=5, bipop=True) else: res = cma.fmin(lambda x: self._fct(x[:self._dim]), self._x0, 0.25, self._opts, eval_initial_x=True, restarts=0) x_opt = res[0][:self._dim] # index trick as 1D is not supported f_opt = res[1] num_fevals = res[3] # num of fevals used return x_opt, f_opt, num_fevals
def launchCMAESMissing(rs, save, gamma, point): ''' Run cmaes for a specific target size Input: -target_size, size of the target, float -setuFile, file of setup, string -save: do we use a previous Best.theta file? True = Yes, False = use current controller, None = random controller ''' rs.gamma = gamma/10.0 pos=point[0] x=point[1][0] y=point[1][1] target_size = point[2] print("Starting the CMAES Optimization for gamma = "+ str(gamma) + ",target " + str(target_size) + " for point "+ str(pos)+" !") foldername = rs.OPTIpathMissing + "gamma" + str(gamma) + "/"+str(target_size)+"/"+str(pos)+"/" thetaname = foldername + "Best" if save: checkIfFolderExists(foldername) copyfile(rs.OPTIpathMissing + "gamma" + str(gamma) + "/" + str(target_size)+"/" + "Best.theta",foldername + "Best.theta") elif save==None: thetaname=None #Initializes all the classes used to generate trajectory exp = Experiments(rs, target_size, False, foldername, thetaname,rs.popsizeCmaes,rs.period) theta = exp.tm.controller.getTheta() thetaCMA = theta.flatten() #run the optimization (cmaes) cma.fmin(partial(exp.runTrajectoriesCMAESOnePointMulti, x, y), thetaCMA, rs.sigmaCmaes, options={'maxiter':rs.maxIterCmaes, 'popsize':rs.popsizeCmaes, 'CMA_diagonal':True, 'verb_log':0, 'verb_disp':0,'termination_callback':term()}) print("End of optimization for gamma = "+ str(gamma) + ",target " + str(target_size) + " for point "+ str(pos)+" !")
def launchCMAESForSpecificTargetSizeAndSpecificPoint(target_size, rs, save, point, noise=None): ''' Run cmaes for a specific target size Input: -target_size, size of the target, float -setuFile, file of setup, string -save: do we use a previous Best.theta file? True = Yes, False = use current controller, None = random controller noise: noise on muscle, if None, defalt noise from muscle setup, float ''' pos = point[0] x = point[1][0] y = point[1][1] print("Starting the CMAES Optimization for target " + str(target_size) + " for point " + str(pos) + " !") foldername = rs.OPTIpath + str(target_size) + "/" + str(pos) + "/" thetaname = foldername + "Best" if save: checkIfFolderExists(foldername) copyfile(rs.OPTIpath + str(target_size) + "/" + "Best.theta", foldername + "Best.theta") elif save == None: thetaname = None #Initializes all the class used to generate trajectory exp = Experiments(rs, target_size, False, foldername, thetaname, rs.popsizeCmaes, rs.period) if (noise != None): exp.setNoise(noise) theta = exp.tm.controller.getTheta() thetaCMA = theta.flatten() #run the optimization (cmaes) cma.fmin(partial(exp.runTrajectoriesCMAESOnePoint, x, y), thetaCMA, rs.sigmaCmaes, options={ 'maxiter': rs.maxIterCmaes, 'popsize': rs.popsizeCmaes, 'CMA_diagonal': True, 'verb_log': 0, 'verb_disp': 0, 'termination_callback': term() }) print("End of optimization for target " + str(target_size) + " for point " + str(pos) + " !")
def optimize(self) -> List[Component]: solutions = [] for i in range(10): x0a = [random() for i in range(8)] xra, fx = cma.fmin(self.objective, x0a, 0.1, options={ 'bounds': [0, 1], 'tolfun': 1e-8, 'verbose': 10, 'ftarget': 1e-8, 'maxiter': 100 })[0:2] x_sol = xra points = [ vm.Point2D(x_sol[2 * i], x_sol[2 * i + 1]) for i in range(int(len(x_sol) / 2.)) ] self.component.update(*points) length = self.component.length() if abs(length - 0.2) < 1e-3: solutions.append(self.component.copy()) return solutions
def infere_variance(subject,x0,lbounds=None,ubounds=None,cma_sigma=1/3,cma_options=cma.CMAOptions(),restarts=0): if not isinstance(cma_options,cma.CMAOptions): cma_options = cma.CMAOptions(cma_options) if lbounds is None: lbounds = 5*np.ones(len(x0)) else: lbounds = np.array(lbounds) if ubounds is None: ubounds = np.inf*np.ones(len(x0)) else: ubounds = np.array(ubounds) if any(np.isinf(ubounds)): scaling_of_variables = None else: scaling_of_variables = ubounds-lbounds cma_options.set('bounds',[lbounds,ubounds]) if scaling_of_variables is not None: cma_options.set('scaling_of_variables',scaling_of_variables) dat,t,d = subject.load_data() inds = dat[:,1]<1000 dat = dat[inds] t = np.mean(t[inds],axis=2) d = np.mean(d[inds],axis=2) rt_ind = np.floor(dat[:,1]/40) model = pe.KnownVarPerfectInference(prior_mu_t=50,prior_mu_d=50,prior_va_t=15**2,prior_va_d=15**2) args = (model,dat[:,2],rt_ind,t,d) cma_fmin_output = cma.fmin(objective,x0,cma_sigma,options=cma_options,args=args,restarts=restarts) stop_cond = {} for key in cma_fmin_output[7].keys(): stop_cond[key] = cma_fmin_output[7][key] return {'xopt':cma_fmin_output[0],'fopt':cma_fmin_output[1],'evalsopt':cma_fmin_output[2],\ 'evals':cma_fmin_output[3],'iterations':cma_fmin_output[4],'xmean':cma_fmin_output[5],\ 'stds':cma_fmin_output[6],'stop':stop_cond}
def maximize(self): """ Maximizes the given acquisition function. Returns ------- np.ndarray(N,D) Point with the highest acquisition value. """ verbose_level = -9 if self.verbose: verbose_level = 0 start_point = init_random_uniform(self.lower, self.upper, 1, self.rng) def obj_func(x): a = self.objective_func(x[None, :]) return a[0] res = cma.fmin(obj_func, x0=start_point[0], sigma0=0.6, restarts=self.restarts, options={"bounds": [self.lower, self.upper], "verbose": verbose_level, "verb_log": sys.maxsize, "maxfevals": self.n_func_evals}) if res[0] is None: logging.error("CMA-ES did not find anything. \ Return random configuration instead.") return start_point return res[0]
def wrapper_CMA(f, bounds): ''' Wrapper the Covariance Matrix Adaptation Evolutionary strategy (CMA-ES) optimization method. It works generating an stochastic seach based on mutivariate Gaussian samples. Only requieres f and the box constrains to work :param f: function to optimize, acquisition. :param bounds: tuple determining the limits of the optimizer. ''' try: import cma import numpy as np def CMA_f_wrapper(f): def g(x): return f(np.array([x]))[0][0] return g lB = np.asarray(bounds)[:, 0] uB = np.asarray(bounds)[:, 1] x = cma.fmin(CMA_f_wrapper(f), (uB + lB) * 0.5, 0.6, options={ "bounds": [lB, uB], "verbose": -1 })[0] print x return reshape(x, len(bounds)) except: print("Cannot find cma library, please install it to use this option.")
def optimize(self, x0, f=None, df=None, f_df=None): """ :param x0: initial point for a local optimizer. :param f: function to optimize. :param df: gradient of the function to optimize. :param f_df: returns both the function to optimize and its gradient. """ try: import cma def CMA_f_wrapper(f): def g(x): val = f(np.array([x])) val = np.reshape(val, (1, )) return val return g lB = np.asarray(self.bounds)[:, 0] uB = np.asarray(self.bounds)[:, 1] x = cma.fmin(CMA_f_wrapper(f), x0, 0.6, options={ "bounds": [lB, uB], "verbose": -1, "maxfevals": 150 })[0] return np.atleast_2d(x), f(np.atleast_2d(x)) except ImportError: print( "Cannot find cma library, please install it to use this option." )
def st_cma(objfunc, par_b, par_0, maxiter, scale, offset): try: import cma except ImportError: cma = None assert cma is not None, 'Library for cma is not installed' sigma0 = 0.2 # "step size", should be around 1/4 of search domain popsize = 5 lb = [v[0] for v in par_b] ub = [v[1] for v in par_b] res = cma.fmin( objfunc, par_0, sigma0, restarts=0, options={ 'bounds': [lb, ub], #'maxfevals': args.maxiter, 'maxiter': maxiter, 'popsize': popsize, }) cand = [scale[i] * v + offset[i] for i, v in enumerate(res[0])] return res[1], cand
def main(self, data, path, dict_config_LSTM): # try: self.array_df = [] self.epoch = 0 self._configure_dir(path) self.dict_c['path_save'] = path self.dict_config_LSTM = dict_config_LSTM pickle_save(self.dict_c['path_save'] + '/dict.p', dict_config_LSTM) self.df_f_train = data['df_f_train'] self.df_f_val = data['df_f_val'] self.df_f_test = data['df_f_test'] self.df_t_train = data['df_t_train'] self.df_t_val = data['df_t_val'] self.df_t_test = data['df_t_test'] self.dimension = self.df_f_train['error_e'].iloc[0].shape[1] self.bias = np.median(np.concatenate(data['df_f_train']['error_e'], axis=0), axis=0) es = cma.fmin( self._opt_function, self.dimension * [1], self.sigma, { 'bounds': self.bounds, 'maxfevals': self.evals, 'verb_disp': self.verbose, 'verb_log': self.verbose_log })
def main_CMA_ES(self): self.data, self.dict_c[ 'path_save'], self.dict_config_LSTM = data_manager( dict_c).configure_data(dict_c) self._configure_dir(self.dict_c['path_save']) self.df_f_train = self.data['df_f_train'] self.df_f_val = self.data['df_f_val'] self.df_f_test = self.data['df_f_test'] self.df_t_train = self.data['df_t_train'] self.df_t_val = self.data['df_t_val'] self.df_t_test = self.data['df_t_test'] dimension = self.df_f_train['error_e'].iloc[0].shape[1] es = cma.fmin( self._opt_function, dimension * [1], self.sigma, { 'bounds': self.bounds, 'maxfevals': self.evals, 'verb_disp': self.verbose, 'verb_log': self.verbose_log })
def launchCMAESForSpecificTargetSize(sizeOfTarget, thetaFile, save): ''' Run cmaes for a specific target size Input: -sizeOfTarget, size of the target, float ''' print("Starting the CMAES Optimization for target " + str(sizeOfTarget) + " !") rs = ReadSetupFile() foldername = rs.CMAESpath + str(sizeOfTarget) + "/" thetaname = foldername + thetaFile if save: copyRBFNtoCMAES(rs, thetaFile, sizeOfTarget) #Initializes all the class used to generate trajectory exp = Experiments(rs, sizeOfTarget, False, foldername, thetaname, rs.popsizeCmaes, rs.period) theta = exp.tm.controller.theta thetaCMA = theta.flatten() #run the optimization (cmaes) resCma = cma.fmin(exp.runTrajectoriesCMAES, thetaCMA, rs.sigmaCmaes, options={ 'maxiter': rs.maxIterCmaes, 'popsize': rs.popsizeCmaes, 'CMA_diagonal': True, 'verb_log': 50, 'verb_disp': 1, 'termination_callback': term() }) print("End of optimization for target " + str(sizeOfTarget) + " !")
def launchCMAESForSpecificTargetSize(sizeOfTarget, thetaFile, save): """ Run cmaes for a specific target size Input: -sizeOfTarget, size of the target, float """ print("Starting the CMAES Optimization for target " + str(sizeOfTarget) + " !") rs = ReadSetupFile() foldername = rs.CMAESpath + str(sizeOfTarget) + "/" thetaname = foldername + thetaFile if save: copyRBFNtoCMAES(rs, thetaFile, sizeOfTarget) # Initializes all the class used to generate trajectory exp = Experiments(rs, sizeOfTarget, False, foldername, thetaname, rs.popsizeCmaes, rs.period) theta = exp.tm.controller.theta thetaCMA = theta.flatten() # run the optimization (cmaes) resCma = cma.fmin( exp.runTrajectoriesCMAES, thetaCMA, rs.sigmaCmaes, options={ "maxiter": rs.maxIterCmaes, "popsize": rs.popsizeCmaes, "CMA_diagonal": True, "verb_log": 50, "verb_disp": 1, "termination_callback": term(), }, ) print("End of optimization for target " + str(sizeOfTarget) + " !")
def _fit(self, cma_maxiter, X, XXtr_state, Xytr_state, hyperparameters_state): warnings.filterwarnings('error') assert XXtr_state.shape == (self.basis_dim_state, self.basis_dim_state) assert Xytr_state.shape == (self.basis_dim_state, self.state_dim) X = X.copy() XXtr_state = XXtr_state.copy() Xytr_state = Xytr_state.copy() hyperparameters_state = hyperparameters_state.copy() Llower_state = spla.cholesky((hyperparameters_state[-2]/hyperparameters_state[-1])**2*np.eye(self.basis_dim_state) + XXtr_state, lower=True) import cma options = {'maxiter': cma_maxiter, 'verb_disp': 1, 'verb_log': 0} res = cma.fmin(self._loss, self.thetas, 2., args=(X.copy(), Llower_state.copy(), XXtr_state.copy(), Xytr_state.copy(), hyperparameters_state.copy()), options=options) self.thetas = res[0].copy() if self.dump_model: print('Unique identifier:', self.uid) directory = './models/' if not os.path.exists(directory): os.makedirs(directory) with open(directory+self.uid+'_epoch:'+str(self.epoch)+'.p', 'wb') as fp: pickle.dump(self.thetas, fp) self.epoch += 1
def _fit(self, cma_maxiter, X, XXtr, Xytr, hyperparameters, sess): warnings.filterwarnings('error') assert len(XXtr) == self.state_dim + self.learn_reward assert len(Xytr) == self.state_dim + self.learn_reward assert len(hyperparameters) == self.state_dim + self.learn_reward X = np.copy(X) XXtr = [np.copy(ele) for ele in XXtr] Xytr = [np.copy(ele) for ele in Xytr] hyperparameters = [np.copy(ele) for ele in hyperparameters] Llowers = [ scipy.linalg.cholesky((hp[-2] / hp[-1])**2 * np.eye(len(XX)) + XX, lower=True) for XX, hp in zip(XXtr, hyperparameters) ] import cma options = {'maxiter': cma_maxiter, 'verb_disp': 1, 'verb_log': 0} res = cma.fmin(self._loss, self.thetas, 2., args=(np.copy(X), [np.copy(ele) for ele in Llowers ], [np.copy(ele) for ele in Xytr], [np.copy(ele) for ele in hyperparameters], sess), options=options) self.thetas = np.copy(res[0])
def weighted_ensemble(predictions, true_labels, task_type, metric, weights, tolfun=1e-3): seed = np.random.randint(0, 1000) logging.debug("CMA-ES uses seed: " + str(seed)) n_models = predictions.shape[0] if n_models > 1: res = cma.fmin( weighted_ensemble_error, weights, sigma0=0.25, restarts=1, args=(predictions, true_labels, metric, task_type), options={ 'bounds': [0, 1], 'seed': seed, 'verb_log': 0, # No output files 'tolfun': tolfun # Default was 1e-11 }) weights = np.array(res[0]) else: # Python CMA-ES does not work in a 1-D space weights = np.ones([1]) weights = weights / weights.sum() return weights
def __call__(self, fun, x0, callback, minimizer_kwargs): class InnerCMACallback: def __init__(self, realcb): self.realcb = realcb def __call__(self, cma): self.realcb(cma.best.x) cb = minimizer_kwargs['callback'] innercb = InnerCMACallback(cb) if cb is not None else None try: return cma.fmin(fun, x0, 10. / 4., options={ 'ftarget': self.ftarget, 'maxfevals': self.maxfevals, 'termination_callback': innercb, 'verb_disp': 0, 'verb_filenameprefix': '/tmp/outcmaes' }) except cma._Error, e: print "CMA error: " + str(e) return None
def fit_cma(log_price): init_limits = [ (4, 6), (0, 5), (1, 3), ] non_lin_vals = [random.uniform(a[0], a[1]) for a in init_limits] tc_0 = non_lin_vals[0] beta_0 = non_lin_vals[1] omega_0 = non_lin_vals[2] seed = np.array([tc_0, beta_0, omega_0]) opti_sol = cma.fmin(lambda x: func(x, log_price), sigma0=2, x0=seed, options={'popsize': 100}) tc, beta, omega = wrapper_scaling(opti_sol[0], log_price) fit_res = fit_ABC(beta, omega, tc, log_price) normed_residual = func([tc, beta, omega], log_price) / len(log_price) sol = { 'tc': tc, 'beta': beta, 'omega': omega, 'A': fit_res['A'], 'B': fit_res['B'], 'C1': fit_res['C1'], 'C2': fit_res['C2'], 'Res': normed_residual } return sol
def cma_wrapper(fun, x0, callback, minimizer_kwargs): class InnerCMACallback: def __init__(self, realcb): self.realcb = realcb def __call__(self, cma): self.realcb(cma.best.x) cb = minimizer_kwargs.pop('callback') minimizer_kwargs['options'][ 'termination_callback'] = InnerCMACallback( cb) if cb is not None else None if 'restarts' in minimizer_kwargs: # We ignore passed x0 in case a restart strategy is employed # as it is important to start at a different point in each restart # (esp. in the smallpop stages of BIPOP, obviously). x0 = '10. * np.random.rand(%d) - 5' % minimizer_kwargs.pop( 'dim') try: return cma.fmin(fun, x0, 10. / 4., **minimizer_kwargs) except cma._Error, e: print "CMA error: " + str(e) return None
def goalBabble(self, x): print("Doing goal babbling now\n") p = self.net.params p[:] = x[3] i = 0 self.sMemory = np.array([1] * (INPUTSIZE + PREDICTSIZE)) self.mMemory = np.array([0] * OUTPUTSIZE) self.rest() sensedAngles = self.get_sensor_values() pv = sensedAngles[x[2]] #Choose a goal sensor value in the range of the predicted angle #self.randomGoal = self.rand.uniform(self.Body[x[1]][0],self.Body[x[1]][1]) self.randomGoal = self.rand.uniform(-0.5, 0.5) print(self.randomGoal) #CMA-ES can be used to discover joint angles that get #closer to the goal state!!!!!!!! self.x1 = x[1] self.x2 = x[2] res = cma.fmin(self.calcGoalScore, 0.1 * (np.random.random_sample(2, ) - 0.5), 0.5, maxfevals=500, verb_disp=1, bounds=[self.Body[x[1]][0], self.Body[x[1]][1]]) cma.plot() cma.show()
def pp_cmaes_fitting(plan, real_perf_values): # x0 = np.array([4.0, 2.0, 15]) # initial guess of delays x0 = np.array([0.5, 4.0, 2.0, 15]) # initial guess including perfpot load_scale_factor = calc_pp_load_scale_factor(plan) perf_scale_factor = calc_pp_perf_scale_factor(real_perf_values) scaled_plan = list(map(lambda l: load_scale_factor * l, plan)) scaled_perfs = list(map(lambda p: perf_scale_factor * p, real_perf_values)) args = (scaled_plan, scaled_perfs, calc_rmse, unpack_pp_parms_list, pp_performance_over_time2) opts = cma.CMAOptions() # only optimize delays '''bounds = [[0.001, 0.001, 0.001], [30.0, 30.0, 30.0]]''' # optimize delays and init_p aka perfpot bounds = [[0.0, 0.001, 0.001, 0.001], [1.0, 30.0, 30.0, 30.0]] opts.set('bounds', bounds) # opts.set('verb_disp', False) # opts.set('verbose', -9) opts.set('maxiter', 800) res = cma.fmin(objective_f, x0, 0.5, args=args, options=opts) print('res[0] = {}'.format(res[0])) print('res[1] = {}'.format(res[1])) return res, load_scale_factor, perf_scale_factor
def goalBabble(self, x): print("Doing goal babbling now\n") p = self.net.params p[:] = x[3] i = 0 self.sMemory = np.array([1] * (INPUTSIZE + PREDICTSIZE)) self.mMemory = np.array([0] * OUTPUTSIZE) self.rest() sensedAngles = self.get_sensor_values() pv = sensedAngles[x[2]] #Choose a goal sensor value in the range of the predicted angle #self.randomGoal = self.rand.uniform(self.Body[x[1]][0],self.Body[x[1]][1]) for i in range(2): self.randomGoal = self.rand.uniform(-0.5, 0.5) print(self.randomGoal) #CMA-ES can be used to discover joint angles that get #closer to the goal state!!!!!!!! self.x1 = x[1] self.x2 = x[2] print("Range motor = " + str(self.Body[x[1]][0]) + " " + str(self.Body[x[1]][1])) initG = [ self.rand.uniform(self.Body[x[1]][0], self.Body[x[1]][1]), self.rand.uniform(self.Body[x[1]][0], self.Body[x[1]][1]) ] print("Initial motor = " + str(initG)) # res = cma.fmin(self.calcGoalScore, initG, (self.Body[x[1]][1]- self.Body[x[1]][0])/10.0,maxfevals=200, verb_disp=1, bounds=[self.Body[x[1]][0]-1, self.Body[x[1]][1]+1] ) # res = cma.fmin(self.calcGoalScore, initG, 0.1,maxfevals=200, verb_disp=1, bounds=[-10,10]) res = cma.fmin(self.calcGoalScore, initG, 0.1, maxfevals=50, verb_disp=1)
def optimize_local(output=output): # if self.allocationMethod == 'variablePrecision': # importing CMAES libarary import cma # setting up parameters and running the optimization x0 = 50 + 15 * np.random.randn(12 * (self.depth - 1)) res = cma.fmin(obj_func, x0, 30, options={'bounds':[1,100],\ 'tolfun':1, 'maxfevals': int(1e4)}) sigma_opt = res[0] elif self.allocationMethod == 'equalPrecision': # importing Bayesian optimization libraries import GPy, GPyOpt from GPyOpt.methods import BayesianOptimization # setting up parameters and running the optimization kernel = GPy.kern.Matern52(input_dim=1) domain = [{ 'name': 'var_1', 'type': 'continuous', 'domain': (0, 100) }] optimizer = BayesianOptimization(obj_func, domain=domain, kernel=kernel) optimizer.run_optimization(max_iter=50) sigma_opt = optimizer.X[optimizer.Y.argmin()] # appending the result (scalar sigma) to output queue output.put(sigma_opt)
def reproduction_for_sin(self, o=None, shape=True, avoidance=False, verbose=0): #if verbose <= 1: #print("Trajectory with x0 = %s, g = %s, self.step=%.2f, step=%.3f" % (self.x0, self.goal, self.step, self.step)) #puts evething that was from X to x; from array to matrix x = copy.copy(self.y_asis_of_sin) temp_matrix_of_x1 = copy.copy(x) temp_matrix_of_x2 = copy.copy(x) original_matrix_1 = [copy.copy(temp_matrix_of_x1)] original_matrix_2 = [copy.copy(temp_matrix_of_x2)] #reproducing the x-asis t = 0.1 * self.step ti = 0 S = self.converges_for_sin() while t < self.step: t += self.step ti += 1 self.s = S[ti] x += self.step * temp_matrix_of_x1 temp_matrix_of_x1 += self.step * temp_matrix_of_x2 sd = self.spring_damping_for_sin() # the weighted shape base on the movement f = self.shape_path_for_sin() if shape else 0. C = self.step.obstacle_for_sin( o, x, temp_matrix_of_x1) if avoidance else 0.0 #print(temp_matrix_of_x2) #Everything that you implemented in the matrix that was temperary will initialize will be put into the none temperary matrix if ti % self.step > 0: temp_matrix_of_x1 = np.append(copy.copy(x), copy.copy(self.y_asis_of_sin)) original_matrix_1 = np.append(copy.copy(self.y_asis_of_sin), copy.copy(temp_matrix_of_x1)) original_matrix_2 = np.append(copy.copy(self.y_asis_of_sin), copy.copy(temp_matrix_of_x2)) self.BlackBox = cma.fmin(cma.ff.linear, self.y_asis_of_sin, 1) print(self.BlackBox[0]) #for i in range(len(self.BlackBox[0])): #original_matrix_1[i] *= self.BlackBox[0][i] temp = np.array(self.y_asis_of_sin) #return the matrix as array when returning original_matrix_1 = temp * (self.BlackBox[2] / 150) return np.array( self.y_asis_of_sin), np.array(x), np.array(original_matrix_1)
def goalBabble(self, x): print("Doing goal babbling now\n") p = self.net.params p[:] = x[3] i = 0 self.sMemory = np.array([1]*(INPUTSIZE + PREDICTSIZE)) self.mMemory = np.array([0]*OUTPUTSIZE) self.rest() sensedAngles = self.get_sensor_values() pv = sensedAngles[x[2]] #Choose a goal sensor value in the range of the predicted angle #self.randomGoal = self.rand.uniform(self.Body[x[1]][0],self.Body[x[1]][1]) for i in range(2): self.randomGoal = self.rand.uniform(-0.5,0.5) print(self.randomGoal) #CMA-ES can be used to discover joint angles that get #closer to the goal state!!!!!!!! self.x1 = x[1] self.x2 = x[2] print("Range motor = " + str(self.Body[x[1]][0]) + " " + str(self.Body[x[1]][1])) initG = [self.rand.uniform(self.Body[x[1]][0],self.Body[x[1]][1]),self.rand.uniform(self.Body[x[1]][0],self.Body[x[1]][1])] print("Initial motor = " + str(initG)) # res = cma.fmin(self.calcGoalScore, initG, (self.Body[x[1]][1]- self.Body[x[1]][0])/10.0,maxfevals=200, verb_disp=1, bounds=[self.Body[x[1]][0]-1, self.Body[x[1]][1]+1] ) # res = cma.fmin(self.calcGoalScore, initG, 0.1,maxfevals=200, verb_disp=1, bounds=[-10,10]) res = cma.fmin(self.calcGoalScore, initG, 0.1,maxfevals=50, verb_disp=1)
def learn(self, _): ''' Learn until convergence. ''' returns = [] function = lambda parameters: self.objective_function(returns, parameters) res = cma.fmin(function, self.get_parameters(), self.sigma) self.set_parameters(res[5]) return returns
def improve(nbevals): stimParName = optSet.stimParName stimMax = optSet.stimMax synParName = optSet.synParName synMax = optSet.synMax res = fmin(f, optSet.x0, optSet.cmaes_sigma, options={ 'bounds': [optSet.lower, optSet.upper], 'verb_log': 3, 'verb_disp': True, 'maxfevals': nbevals, 'seed': 0 }) x = res[0] # Save the best asim file in simFiles directory simSet = SimulationSet.SimulationSet() for st in range(len(stimParName)): simSet.set_by_range({stimParName[st]: [x[st] * stimMax[st]]}) for sy in range(len(synParName)): simSet.set_by_range( {synParName[sy]: [x[st + 1 + sy] * synMax[sy]]}) print simSet.samplePts projMan.make_asims(simSet) # Copy sim file from "SimFiles" to "CMAeBestSimFiles" directory destdir = folders.animatlab_rootFolder + "CMAeBestSimFiles/" sourcedir = folders.animatlab_simFiles_dir simFileName = findChartName(folders.animatlab_commonFiles_dir)[0] filesource = simFileName + "-1.asim" filedest = simFileName + ".asim" comment = "" copyRenameFile(sourcedir, filesource, destdir, filedest, comment) return [res, simSet]
def optimize(self, x0=None, f=None, df=None, f_df=None): """ :param x0: initial point for a local optimizer. :param f: function to optimize. :param df: gradient of the function to optimize. :param f_df: returns both the function to optimize and its gradient. """ try: import cma import numpy as np def CMA_f_wrapper(f): def g(x): return f(np.array([x]))[0][0] return g lB = np.asarray(self.space.get_bounds())[:, 0] uB = np.asarray(self.space.get_bounds())[:, 1] x = cma.fmin(CMA_f_wrapper(f), (uB + lB) * 0.5, 0.6, options={ "bounds": [lB, uB], "verbose": -1 })[0] return np.atleast_2d(x), f(np.atleast_2d(x)) except: print("CMA does not work in problems of dimension 1.")
def __init__(self, space, maxiter=1000): super(Opt_CMA, self).__init__(space) self.maxiter = maxiter assert self.space.has_types['continuous'] try: import cma import numpy as np def CMA_f_wrapper(f): def g(x): return f(np.array([x]))[0][0] return g lB = np.asarray(self.space.get_bounds())[:, 0] uB = np.asarray(self.space.get_bounds())[:, 1] x = cma.fmin(CMA_f_wrapper(f), (uB + lB) * 0.5, 0.6, options={ "bounds": [lB, uB], "verbose": -1 })[0] return np.atleast_2d(x), f(np.atleast_2d(x)) except: print( "Cannot find cma library, please install it to use this option." )
def optimize(self, x0, f=None, df=None, f_df=None): """ :param x0: initial point for a local optimizer. :param f: function to optimize. :param df: gradient of the function to optimize. :param f_df: returns both the function to optimize and its gradient. """ try: import cma def CMA_f_wrapper(f): def g(x): return f(np.array([x]))[0][0] return g lB = np.asarray(self.bounds)[:, 0] uB = np.asarray(self.bounds)[:, 1] x = cma.fmin(CMA_f_wrapper(f), x0, 0.6, options={ "bounds": [lB, uB], "verbose": -1 })[0] return np.atleast_2d(x), f(np.atleast_2d(x)) except ImportError: print( "Cannot find cma library, please install it to use this option." ) except: print("CMA does not work in problems of dimension 1.")
def launchCMAESMissing(rs, save, gamma, point): ''' Run cmaes for a specific target size Input: -target_size, size of the target, float -setuFile, file of setup, string -save: do we use a previous Best.theta file? True = Yes, False = use current controller, None = random controller ''' rs.gamma = gamma / 10.0 pos = point[0] x = point[1][0] y = point[1][1] target_size = point[2] print("Starting the CMAES Optimization for gamma = " + str(gamma) + ",target " + str(target_size) + " for point " + str(pos) + " !") foldername = rs.OPTIpathMissing + "gamma" + str(gamma) + "/" + str( target_size) + "/" + str(pos) + "/" thetaname = foldername + "Best" if save: checkIfFolderExists(foldername) copyfile( rs.OPTIpathMissing + "gamma" + str(gamma) + "/" + str(target_size) + "/" + "Best.theta", foldername + "Best.theta") elif save == None: thetaname = None #Initializes all the classes used to generate trajectory exp = Experiments(rs, target_size, False, foldername, thetaname, rs.popsizeCmaes, rs.period) theta = exp.tm.controller.getTheta() thetaCMA = theta.flatten() #run the optimization (cmaes) cma.fmin(partial(exp.runTrajectoriesCMAESOnePointMulti, x, y), thetaCMA, rs.sigmaCmaes, options={ 'maxiter': rs.maxIterCmaes, 'popsize': rs.popsizeCmaes, 'CMA_diagonal': True, 'verb_log': 0, 'verb_disp': 0, 'termination_callback': term() }) print("End of optimization for gamma = " + str(gamma) + ",target " + str(target_size) + " for point " + str(pos) + " !")
def posterior_mean_optimization(model, lower, upper, n_restarts=10, method="scipy", with_gradients=False): """ Estimates the incumbent by minimize the posterior mean of the objective function. Parameters ---------- model : Model object Posterior belief of the objective function. lower : (D) numpy array Specified the lower bound of the input space. Each entry corresponds to one dimension. upper : (D) numpy array Specified the upper bound of the input space. Each entry corresponds to one dimension. n_restarts: int Number of independent restarts of the optimization procedure from random starting points method : {'scipy', 'cma'} Specifies which optimization method is used to minimize the posterior mean. with_gradients : bool Specifies if gradient information are used. Only valid if method == 'scipy'. Returns ------- np.ndarray(D,) best point that was found """ def f(x): return model.predict(x[np.newaxis, :])[0][0] def df(x): dmu = model.predictive_gradients(x[np.newaxis, :])[0] return dmu startpoints = init_random_uniform(lower, upper, n_restarts) x_opt = np.zeros([len(startpoints), lower.shape[0]]) fval = np.zeros([len(startpoints)]) for i, startpoint in enumerate(startpoints): if method == "scipy": if with_gradients: res = optimize.fmin_l_bfgs_b(f, startpoint, df, bounds=list(zip(lower, upper))) x_opt[i] = res[0] fval[i] = res[1] else: res = optimize.minimize(f, startpoint, bounds=list(zip(lower, upper)), method="L-BFGS-B") x_opt[i] = res["x"] fval[i] = res["fun"] elif method == 'cma': res = cma.fmin(f, startpoint, 0.6, options={"bounds": [lower, upper]}) x_opt[i] = res[0] fval[i] = res[1] # Return the point with the lowest function value best = np.argmin(fval) return x_opt[best]
def run_cma(self): popsize = self.population maxiter = self.iterations all_parameters = [ 'STRETCH', 'SHEAR', 'BEND', 'FRICTION', 'SELFCOLDIST', 'SELFCOLFRICTION', 'STIFFPOWER', 'ITERATION', 'WIND', 'ARM_HEIGHT_PERT_GOOD', 'ARM_HEIGHT_PERT_MISS', 'ARM_HEIGHT_PERT_CAUG', 'ARM_HORIZONTAL_PERT_GOOD', 'ARM_HORIZONTAL_PERT_MISS', 'ARM_HORIZONTAL_PERT_CAUG', 'FIST_RADIUS', 'WRIST_RADIUS', 'ELBOW_RADIUS', 'SHOULDER_RADIUS', 'FOREARM_LENGTH' ] use_parameters = np.array( [1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]) all_parameters_min = np.array([ 0.0, 0.0, 0.0, 0.3, 0.0, 0.0, 5.0, 0.0, 0.0, -0.04, -0.04, -0.06, -0.03, -0.03, -0.03, 0.04, 0.03, 0.04, 0.065, 0.28 ]) all_parameters_max = np.array([ 1.0, 1.0, 1.0, 0.8, 0.015, 1.0, 10.0, 20.0, 1.0, 0.04, 0.04, 0.0, 0.03, 0.03, 0.03, 0.06, 0.043, 0.06, 0.085, 0.35 ]) all_parameters_initialization = (all_parameters_max + all_parameters_min) / 2. all_parameters_scaling = (all_parameters_max - all_parameters_min) / 4. parameters_min = [] parameters_max = [] parameters_init = [] parameters_scaling = [] self.parameters = [] self.iteration_count = 0 for i in xrange(len(use_parameters)): if use_parameters[i]: parameters_min.append(all_parameters_min[i]) parameters_max.append(all_parameters_max[i]) parameters_init.append(all_parameters_initialization[i]) parameters_scaling.append(all_parameters_scaling[i]) self.parameters.append(all_parameters[i]) # print 'Using parameter: ', all_parameters[i] opts = { 'seed': 1234, 'ftarget': 0., 'popsize': popsize, 'maxiter': maxiter, 'maxfevals': 1e8, 'CMA_cmean': 0.5, 'scaling_of_variables': parameters_scaling, 'bounds': [parameters_min, parameters_max] } self.iteration_start_time = time.time() optimization_results = cma.fmin(self.objective_function, parameters_init, 1., options=opts) print 'Final Optimization Results: ', optimization_results print 'Final total time taken: ', time.time() - self.node_start_time
def learn(self, _): ''' Learn until convergence. ''' returns = [] function = lambda parameters: self.objective_function( returns, parameters) res = cma.fmin(function, self.get_parameters(), self.sigma) self.set_parameters(res[5]) return returns
def Testarea(X,Y,func,nbParam,ff): #T=symbols('T') #print "a intrat in cma" funcu=func.replace("^","**") funca=funcu.replace("P","prez") rez=[0] if nbParam >1: if ff==1 : rez=cma.fmin(FitnessFunctionsForCma.ME, nbParam*[0], 0.5,args=(X,Y,funcu)) else : rez=cma.fmin(FitnessFunctionsForCma.ME, nbParam*[0], 0.5,args=(X,Y,funcu)) prez=rez[0].tolist() rezult=prez #print "a iesit din cma" return (prez,rez[1],funca) else : return (rez,1002,funca)
def _optimize(self, fun_negative_acquisition, str_initial_method, int_samples): list_next_point = [] if self.str_optimizer_method_bo == 'L-BFGS-B': list_bounds = self._get_bounds() arr_initials = self.get_initial( str_initial_method, fun_objective=fun_negative_acquisition, int_samples=int_samples) for arr_initial in arr_initials: next_point = minimize(fun_negative_acquisition, x0=arr_initial, bounds=list_bounds, method=self.str_optimizer_method_bo, options={'disp': False}) next_point_x = next_point.x list_next_point.append(next_point_x) if self.debug: print( '[DEBUG] _optimize in bo.py: optimized point for acq', next_point_x) elif self.str_optimizer_method_bo == 'DIRECT': # pragma: no cover list_bounds = self._get_bounds() next_point = directminimize( fun_negative_acquisition, bounds=list_bounds, ) next_point_x = next_point.x list_next_point.append(next_point_x) elif self.str_optimizer_method_bo == 'CMA-ES': list_bounds = self._get_bounds() list_bounds = np.array(list_bounds) def fun_wrapper(f): def g(bx): return f(bx)[0] return g arr_initials = self.get_initial( str_initial_method, fun_objective=fun_negative_acquisition, int_samples=1) next_point_x = cma.fmin(fun_wrapper(fun_negative_acquisition), arr_initials[0], 0.5, options={ 'bounds': [list_bounds[:, 0], list_bounds[:, 1]], 'verbose': -1 })[0] list_next_point.append(next_point_x) next_points = np.array(list_next_point) next_point = get_best_acquisition(next_points, fun_negative_acquisition) return next_point.flatten(), next_points
def acq_max_(self,ac, gp, y_max, bounds, random_state): x_seeds = random_state.uniform(bounds[:, 0], bounds[:, 1], size=(bounds.shape[0])) options = {'ftarget': 1e-3, 'bounds': bounds.T.tolist(), 'maxiter': 1000, 'verb_log': 0,'verb_time':False,'verbose':-9} res = cma.fmin(lambda x: 1 - ac(x.reshape(1, -1), gp=gp, y_max=y_max), x_seeds, 0.25, options=options, restarts=0, incpopsize=0, restart_from_best=False, bipop=False) x_max = res[0] return np.clip(x_max, bounds[:, 0], bounds[:, 1])
def get_drive_median(self): if len(self.locations) == 0: self._drive_median = None elif len(self.locations) == 1: self._drive_median = self.locations[0] elif len(self.locations) == 2: self._drive_median = self.path_midpoint(*self.locations) else: self._drive_median = cma.fmin(self.solution_fitness, list(self.geom_median), self.sigma0(), args=(True,), options={'popsize':2, 'tolfun':1000, 'tolfunhist': 1000})
def estimate_incumbent(self, startpoints): """ Starts form each startpoint an optimization run in the configuration subspace and returns the best found point of all runs as incumbent Parameters ---------- startpoints : (N, D) numpy array Startpoints where the optimization starts from. Returns ------- np.ndarray(1, D) Incumbent np.ndarray(1,1) Incumbent value """ x_opt = np.zeros([len(startpoints), self.X_lower.shape[0]]) fval = np.zeros([len(startpoints)]) for i, startpoint in enumerate(startpoints): if self.method == "scipy": if self.with_gradients: res = optimize.fmin_l_bfgs_b(self.f, startpoint[self.is_env == 0], self.df, bounds=list(zip(self.sub_X_lower, self.sub_X_upper))) # The result has the dimensionality of the projected # configuration space so we have to add the # dimensions of the environmental subspace x_ = np.zeros([self.is_env.shape[0]]) x_[self.is_env == 1] = self.env_values x_[self.is_env == 0] = res[0] x_opt[i] = x_ fval[i] = res[1] else: res = optimize.minimize(self.f, startpoint[self.is_env == 0], bounds=list(zip(self.sub_X_lower, self.sub_X_upper)), method="L-BFGS-B", options={"disp": True}) x_ = np.zeros([self.is_env.shape[0]]) x_[self.is_env == 1] = self.env_values x_[self.is_env == 0] = res["x"] x_opt[i] = x_ fval[i] = res["fun"] elif self.method == 'cmaes': res = cma.fmin(self.f, startpoint[self.is_env == 0], 0.6, options={"bounds": [self.sub_X_lower, self.sub_X_upper]}) x_ = np.zeros([self.is_env.shape[0]]) x_[self.is_env == 1] = self.env_values x_[self.is_env == 0] = res[0] x_opt[i] = x_ fval[i] = res[1] # Return the point with the lowest function value best = np.argmin(fval) return x_opt[best, np.newaxis, :], np.array([[fval[best]]])
def maximize(self, verbose=False): if not verbose: # Turn off stdout, a bit hacky but that's the only way how we get cma to be quiet stdout = sys.stdout sys.stdout = io.StringIO() # Start from random point start_point = np.random.uniform(self.X_lower, self.X_upper, self.X_lower.shape[0]) res = cma.fmin(self._cma_fkt_wrapper(self.objective_func), start_point, 0.6, options={"bounds": [self.X_lower, self.X_upper], "verbose": 0, "verb_log": sys.maxsize}) # Turn on stdout again sys.stdout = stdout else: res = cma.fmin(self._cma_fkt_wrapper(self.objective_func), (self.X_upper + self.X_lower) * 0.5, 0.6, options={"bounds": [self.X_lower, self.X_upper], "verbose": 0, "verb_log": sys.maxsize}) return np.array([res[0]])
def genetic_search(): side = 10 train_input, train_output, train_splits, test_input, test_output, test_splits, network = test_data.instrumentalness(side=side) optimiser = esn.GeneticOptimiser(network, train_input, train_output, 0) params = np.array(optimiser.initial_params()) res = cma.fmin(optimiser.evaluate, params, 0.1, maxiter=5) filename = '/parent/best_esn_%s_%s.pkl' % (side, res[1]) with open(filename, 'w') as f: cPickle.dump(network.serialize(), f)
def solve(self): [o.notify_init(self, self.model) for o in self.observers] res = {'result': 'NG'} # 1. The initial step notification [o.notify_step(self, self.model) for o in self.observers] print('Solving...') pts = [] solved = [] values = [] # for task in self.tasks: for task in np.linspace(0.0, 1.0, 51): # if not (2.0 / 3.0 <= task and task <= 3.0 / 3.0): # continue task = 1.0 print('') print('------- CMA-ES : task = %.6f -------- ' % task) self.current_task = task opts = cma.CMAOptions() opts = cma.CMAOptions() opts.set('verb_disp', 1) opts.set('ftarget', 0.001) opts.set('popsize', 16) opts.set('maxiter', 100) # opt = {'verb_time': 0, 'popsize': 16, 'tolfun': 1e-5} x0 = np.random.rand(self.prob.dim) - 0.5 res = cma.fmin(self.evaluate, x0, 2.0, opts) print('------------ task = %.6f ----------- ' % task) print('self.eval_counter = %d' % self.num_evals()) print('the answer: %s' % res[0]) print('value: %.6f' % res[1]) pts += [res[0]] solved += [task] values += [res[1]] print('solved tasks: %s' % solved) print('solved values: %s' % values) print('') # [o.notify_step(self, self.model) for o in self.observers] self.mean().fit(pts) # 2. The final step notification [o.notify_step(self, self.model) for o in self.observers] for i in range(self.n): print("%d (%.4f) : %s" % (i, self.tasks[i], pts[i])) print('sum values: %.6f' % np.mean(self.values())) print self.model [o.notify_solve(self, self.model) for o in self.observers] return res
def learn(self, steps): ''' Learn for a given number of steps. ''' returns = [] function = lambda parameters: self.objective_function(returns, parameters) for step in range(steps): agent = FixedSarsaAgent() agent.action_weights = self.action_weights agent.parameter_weights = self.parameter_weights rets = agent.learn(self.qsteps) returns.extend(rets) res = cma.fmin(function, self.get_parameters(), self.sigma) self.set_parameters(res[5]) return returns
def optimize(self): opt = {'verb_time':0, # 'boundary_handling': 'BoundPenalty', 'bounds': [self.lo, self.hi], 'popsize':64, 'tolfun' : 0.001} print "==== abstract.model.TWOTIP optimize...." self.res = cma.fmin(self.evaluate, 0.5 * (self.lo + self.hi), 1.0, opt) print "==== result\n ", self.res x_opt = self.res[0] print 'optimal value = ', self.evaluate(x_opt) print 'optimal solution = ', x_opt print "==== abstract.model.TWOTIP optimize.... OK"
def cmaes(f, n, ftol, xtol, bounds, x, **kwargs): """Find global maxima of an objective function using CMA-ES algorithm. Args: f (scalar function): Objective function n (int): Number of parameters ftol (double): Tolerance for the change of f function xtol (double): Tolerance for the change of paramters bound (dict): Absolute value of lower and upper bounds x (array_like): Initial parameter value Returns: f_opt (double): Function value at the optimum x_opt (array_like): Parameter value at the optimum res (str): Termination criterion """ #set options of the cma-es optimizer opts = cma.CMAOptions() opts['popsize'] = n*10 opts['CMA_active'] = False opts['tolfun'] = ftol opts['tolx'] = xtol opts['verb_disp'] = 0 opts['verb_log'] = 0 opts['verbose'] = 0 if type(bounds['lb']) == int or type(bounds['lb']) == float: opts['bounds'] = [[bounds['lb']]*n, [bounds['ub']]*n] elif len(bounds['lb']) == n and len(bounds['ub']) == n: opts['bounds'] = [bounds['lb'], bounds['ub']] else: print('inconsistent definition of parameter bounds') opts['CMA_stds'] = ones(n)*(bounds['ub'] - bounds['lb'])/4 cma_sigma = 1; for s in kwargs.keys(): opts[s] = kwargs[s] #start optimization negf = lambda x: -f(x) res = cma.fmin(negf, x, cma_sigma, opts) #collect results x_opt = res[0] f_opt = -res[1] res = res[-3] return f_opt, x_opt, res
def launchCMAESForSpecificTargetSizeAndSpecificPoint(target_size, rs, save, point, noise=None): ''' Run cmaes for a specific target size Input: -target_size, size of the target, float -setuFile, file of setup, string -save: do we use a previous Best.theta file? True = Yes, False = use current controller, None = random controller noise: noise on muscle, if None, defalt noise from muscle setup, float ''' pos=point[0] x=point[1][0] y=point[1][1] print("Starting the CMAES Optimization for target " + str(target_size) + " for point "+ str(pos)+" !") foldername = rs.OPTIpath + str(target_size)+"/"+str(pos)+"/" thetaname = foldername + "Best" if save: checkIfFolderExists(foldername) copyfile(rs.OPTIpath + str(target_size)+"/" + "Best.theta",foldername + "Best.theta") elif save==None: thetaname=None #Initializes all the class used to generate trajectory exp = Experiments(rs, target_size, False, foldername, thetaname,rs.popsizeCmaes,rs.period) if(noise!=None): exp.setNoise(noise) theta = exp.tm.controller.getTheta() thetaCMA = theta.flatten() #run the optimization (cmaes) cma.fmin(partial(exp.runTrajectoriesCMAESOnePoint, x, y), thetaCMA, rs.sigmaCmaes, options={'maxiter':rs.maxIterCmaes, 'popsize':rs.popsizeCmaes, 'CMA_diagonal':True, 'verb_log':0, 'verb_disp':0,'termination_callback':term()}) print("End of optimization for target " + str(target_size) + " for point "+ str(pos)+" !")
def optimize_with_fullbody_motion(self): # x = np.random.rand(self.dim) x = np.array([-0.52563663, -1.57, -1.57, 0.91604437, -0.67324443, -0.43524684, -0.2820, 0.67682579, -1.199266, -0.864372, -1.57, 0.79398899]) # 0.476501049002 return self.evaluate_fullbody(x) lo = np.array([-1.57] * self.dim) hi = np.array([1.57] * self.dim) opt = {'verb_time': 0, 'boundary_handling': 'BoundPenalty', 'bounds': [lo, hi], 'tolfun': 0.001} print "==== abstract.model.TIP optimize...." self.res = cma.fmin(self.evaluate_fullbody, 0.5 * (lo + hi), 1.0, opt) self.control = self.res[0]
def ff_cmaes_fitting(plan, real_perf_values): x0 = np.array([real_perf_values[0], 1.0, 30.0, 1.0, 15.0]) # initial guess args = (plan, real_perf_values, calc_rmse, unpack_ff_parms_list, ff_performance_over_time2) opts = cma.CMAOptions() bounds = [[0.0, 0.01, 1.0, 0.01, 1.0], [real_perf_values[0] * 2, 5.0, 70.0, 5.0, 70.0]] opts.set('bounds', bounds) opts.set('tolfun', 1e-5) # opts.set('verb_disp', False) # opts.set('verbose', -9) # opts.set('maxiter', 800) res = cma.fmin(objective_f, x0, 0.5, args=args, options=opts) return res
def __call__(self, fun, x0, callback, minimizer_kwargs): class InnerCMACallback: def __init__(self, realcb): self.realcb = realcb def __call__(self, cma): self.realcb(cma.best.x) cb = minimizer_kwargs['callback'] innercb = InnerCMACallback(cb) if cb is not None else None try: return cma.fmin(fun, x0, 10./4., options={'ftarget': self.ftarget, 'maxfevals': self.maxfevals, 'termination_callback': innercb, 'verb_disp': 0, 'verb_filenameprefix': '/tmp/outcmaes'}) except cma._Error, e: print "CMA error: " + str(e) return None
def __init__(self, space, maxiter=1000): super(Opt_CMA, self).__init__(space) self.maxiter = maxiter assert self.space.has_types['continuous'] try: import cma import numpy as np def CMA_f_wrapper(f): def g(x): return f(np.array([x]))[0][0] return g lB = np.asarray(self.space.get_bounds())[:,0] uB = np.asarray(self.space.get_bounds())[:,1] x = cma.fmin(CMA_f_wrapper(f), (uB + lB) * 0.5, 0.6, options={"bounds":[lB, uB], "verbose":-1})[0] return np.atleast_2d(x), f(np.atleast_2d(x)) except: print("Cannot find cma library, please install it to use this option.")
def solve(self): [o.notify_init(self, self.model) for o in self.observers] sample_values = [] for task in self.tasks: pt = self.mean().point(task) s = Sample(pt, self.prob) v = s.evaluate(task) sample_values += [v] self.iter_values += [sample_values] self.iter_params += [self.mean().params()] [o.notify_step(self, self.model) for o in self.observers] res = {'result': 'NG'} # opt = {'verb_time': 0, 'popsize': 16, 'tolfun': 1.0} cma.CMAOptions('tol') opts = cma.CMAOptions() opts.set('verb_disp', 1) # opts.set('tolfun', 0.001) # opts.set('tolx', 0.0000001) # opts.set('tolx', 1.0) opts.set('ftarget', 0.001) num_offsprings = 16 opts.set('popsize', num_offsprings) max_iter = int(20000 / self.n / num_offsprings) print('maxiter: %d' % max_iter) opts.set('maxiter', max_iter) for key, value in opts.iteritems(): print '[', key, ']\n', value x0 = np.random.rand(self.mean().paramdim) - 0.5 # print cma.CMAOptions() # exit(0) print() print('------- CMA-ES --------') res = cma.fmin(self.evaluate, x0, 1.0, opts) print('-----------------------') print() # np.set_printoptions(precision=6, suppress=True) print('the answer: %s' % res[0]) [o.notify_solve(self, self.model) for o in self.observers] return res
def weighted_ensemble(predictions, true_labels, task_type, metric, weights, tolfun=1e-3): seed = np.random.randint(0, 1000) logging.debug("CMA-ES uses seed: " + str(seed)) n_models = predictions.shape[0] if n_models > 1: res = cma.fmin(weighted_ensemble_error, weights, sigma0=0.25, restarts=1, args=(predictions, true_labels, metric, task_type), options={'bounds': [0, 1], 'seed': seed, 'verb_log': 0, # No output files 'tolfun': tolfun # Default was 1e-11 }) weights = np.array(res[0]) else: # Python CMA-ES does not work in a 1-D space weights = np.ones([1]) weights = weights / weights.sum() return weights
def fitCapacitanceAndFrequency(self, CdlStart = 1e-4, Cdl1Start = 0.0, Cdl2Start = 0.0, Cdl3Start = 0.0): """Obtains values of the capacitance parameters and frequency using a CMA-ES algorithm. """ start = [CdlStart, Cdl1Start, Cdl2Start, Cdl3Start, self.freq] start = self._rescaleCapFreqParams(start) verbose = 1 if "loud-cma" in self.debugParams else -9 optDict = {'tolfun' : 1e-19, 'tolfunhist' : 1e-19, "verbose" : verbose, 'verb_log' : np.inf} res = cma.fmin(self._capacitanceAndFreqObjectiveFunction, start, 1, optDict) res = self._unscaleCapFreqParams(res[0]) print res self.Cdl = res[0] self.Cdl1 = res[1] self.Cdl2 = res[2] self.Cdl3 = res[3] self.freq = res[4]
def estimate_incumbent(self, startpoints): """ Starts form each startpoint an optimization run and returns the best found point of all runs as incumbent Parameters ---------- startpoints : (N, D) numpy array Startpoints where the optimization starts from. Returns ------- np.ndarray(1, D) Incumbent np.ndarray(1,1) Incumbent value """ x_opt = np.zeros([len(startpoints), self.X_lower.shape[0]]) fval = np.zeros([len(startpoints)]) for i, startpoint in enumerate(startpoints): if self.method == "scipy": if self.with_gradients: res = optimize.fmin_l_bfgs_b( self.f, startpoint, self.df, bounds=list(zip(self.X_lower, self.X_upper)) ) x_opt[i] = res[0] fval[i] = res[1] else: res = optimize.minimize( self.f, startpoint, bounds=list(zip(self.X_lower, self.X_upper)), method="L-BFGS-B" ) x_opt[i] = res["x"] fval[i] = res["fun"] elif self.method == "cmaes": res = cma.fmin(self.f, startpoint, 0.6, options={"bounds": [self.X_lower, self.X_upper]}) x_opt[i] = res[0] fval[i] = res[1] # Return the point with the lowest function value best = np.argmin(fval) return x_opt[best, np.newaxis, :], fval[best, np.newaxis, np.newaxis]
def main_cma_es(args): import cma print "args", args # options = {'CMA_diagonal':100, 'seed':1234, 'verb_time':0, "maxfevals": 2000} # options = {'CMA_diagonal': 0, 'seed':32984, 'verb_time':0, "maxfevals": 2000} options = {'CMA_diagonal': 0, 'seed':4534985, 'verb_time':0, "maxfevals": 4000} hparams = { "numsteps": args.numsteps, "measure": ComplexityMeasure(), "continuous": True, } pobjective = partial(objective, hparams=hparams) # func = objective # args["func"] # arguments: function, initial params, initial var, options # res = cma.fmin(cma.fcts.griewank, [0.1] * 10, 0.5, options) res = cma.fmin(pobjective, [0.5] * 4, 0.3, options) print "result cma_es", res[0], res[1] return res[0]
def wrapper_CMA(f,bounds): ''' Wrapper the Covariance Matrix Adaptation Evolutionary strategy (CMA-ES) optimization method. It works generating an stochastic seach based on mutivariate Gaussian samples. Only requieres f and the box constrains to work :param f: function to optimize, acquisition. :param bounds: tuple determining the limits of the optimizer. ''' try: import cma import numpy as np def CMA_f_wrapper(f): def g(x): return f(np.array([x]))[0][0] return g lB = np.asarray(bounds)[:,0] uB = np.asarray(bounds)[:,1] x = cma.fmin(CMA_f_wrapper(f), (uB + lB) * 0.5, 0.6, options={"bounds":[lB, uB], "verbose":-1})[0] print x return reshape(x,len(bounds)) except: print("Cannot find cma library, please install it to use this option.")
def maximize(self, rng = None): """ Maximizes the given acquisition function. Parameters ---------- Returns ------- np.ndarray(N,D) Point with highest acquisition value. """ # All stdout and stderr is pointed to devnull during # the optimization. (That is the only way to keep cmaes quiet) if rng is None: rng = np.random.RandomState(42) if not self.verbose: sys.stdout = os.devnull sys.stderr = os.devnull res = cma.fmin(self._cma_fkt_wrapper(self.objective_func), x0=(self.X_upper + self.X_lower) * 0.5, sigma0=0.6, restarts=self.restarts, options={"bounds": [self.X_lower, self.X_upper], "verbose": 0, "verb_log": sys.maxsize, "maxfevals": self.n_func_evals}) if res[0] is None: logging.error("CMA-ES did not find anything. \ Return random configuration instead.") return np.array([rng.uniform(self.X_lower, self.X_upper, self.X_lower.shape[0])]) if not self.verbose: sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ return np.array([res[0]])