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 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 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 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 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)
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 run(): train = 0 names = [ 'bet_multi_param', 'bet_tma_a', 'bet_tma_b', 'bet_lati_a', 'bet_lati_b', 'bet_tiew_a', 'bet_tiew_b', # 'bet_upsr_a', 'bet_upsr_b', # 'bet_sfcw_a', 'bet_sfcw_b', # 'bet_wnll_a', 'bet_wnll_b', # 'bet_tier_a', 'bet_tier_b', # 'bet_upsl_a', 'bet_upsl_b', # 'bet_ts_a', 'bet_ts_b', # 'bet_wnlw_a', 'bet_wnlw_b', # 'bet_setw_a', 'bet_setw_b', # 'bet_setl_a', 'bet_setl_b', # 'bet_gms_a', 'bet_gms_b', # 'bet_drsl_a', 'bet_drsl_b', # 'bet_tmi_a', 'bet_tmi_b', # 'bet_wnlr_a', 'bet_wnlr_b', # 'bet_upsw_a', 'bet_upsw_b', # 'bet_drs_a', 'bet_drs_b', # 'bet_setr_a', 'bet_setr_b', # 'bet_drsw_a', 'bet_drsw_b', # 'bet_tiel_a', 'bet_tiel_b', # 'bet_age_a', 'bet_age_b', # 'bet_spd_a', 'bet_spd_b', # 'bet_sfcr_a', 'bet_sfcr_b', ] tolx = 10000 # more higher then longer time params = [-14, 0, 0, 0, 0, 0, 0] bounds = [[-np.inf], [np.inf]] assert len(params) == len(names) # assert len(params) == len(bounds) if train: time_start = time() mins = 60 * 4 sigma = 1 opts = CMAOptions() 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(f'tolx={es.opts["tolx"]:.3f} sol={list(es.result[5])}') es.opts['tolx'] = es.result[3] / tolx if time() - time_start > 60 * mins: print(f'{mins}min limit reached') break 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])) # pmin = -20 # pmax = 20 # step = (pmax - pmin) / 10 # rranges = [ # slice(pmin, pmax, step), # slice(pmin, pmax, step), # ] # res = optimize.brute(main, rranges, (train,), finish=None) # print(res) # return # 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)
x_mean = encoder.predict(img[np.newaxis, ...]) fitness_func = Fitness(img, decoder) best_img = None best_z = None best_score = -1 for i in range(args.runs): print('Runs: %d / %d' % (i + 1, args.runs)) if encoder is None: init = np.random.randn(decoder.input_shape[-1]) * args.std else: init = x_mean[0] es = ES(init, args.sigma) for ite in range(args.iterations): dnas = np.asarray(es.ask()) es.tell(dnas, fitness_func(dnas)) es.disp() es.result_pretty() z = np.asarray(es.result[0]) img_reconstruct = decoder.predict(z[np.newaxis, ...])[0] mse = np.mean(np.square(img_reconstruct - img)) print('mse: {:.2f}'.format(mse)) if mse > best_score: best_score = mse best_z = z best_img = img_reconstruct output_img = np.round( np.concatenate( (np.squeeze(img), np.squeeze(img_reconstruct)), axis=1) * 127.5 + 127.5).astype(np.uint8) filename, ext = os.path.splitext(args.output) imsave(filename + '_%d' % i + ext, output_img)
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)