class EvolutionStrategy: # Wrapper for CMAEvolutionStrategy def __init__(self, mu, sigma, popsize, weight_decay=0.01): self.es = CMAEvolutionStrategy(mu.tolist(), sigma, {'popsize': popsize}) self.weight_decay = weight_decay self.solutions = None @property def best(self): best_sol = self.es.result[0] best_fit = -self.es.result[1] return best_sol, best_fit def _compute_weight_decay(self, model_param_list): model_param_grid = np.array(model_param_list) return -self.weight_decay * np.mean( model_param_grid * model_param_grid, axis=1) def ask(self): self.solutions = self.es.ask() return self.solutions def tell(self, reward_table_result): reward_table = -np.array(reward_table_result) if self.weight_decay > 0: l2_decay = self._compute_weight_decay(self.solutions) reward_table += l2_decay self.es.tell(self.solutions, reward_table.tolist())
def runSingleSplit_pycma(fid, dim, iids=[1, 2, 3, 4, 5], num_reps=5): """ Function running single-split CMA-ES. :param fid: The function id (from bbob) :param dim: The dimension to run the bbob-problem in :param rep1: The configuration to run before the splitpoint :param rep2: The configuration to run after the splitpoint :param split_idx: The splitpoint-index at which to switch between rep1 and rep2 :param iids: The instances of the bbob-function to run :param num_reps: The amount of repetitions to run :return: The ERT over all num_reps runs on all instances in iids """ obs = create_observer("Pycma", None, None) suite = cocoex.Suite("bbob", "", f"dimensions:{dim}") HittingTimes = [] for i, iid in enumerate(iids): for j in range(num_reps): fitness_function = suite.get_problem_by_function_dimension_instance( fid, dim, iid) fitness_function.observe_with(obs) f = fitnessFunc(fitness_function) cma = CMAEvolutionStrategy([0] * 5, 0.5) cma.optimize(f) HittingTimes.append(cma.result.evaluations) print(cma.result.xbest) fitness_function.free() return np.mean(HittingTimes)
def __build__(self, init_mean_parameters: Sequence): self._evolution_strategy = CMAEvolutionStrategy( init_mean_parameters, self._parameters_variance, # Sigma is shared {"popsize": self._num_candidate_policies}, ) # Population size self._resample_shared_parameters() self.policy.set_param_values(self._shared_params[0])
def evaluate(mth, run_i, seed): print(mth, run_i, seed, '===== start =====', flush=True) def objective_function(config): y = problem.evaluate_config(config) return y from cma import CMAEvolutionStrategy from litebo.utils.util_funcs import get_types from litebo.utils.config_space import Configuration types, bounds = get_types(cs) assert all(types == 0) # Check Constant Hyperparameter const_idx = list() for i, bound in enumerate(bounds): if np.isnan(bound[1]): const_idx.append(i) hp_num = len(bounds) - len(const_idx) es = CMAEvolutionStrategy(hp_num * [0], 0.99, inopts={'bounds': [0, 1], 'seed': seed}) global_start_time = time.time() global_trial_counter = 0 config_list = [] perf_list = [] time_list = [] eval_num = 0 while eval_num < max_runs: X = es.ask(number=es.popsize) _X = X.copy() for i in range(len(_X)): for index in const_idx: _X[i] = np.insert(_X[i], index, 0) # np.insert returns a copy # _X = np.asarray(_X) values = [] for xi in _X: # convert array to Configuration config = Configuration(cs, vector=xi) perf = objective_function(config) global_time = time.time() - global_start_time global_trial_counter += 1 values.append(perf) print('=== CMAES Trial %d: %s perf=%f global_time=%f' % (global_trial_counter, config, perf, global_time)) config_list.append(config) perf_list.append(perf) time_list.append(global_time) values = np.reshape(values, (-1,)) es.tell(X, values) eval_num += es.popsize print('===== Total evaluation times=%d. Truncate to max_runs=%d.' % (eval_num, max_runs)) config_list = config_list[:max_runs] perf_list = perf_list[:max_runs] time_list = time_list[:max_runs] return config_list, perf_list, time_list
def init_optimization_strategy(self, *args, **kwds): """ init_optimization_strategy initializes optimizer object. Its argument depend on the specific initializer used IN the case of the CMA optimizer the options are described here: https://pypi.python.org/pypi/cma :param args: see https://pypi.python.org/pypi/cma :param kwds: see https://pypi.python.org/pypi/cma :return: None """ self.optim = CMAEvolutionStrategy(*args, **kwds)
def create_optimizer(self): from cma import CMAEvolutionStrategy opts = {'bounds': self.bounds} stddevs = (self.param_space.param_uppers - self.param_space. param_lowers) * self.stddev + self.param_space.param_lowers optimizer = CMAEvolutionStrategy(self.init_guess, np.amin(stddevs), inopts=opts) _ = optimizer.optimize(self._priv_evaluator) self.is_converged = True
def initialize(self, **kwargs): super().initialize(**kwargs) if self.x0 is None: self.x0 = self.domain.l + self.domain.range / 2 # cma operates on normalized scale x0 = self.domain.normalize(self.x0) self.cma = CMAEvolutionStrategy(x0=x0, sigma0=self.config.sigma0, inopts={'bounds': [0, 1]}) self._X = None self._X_i = 0 self._Y = None
def fit(self, my_lambda, coverage=3, max_iters=50): #while(True): print('beta = ', self.my_beta) print('lambda = ', my_lambda) my_args = (self, my_lambda, coverage, False) nfeatures = self.train_args['feature'].shape[1] w0 = self.randomw0(nfeatures) sigma_value = 0.02 print('sigma0 ', sigma_value) es = CMAEvolutionStrategy(w0, sigma0=sigma_value, inopts={ 'maxiter': max_iters, 'popsize': 40 }) while not es.stop(): solutions = es.ask() fitnesses = [ InterestingnessLearner.cost(x, *my_args) for x in solutions ] es.tell(solutions, fitnesses) es.disp() self.nmcost(es.result[0], my_lambda, coverage, is_debug=True) final_model = self.createClassifier(es.result[0], coverage) print(final_model.size(), final_model.meanSupport()) return final_model
def cma(fun, budget): sigma0 = 0.02 range_ = fun.upper_bounds - fun.lower_bounds center = fun.lower_bounds + range_ / 2 x0 = center options = dict(scaling=range_ / range_[0], maxfevals=budget, verb_log=0, verb_disp=1, verbose=1) es = CMAEvolutionStrategy(x0, sigma0 * range_[0], options) res = es.optimize(fun).result() xbest, ybest, nbeval, *rest = res return xbest, ybest, nbeval
def example_cma(): def yangs4(x): # f = (a-b).c a = np.sum(np.square(np.sin(x))) b = np.exp(-np.sum(np.square(x))) c = np.exp(-np.sum(np.square(np.sin(np.sqrt(np.abs(x)))))) return (a - b) * c n = 5 x0 = n * [0.1] sigma0 = 0.1 # evolution strategy es = CMAEvolutionStrategy(x0, sigma0) optSol = es.optimize(yangs4)
def main(): # param length # 10 fights # rating_mu, rating_sig, wins, losses, odds input_params_len = 10 * 2 * 4 es = CMAEvolutionStrategy([0] * input_params_len, 0.5) while not es.stop(): solutions = es.ask() func_vals = [get_betting_result(x) for x in solutions] es.tell(solutions, func_vals) es.logger.add() # write data to disc to be plotted es.disp() es.result_pretty()
def init_algo(self): init_min_bound = self.boundary.init_min_bounds[0] init_max_bound = self.boundary.init_max_bounds[0] min_bound = self.boundary.min_bounds[0] max_bound = self.boundary.max_bounds[0] if self.algo_type == 'CMA': init_point = [(init_max_bound + init_min_bound) / 2] * dimension sigma = (init_max_bound - init_min_bound) * 0.2 #print 'init_point:', init_point #print 'sigma:', sigma self.algo = CMAEvolutionStrategy(init_point, sigma, { 'popsize': self.n_points, 'bounds': [min_bound, max_bound] })
def maximize(self, runhistory: HistoryContainer, num_points: int, **kwargs) -> Iterable[Tuple[float, Configuration]]: try: from cma import CMAEvolutionStrategy except ImportError: raise ImportError("Package cma is not installed!") types, bounds = get_types(self.config_space) assert all(types == 0) # Check Constant Hyperparameter const_idx = list() for i, bound in enumerate(bounds): if np.isnan(bound[1]): const_idx.append(i) hp_num = len(bounds) - len(const_idx) es = CMAEvolutionStrategy(hp_num * [0], 0.99, inopts={'bounds': [0, 1]}) eval_num = 0 next_configs_by_acq_value = list() while eval_num < num_points: X = es.ask(number=es.popsize) _X = X.copy() for i in range(len(_X)): for index in const_idx: _X[i] = np.insert(_X[i], index, 0) _X = np.asarray(_X) values = self.acquisition_function._compute(_X) values = np.reshape(values, (-1, )) es.tell(X, values) next_configs_by_acq_value.extend([(values[i], _X[i]) for i in range(es.popsize)]) eval_num += es.popsize next_configs_by_acq_value.sort(reverse=True, key=lambda x: x[0]) next_configs_by_acq_value = [_[1] for _ in next_configs_by_acq_value] next_configs_by_acq_value = [ Configuration(self.config_space, vector=array) for array in next_configs_by_acq_value ] challengers = ChallengerList(next_configs_by_acq_value, self.config_space, self.random_chooser) self.random_chooser.next_smbo_iteration() return challengers
def main(filename, directory): initialFilename = os.path.join(directory, 'initial.json') genDir = os.path.join(directory, 'gens') finalFilename = os.path.join(directory, 'final.json') baseCondor = 'base.condor' with open(baseCondor, 'r') as f: condorConfig = f.read() optMkdir(directory) optMkdir(genDir) shutil.copyfile(filename, initialFilename) with open(filename, 'r') as f: conf = json.load(f) paramNames = [] paramVals = [] flattenParams(conf, paramNames, paramVals, '') sigma0 = SIGMA0 opts = Options() opts['popsize'] = POP_SIZE #opts.printme() cma = CMAEvolutionStrategy(paramVals, sigma0, opts) while (cma.countiter < NUM_GENS) and not (cma.stop()): thisGenDir = os.path.join(genDir, str(cma.countiter)) optMkdir(thisGenDir) xs = cma.ask() xs, fits = runEvals(paramNames, xs, cma.countiter, thisGenDir, condorConfig) cma.tell(xs, fits) res = cma.result() paramsToJsonFile(finalFilename, paramNames, res[0])
class CMAES(Algorithm): def initialize(self, **kwargs): super().initialize(**kwargs) if self.x0 is None: self.x0 = self.domain.l + self.domain.range / 2 # cma operates on normalized scale x0 = self.domain.normalize(self.x0) self.cma = CMAEvolutionStrategy(x0=x0, sigma0=self.config.sigma0, inopts={'bounds': [0, 1]}) self._X = None self._X_i = 0 self._Y = None def _next(self, context=None): if self._X is None: # get new population self._X = self.cma.ask() self._Y = np.empty(len(self._X)) self._X_i = 0 return self.domain.denormalize(self._X[self._X_i]) def finalize(self): self.cma.result_pretty() def best_predicted(self): xbest = None if self.cma.result.xbest is not None: xbest = self.domain.denormalize(self.cma.result.xbest) return xbest if not xbest is None else self.x0 def add_data(self, data): self._Y[self._X_i] = data['y'] self._X_i += 1 # population complete if self._X_i == len(self._X): self.cma.tell(self._X, -self._Y) self._X = None super().add_data(data)
def __init__(self, expt_dir): raise NotImplementedError('The CMA chooser is not yet implemented!') self.state_pkl = os.path.join(expt_dir, self.__module__ + ".pkl") #TODO: params needs to be an array of starting values # - need to figure out how to map Spearmint params into # all floats usable by the evolution strategy. self.optimizer = CMAEvolutionStrategy(params)
def init_algos(self): del self.algos[:] if self.algo_type == 'CMA': for cluster in self.clusters: self.algos.append( CMAEvolutionStrategy([0.5] * self.dimension, 0.2, { 'popsize': self.n_points, 'bounds': [0, 1] })) for algo in self.algos: new_trans_positions = algo.ask()
def otimizar(self): lw = [0.0, 0.0, 0.0] up = [1.0, 1.0, 1.0] x0 = 3 * [0.1] sigma = 0.25 # Otimizando c = CMAEvolutionStrategy(x0, sigma, {'bounds': [lw, up]}) self.iniciar_tempo() c.optimize(self.func_objetivo, iterations=self.num_chamadas) self.finalizar_tempo() # Extraindo os melhores hiperparametros C_ = 2 ** (-5 + c.best.x[0] * 20) gamma_ = 2 ** (-15 + c.best.x[1] * 18) epsilon_ = abs(c.best.x[2]) # Treinando SVM final com os parâmetros encontrados self.svm = SVM(gamma_, C_, epsilon_) self.svm.treinar(self.X_treinamento, self.Y_treinamento) self.svm.testar(self.X_teste, self.Y_teste)
def main(): bias0 = [0.0, -3.0] * total_biases weight0 = [0.0, -3.0] * total_weights x0 = bias0 x0.extend(weight0) # assert(len(x0) == 108) sigma0 = 0.1 # evolution strategy es = CMAEvolutionStrategy(x0, sigma0) optSol = es.optimize(regression_problem) print(optSol) sol = [-3.18979598e-02, 1.21945777e+00, 3.80408518e-02, 7.99747577e-01, 9.51714572e-02, 8.10528673e-01, -5.97132372e-02, 1.04204663e+00, 1.74305244e-02, 9.93532532e-01, -8.67464165e-02, 9.51615254e-01, -3.77311791e-02, 9.97444596e-01, -5.84591048e-03, 1.08793924e+00, -5.59697903e-02, 9.51347690e-01, 3.33323542e-02, 1.00693954e+00]
def main(filename, directory): initialFilename = os.path.join(directory, "initial.json") genDir = os.path.join(directory, "gens") finalFilename = os.path.join(directory, "final.json") baseCondor = "base.condor" with open(baseCondor, "r") as f: condorConfig = f.read() optMkdir(directory) optMkdir(genDir) shutil.copyfile(filename, initialFilename) with open(filename, "r") as f: conf = json.load(f) paramNames = [] paramVals = [] flattenParams(conf, paramNames, paramVals, "") sigma0 = SIGMA0 opts = Options() opts["popsize"] = POP_SIZE # opts.printme() cma = CMAEvolutionStrategy(paramVals, sigma0, opts) while (cma.countiter < NUM_GENS) and not (cma.stop()): thisGenDir = os.path.join(genDir, str(cma.countiter)) optMkdir(thisGenDir) xs = cma.ask() xs, fits = runEvals(paramNames, xs, cma.countiter, thisGenDir, condorConfig) cma.tell(xs, fits) res = cma.result() paramsToJsonFile(finalFilename, paramNames, res[0])
class CMAES: def __init__(self, x0, s0=0.5, opts={}): """ wrapper around cma.CMAEvolutionStrategy """ self.num_parameters = len(x0) print('{} params in controller'.format(self.num_parameters)) self.solver = CMAEvolutionStrategy(x0, s0, opts) def __repr__(self): return '<pycma wrapper>' def ask(self): """ sample parameters """ samples = self.solver.ask() return np.array(samples).reshape(-1, self.num_parameters) def tell(self, samples, fitness): """ update parameters with total episode reward """ return self.solver.tell(samples, -1 * fitness) @property def mean(self): return self.solver.mean
def setup(self): # dummy_env = gym.make(sellf.args.env_name) # num_actions = dummy_env.action_space.n # dummy_c = ControlModel(encoder=self.model, # num_actions=num_actions) num_params = np.prod(self.model.fc.weight.size()) + np.prod( self.model.fc.bias.size()) param0 = np.random.randn(num_params) es = CMAEvolutionStrategy(param0, sigma0=1, inopts={"popsize": self.args.workers + 1}) #maximize return es
def evolve_greedy_policies(model_dist: ModelDist, iterations: int = 30, population_size: int = 5): """ Evolves the greedy policy to find the best policies :param model_dist: Model distribution :param iterations: Number of evolutions :param population_size: The population size """ print(f'Evolves the greedy policies for {model_dist.name} model with ' f'{model_dist.num_tasks} tasks and {model_dist.num_servers} servers') eval_tasks, eval_servers = model_dist.generate_oneshot() lower_bound = greedy_algorithm(eval_tasks, eval_servers, ValuePriority(), ProductResources(), SumSpeed()).social_welfare print(f'Lower bound is {lower_bound}') reset_model(eval_tasks, eval_servers) evolution_strategy = CMAEvolutionStrategy( 11 * [1], 0.2, {'population size': population_size}) for iteration in range(iterations): suggestions = evolution_strategy.ask() tasks, servers = model_dist.generate_oneshot() solutions = [] for i, suggestion in enumerate(suggestions): solutions.append( greedy_algorithm( tasks, servers, TaskPriorityEvoStrategy(i, *suggestion[:5]), ServerSelectionEvoStrategy(i, *suggestion[5:8]), ResourceAllocationEvoStrategy( i, *suggestion[8:11])).social_welfare) reset_model(tasks, servers) evolution_strategy.tell(suggestions, solutions) evolution_strategy.disp() if iteration % 2 == 0: evaluation = greedy_algorithm( eval_tasks, eval_servers, TaskPriorityEvoStrategy(0, *suggestions[0][:5]), ServerSelectionEvoStrategy(0, *suggestions[0][5:8]), ResourceAllocationEvoStrategy(0, *suggestions[0][8:11])) print(f'Iter: {iteration} - {evaluation.social_welfare}') pprint.pprint(evolution_strategy.result())
def run(): train = 0 names = [ # 'bet_pred_a', 'bet_pred_b', 'bet_odds_a', 'bet_odds_b', 'bet_wnl_a', 'bet_wnl_b', 'bet_ts_a', 'bet_ts_b', 'bet_tmi_a', 'bet_tmi_b', 'bet_tma_a', 'bet_tma_b', ] params = [ 0, 0, 0, 0, 0, 0 ] bounds = [[-np.inf], [np.inf]] assert len(params) == len(names) # assert len(params) == len(bounds[0]) if train: sigma = 1 opts = CMAOptions() # opts['tolx'] = 1E-2 opts['bounds'] = bounds es = CMAEvolutionStrategy(params, sigma, inopts=opts) while not es.stop(): solutions = es.ask() fitness = [main(x, train=1) for x in solutions] es.tell(solutions, fitness) es.disp() print(list(es.result[0])) print(list(es.result[5])) es.result_pretty() print('') print('best') print(list(es.result[0])) print('') print('xfavorite: distribution mean in "phenotype" space, to be considered as current best estimate of the optimum') print(list(es.result[5])) else: main(params)
def shift_matrix(self, i, best_point): center = self.clusters[i].transform_inverse([[0.5] * self.dimension ])[0] translate = best_point - center translate_matrix = np.eye(self.dimension + 1) translate_matrix[0:-1, -1] = -translate.T self.clusters[i].matrix = np.dot(self.clusters[i].matrix, translate_matrix) #self.update_matrix(i) if self.algo_type == 'CMA': self.algos[i] = CMAEvolutionStrategy([0.5] * self.dimension, 0.2, { 'popsize': self.n_points, 'bounds': [0, 1] }) init_positions = self.algos[i].ask()
def update_borders(self): for i in range(len(self.clusters)): cluster = self.clusters[i] len_bounds = np.linalg.norm(cluster.border[1] - cluster.border[1]) es = CMAEvolutionStrategy( cluster.border.ravel().tolist(), len_bounds * 0.1, { 'bounds': [self.boundary.min_bounds[0], self.boundary.max_bounds[0]] }) while not es.stop(): solutions = es.ask() #TODO es.tell( solutions, [self.evaluate_border(border, i) for border in solutions]) #es.tell( solutions, [cluster.evaluate_border(border) for border in solutions] ) x_best = es.result()[0] #if x_best is not None and cluster.in_global_border( x_best ): if x_best is not None: cluster.border = x_best.reshape(cluster.border.shape) '''
def cma_minimize(acq_function, bounds, return_best_only=True, **kwargs) -> Tuple[torch.Tensor, ...]: x0 = 0.5 * np.ones(bounds.shape[-1]) opts = { 'bounds': [0, 1], "popsize": kwargs.get('popsize', 100), "seed": 10, "verbose": -1 } if "maxiter" in kwargs: opts.update(maxiter=kwargs["maxiter"]) es = CMAEvolutionStrategy(x0=x0, sigma0=kwargs.get('sigma0', 0.5), inopts=opts) xs_list, y_list = [], [] with torch.no_grad(): while not es.stop(): xs = es.ask() X = torch.tensor(xs, dtype=torch.float64) Y = acq_function(X.unsqueeze(-2)) y = Y.view(-1).double().numpy() es.tell(xs, y) xs_list.append(xs) y_list.append(y) if return_best_only: cand = torch.tensor([es.best.x]) cand_val = torch.tensor([es.best.f]) else: cand = torch.tensor(np.concatenate(xs_list, axis=0)) cand_val = torch.tensor(np.concatenate(y_list, axis=0)) return cand, cand_val
def run_optimization(self): """ Runs optimization job :return: """ simulation_name = self.parse_args.input population_size = self.parse_args.population_size self.optim_param_mgr = OptimizationParameterManager() optim_param_mgr = self.optim_param_mgr # optim_param_mgr.parse(args.params_file) optim_param_mgr.parse(self.parse_args.params_file) starting_params = optim_param_mgr.get_starting_points() print 'starting_params (mapped to [0,1])=', starting_params print 'remapped (true) starting params=', optim_param_mgr.params_from_0_1(starting_params) print 'dictionary of remapped parameters labeled by parameter name=', optim_param_mgr.param_from_0_1_dict( starting_params) print 'simulation_name=', simulation_name self.workload_dict = self.prepare_optimization_run(simulation_name=simulation_name) workload_dict = self.workload_dict print workload_dict std_dev = optim_param_mgr.std_dev default_bounds = optim_param_mgr.default_bounds optim = CMAEvolutionStrategy(starting_params, std_dev, {'bounds': list(default_bounds)}) while not optim.stop(): # iterate # get candidate solutions # param_set_list = optim.ask(number=self.num_workers) # param_set_list = optim.ask(number=1) param_set_list = optim.ask(number=population_size) # set param_set_list for run_task to iterate over self.set_param_set_list(param_set_list=param_set_list) # #debug # return_result_vec = [self.fcn(optim_param_mgr.params_from_0_1(X)) for X in param_set_list] # evaluate targert function values at the candidate solutions return_result_vec = np.array([], dtype=float) for param_set in self.param_generator(self.num_workers): print 'CURRENT PARAM SET=', param_set # distribution param_set to workers - run tasks spawns appropriate number of workers # given self.num_workers and the size of the param_set partial_return_result_vec = self.run_task(workload_dict, param_set) return_result_vec = np.append(return_result_vec, partial_return_result_vec) print 'FINISHED PARAM_SET=', param_set optim.tell(param_set_list, return_result_vec) # do all the real "update" work optim.disp(20) # display info every 20th iteration optim.logger.add() # log another "data line" optimal_parameters = optim.result()[0] print('termination by', optim.stop()) print('best f-value =', optim.result()[1]) optimal_parameters_remapped = optim_param_mgr.params_from_0_1(optim.result()[0]) print('best solution =', optimal_parameters_remapped) # print('best solution =', optim_param_mgr.params_from_0_1(optim.result()[0])) print optim_param_mgr.params_names self.save_optimal_parameters(optimal_parameters) self.save_optimal_simulation(optimal_parameters)
def __init__(self, mu, sigma, popsize, weight_decay=0.01): self.es = CMAEvolutionStrategy(mu.tolist(), sigma, {'popsize': popsize}) self.weight_decay = weight_decay self.solutions = None
def train(self, cost, model, x_data, y_data=None, tolfun=1e-11, popsize=None, maxiter=None, use_grad=False): """Trains the ``model`` using the custom `cost` function. Args: cost (theta.costfunctions): the cost function. model (theta.model.Model or theta.rtbm.RTBM): the model to be trained. x_data (numpy.array): the support data with shape (Nv, Ndata). y_data (numpy.array): the target prediction. tolfun (float): the maximum tolerance of the cost function fluctuation to stop the minimization. popsize (int): the population size. maxiter (int): the maximum number of iterations. use_grad (bool): if True the gradients for the cost and model are used in the minimization. Returns: numpy.array: the optimal parameters Note: The parameters of the model are changed by this algorithm. """ initsol = np.real(model.get_parameters()) args = {'bounds': model.get_bounds(), 'tolfun': tolfun, 'verb_log': 0} sigma = np.max(model.get_bounds()[1])*0.1 if popsize is not None: args['popsize'] = popsize if maxiter is not None: args['maxiter'] = maxiter grad = None if use_grad: grad = worker_gradient es = CMAEvolutionStrategy(initsol, sigma, args) if self.num_cores > 1: with closing(mp.Pool(self.num_cores, initializer=worker_initialize, initargs=(cost, model, x_data, y_data))) as pool: while not es.stop(): f_values, solutions = [], [] while len(solutions) < es.popsize: x = es.ask(es.popsize-len(solutions), gradf=grad) curr_fit = pool.map_async(worker_compute, x).get() for value, solution in zip(curr_fit,x): if not np.isnan(value): solutions.append(solution) f_values.append(value) es.tell(solutions, f_values) es.disp() pool.terminate() else: worker_initialize(cost, model, x_data, y_data) while not es.stop(): f_values, solutions = [], [] while len(solutions) < es.popsize: curr_fit = x = np.NaN while np.isnan(curr_fit): x = es.ask(1, gradf=grad)[0] curr_fit = worker_compute(x) solutions.append(x) f_values.append(curr_fit) es.tell(solutions, f_values) es.disp() print(es.result) model.set_parameters(es.result[0]) return es.result[0]
def run(): train = 0 names = [ # 'pred_a', 'pred_b', # 0.0 # 'odds_a', 'odds_b', # 2.1 # 'bet_wnl_a', 'bet_wnl_b', # 2.1 # 'bet_ts_a', 'bet_ts_b', # 1.5 # 'bet_tmi_a', 'bet_tmi_b', # 1.1 # 'bet_tma_a', 'bet_tma_b', # 0.9 # 'bet_drs_a', 'bet_drs_b', # 0.5 'bet_sfc_a', 'bet_sfc_b', # -0.1 # 'bet_spd_a', 'bet_spd_b', # 0.8 # 'bet_set_a', 'bet_set_b', # 1.0 # 'bet_gms_a', 'bet_gms_b', # -0.2 # 'bet_tie_a', 'bet_tie_b', # 4.1 # 'bet_ups_a', 'bet_ups_b', # -0.2 # 'bet_age_a', 'bet_age_b', # -2.5 ] params = [0, 0] bounds = [[-np.inf], [np.inf]] assert len(params) == len(names) assert len(params) == len(bounds) if train: sigma = 1 opts = CMAOptions() # opts['tolx'] = 1E-2 opts['bounds'] = bounds es = CMAEvolutionStrategy(params, sigma, inopts=opts) while not es.stop(): solutions = es.ask() try: fitness = [main(x, train) for x in solutions] except ValueError as exc: print(str(exc)) continue es.tell(solutions, fitness) es.disp() print(list(es.result[0])) print(list(es.result[5])) es.result_pretty() print( f'finished after {es.result[3]} evaluations and {es.result[4]} iterations' ) print('') print('best') print(list(es.result[0])) print('') print( 'xfavorite: distribution mean in "phenotype" space, to be considered as current best estimate of the optimum' ) print(list(es.result[5])) # res = minimize(main, params, (train,), bounds=bounds) # print('') # print(f'{res.nit} iterations') # print(f'Success: {res.success} {res.message}') # print(f'Solution: {res.x}') # return else: main(params)
class CMAOptimizationSteppable(SteppableBasePy): def __init__(self, _simulator, _frequency=1): SteppableBasePy.__init__(self, _simulator, _frequency) self.optim = None self.sim_length_mcs = self.simulator.getNumSteps() - 1 self.f_vec = [] self.X_vec = [] self.X_vec_check = [] self.num_fcn_evals = -1 def minimized_fcn(self, *args, **kwds): """ this function needs to be overloaded in the subclass - it implements simulation fitness metric :return {float}: number describing the "fitness" of the simulation """ return 0.0 def initial_condition_fcn(self, *args, **kwds): """ This function prepares initial condition for the simulaiton. Typically it creates cell field and initializes all cell and field properties :param args: first argument is a vector of parameters that are being optimized. The rest are up to the user :param kwds: key words arguments - those are are up to the user :return: None """ pass def init_optimization_strategy(self, *args, **kwds): """ init_optimization_strategy initializes optimizer object. Its argument depend on the specific initializer used IN the case of the CMA optimizer the options are described here: https://pypi.python.org/pypi/cma :param args: see https://pypi.python.org/pypi/cma :param kwds: see https://pypi.python.org/pypi/cma :return: None """ self.optim = CMAEvolutionStrategy(*args, **kwds) def optimization_step(self, mcs): """ THis function implements houklsekeeping associated with running optimization algorithm in a steppable :param mcs {int}: current mcs :return: None """ if not mcs % self.sim_length_mcs: if self.optim.stop(): self.stopSimulation() print('termination by', self.optim.stop()) print('best f-value =', self.optim.result()[1]) print('best solution =', self.optim.result()[0]) if not len(self.X_vec): self.X_vec = self.optim.ask() if len(self.f_vec): # print 'self.X_vec_check=', self.X_vec_check # print 'self.f_vec=', self.f_vec self.optim.tell(self.X_vec_check, self.f_vec) # do all the real "update" work self.optim.disp(20) # display info every 20th iteration self.optim.logger.add() # log another "data line" self.f_vec = [] self.num_fcn_evals = len(self.X_vec) self.X_vec_check = deepcopy(self.X_vec) self.X_current = self.X_vec[0] if len(self.X_vec_check) != self.num_fcn_evals: fcn_target = self.minimized_fcn() self.f_vec.append(fcn_target) self.X_vec.pop(0) self.num_fcn_evals -= 1 CompuCellSetup.reset_current_step(0) self.simulator.setStep(0) self.clean_cell_field(reset_inventory=True) self.initial_condition_fcn(self.X_current)
def run_optimization(self): """ Runs optimization job :return: """ simulation_name = self.parse_args.input population_size = self.parse_args.population_size self.optim_param_mgr = OptimizationParameterManager() optim_param_mgr = self.optim_param_mgr # optim_param_mgr.parse(args.params_file) optim_param_mgr.parse(self.parse_args.params_file) starting_params = optim_param_mgr.get_starting_points() print 'starting_params (mapped to [0,1])=', starting_params print 'remapped (true) starting params=', optim_param_mgr.params_from_0_1( starting_params) print 'dictionary of remapped parameters labeled by parameter name=', optim_param_mgr.param_from_0_1_dict( starting_params) print 'simulation_name=', simulation_name self.workload_dict = self.prepare_optimization_run( simulation_name=simulation_name) workload_dict = self.workload_dict print workload_dict std_dev = optim_param_mgr.std_dev default_bounds = optim_param_mgr.default_bounds optim = CMAEvolutionStrategy(starting_params, std_dev, {'bounds': list(default_bounds)}) while not optim.stop(): # iterate # get candidate solutions # param_set_list = optim.ask(number=self.num_workers) # param_set_list = optim.ask(number=1) param_set_list = optim.ask(number=population_size) # set param_set_list for run_task to iterate over self.set_param_set_list(param_set_list=param_set_list) # #debug # return_result_vec = [self.fcn(optim_param_mgr.params_from_0_1(X)) for X in param_set_list] # evaluate targert function values at the candidate solutions return_result_vec = np.array([], dtype=float) for param_set in self.param_generator(self.num_workers): print 'CURRENT PARAM SET=', param_set # distribution param_set to workers - run tasks spawns appropriate number of workers # given self.num_workers and the size of the param_set partial_return_result_vec = self.run_task( workload_dict, param_set) return_result_vec = np.append(return_result_vec, partial_return_result_vec) print 'FINISHED PARAM_SET=', param_set optim.tell(param_set_list, return_result_vec) # do all the real "update" work optim.disp(20) # display info every 20th iteration optim.logger.add() # log another "data line" optimal_parameters = optim.result()[0] print('termination by', optim.stop()) print('best f-value =', optim.result()[1]) optimal_parameters_remapped = optim_param_mgr.params_from_0_1( optim.result()[0]) print('best solution =', optimal_parameters_remapped) # print('best solution =', optim_param_mgr.params_from_0_1(optim.result()[0])) print optim_param_mgr.params_names self.save_optimal_parameters(optimal_parameters) self.save_optimal_simulation(optimal_parameters)