def drive_optimization( population_size, dim, lower_bounds, upper_bounds, # DE-specific parameters de_strategy="DE_local_to_best", de_step_size=0.85, prob_crossover=1.0, exp_cross=False, # converge-related parameters itermax=100, dx_conv_crit=1e-6, y_conv_crit=None, # misc in_domain=None, seed=None, logger=None, after_update_opt_state=[], ): """ Driver script It uses DifferentialEvolutionAlgorithm as an implementation of Ken Price's differential evolution algorithm: [[http://www1.icsi.berkeley.edu/~storn/code.html]]. """ if logger is None: configure_logger(level=logging.CRITICAL) logger = logging.getLogger("gc3.gc3libs") if in_domain is None: def _default_in_domain(pop): return (pop < upper_bounds).all(axis=1) & (pop > lower_bounds).all(axis=1) in_domain = _default_in_domain opt = DifferentialEvolutionAlgorithm( initial_pop=np.zeros((population_size, dim)), de_step_size=de_step_size, # DE-stepsize ex [0, 2] prob_crossover=prob_crossover, # crossover probabililty constant ex [0, 1] itermax=itermax, # maximum number of iterations (generations) dx_conv_crit=dx_conv_crit, # stop when variation among x's is < this y_conv_crit=y_conv_crit, # stop when ofunc < y_conv_crit de_strategy=de_strategy, logger=logger, in_domain=in_domain, ) opt.vals = np.ones(population_size) * PENALTY_VALUE # init """ Jobs: create and manage population """ try: pop = getJobs(throw=True) except Exception as ex: # server error print ex return if not pop: # empty # Initialize population using the arguments passed to the # DifferentialEvolutionParallel initialization opt.new_pop = draw_population(lower_bds=lower_bounds, upper_bds=upper_bounds, size=population_size, dim=dim) putJobs(pop2Jobs(opt)) else: # finished? finished, count = True, 0 for job in pop: finished &= job.finished count += job.finished cur_iter = job.iteration - 1 # opt iter index start with 0 print "Iter(%d): %d finished jobs" % (cur_iter + 1, count) if opt.cur_iter != cur_iter: restoreCurrentPop(opt, cur_iter) # restore current population and iteration counter if finished: # Update population and evaluate convergence newVals = np.zeros(population_size) opt.new_pop = np.zeros((population_size, dim)) k = 0 for job in pop: opt.new_pop[k, :] = job.params newVals[k] = job.result if job.result != None else PENALTY_VALUE k += 1 opt.update_opt_state(opt.new_pop, newVals) putPop(opt) print [opt.best_y, opt.best_x] if opt.cur_iter > opt.itermax: print "Maximum number of iterations exceeded after [%d] steps. " % (opt.cur_iter) # sys.exit() if not opt.has_converged(): # Generate new population and enforce constrains opt.new_pop = opt.evolve() # Push all and run again! putJobs(pop2Jobs(opt)) return True else: # Once iteration has terminated, extract `bestval` which should represent # the element in *all* populations that lead to the closest match to the # empirical value print "Calibration converged after [%d] steps. " % (opt.cur_iter) sys.exit() # # VM's: create and manage dispatchers # vms = getVMs() # # if not vms: # empty # print "[+] No running EC2 instances found, creating %d" % N_NODES # nodes = fp_ec2_create_vms(N_NODES, pubkey_file='/home/tklauser/.ssh/id_rsa.pub') # vms = [] # for node in nodes: # vm = { 'ip' : node.public_ips[0], 'vmtype' : 'Amazon', 'dateUpdate' : str(datetime.datetime.now()) } # vms.append(vm) # putVMs(vms) # else: # pass #TODO manage VMs # Then, we could also run the forwardPremium binary here; Single script solution return False