def test_sphere(self): problem = Sphere() for algorithm in [NelderMead(), PatternSearch(), PSO(), GA()]: f, f_opt = test(problem, algorithm) self.assertAlmostEqual(f, f_opt, places=5) print(problem.__class__.__name__, algorithm.__class__.__name__, "Yes")
def test_ask_and_tell(self): # create the algorithm object to be used algorithm = GA(pop_size=100, eliminate_duplicates=True) # create the ask and tell interface object api = AskAndTell(algorithm, n_var=2, n_obj=1, n_constr=1, xl=-10, xu=10) # this loop runs always one step of the algorithm for gen in range(100): # ask the algorithm for values to be evaluated X = api.ask() # evaluate the values - here just some easy calculations F = np.sum(np.square(X), axis=1)[:, None] G = 1 - np.abs(X[:, 0])[:, None] # let the api objects know the objective and constraint values api.tell(F, G=G) print(api.get_population().get("F").min()) # retrieve the results form the api - here the whole population of the algorithm X, F, CV = api.result(only_optimum=False, return_values_of=["X", "F", "CV"]) self.assertTrue(np.allclose(CV, 0)) self.assertTrue(np.allclose(F[:10], 1, atol=1.e-5))
def __init__(self: object, optim: object = None, verbose: bool = False, infill: bool = False): self.eps = 2.22e-16 self.verbose = verbose self.optim = optim self.infill = infill self.n_feat = len(self.optim.var_min) // 2 if self.infill: self.param_objective = lambda params: self.__infill_objective( params) else: self.param_objective = lambda params: self.__parameters_objective( params) self.krigopt = KrigOptim(self.param_objective, optim) self.algorithm = GA( pop_size=optim.num_pop, eliminate_duplicates=True ) #DE(pop_size=optim.num_pop) #PSO(pop_size=optim.num_pop) # if self.verbose: print("Initialized Kriging object with : \n") self.__print_optim__()
def optimize(self, initial_suggest: pd.DataFrame = None, fix_input: dict = None) -> pd.DataFrame: lb = self.space.opt_lb.numpy() ub = self.space.opt_ub.numpy() prob = BOProblem(lb, ub, self.acq, self.space, fix_input) init_pop = self.get_init_pop(initial_suggest) mutation = self.get_mutation() crossover = self.get_crossover() if self.acq.num_obj > 1: algo = NSGA2(pop_size=self.pop, sampling=init_pop, mutation=mutation, crossover=crossover) else: algo = GA(pop_size=self.pop, sampling=init_pop, mutation=mutation, crossover=crossover) res = minimize(prob, algo, ('n_gen', self.iter), verbose=self.verbose) opt_x = res.X.reshape(-1, len(lb)).astype(float) opt_xcont = torch.from_numpy(opt_x[:, :self.space.num_numeric]) opt_xenum = torch.from_numpy(opt_x[:, self.space.num_numeric:]) df_opt = self.space.inverse_transform(opt_xcont, opt_xenum) if fix_input is not None: for k, v in fix_input.items(): df_opt[k] = v return df_opt
def test_sphere_with_constraints(self): problem = SphereWithConstraints() for algorithm in [GA(), NelderMead(), PatternSearch(), CuckooSearch()]: f, f_opt = test(problem, algorithm) self.assertAlmostEqual(f, f_opt, places=3) print(problem.__class__.__name__, algorithm.__class__.__name__, "Yes")
def genetic_algorithm(): algorithm = GA(population_size=100, individual_size=2, eliminate_duplicates=True) res = minimize(problem, algorithm, seed=1, verbose=False) print("Best solution found: \nX = %s\nF = %s" % (res.X, res.F))
def _subset_selection(pop, nd_F, K): problem = SubsetProblem(pop.get("F")[:, 1], nd_F, K) algorithm = GA(pop_size=100, sampling=MySampling(), crossover=BinaryCrossover(), mutation=MyMutation(), eliminate_duplicates=True) res = minimize(problem, algorithm, ('n_gen', 60), verbose=False) return res.X
def test_crossover(self): for crossover in ['real_de', 'real_sbx', 'real_exp']: print(crossover) method = GA(pop_size=20, crossover=get_crossover(crossover, prob=0.95)) minimize(get_problem("sphere"), method, ("n_gen", 20)) for crossover in [ 'bin_ux', 'bin_hux', 'bin_one_point', 'bin_two_point' ]: print(crossover) method = NSGA2(pop_size=20, crossover=get_crossover(crossover, prob=0.95)) minimize(get_problem("zdt5"), method, ("n_gen", 20))
def run(cross=0.7, ag=None, mut=0.01): algorithm = GA( pop_size=100, sampling=get_sampling("real_random"), crossover=get_crossover("real_one_point", prob=cross), mutation=get_mutation("real_pm", eta=20, prob=mut), #bin_bitflip n_offsprings=ag, #ag=1 -> steady-state, ag=None -> geracional eliminate_duplicates=True) X, F = problem.evaluate(np.random.rand(100, 1), return_values_of=["X", "F"]) termination = get_termination("n_eval", 25000) res = minimize( problem, algorithm, ('n_gen', 200), termination, seed=10, # elitismo verbose=False) return X, F, res
def solve(seq_length, problem, sampling=None): if sampling is None: sampling = LevelOrderSampling() subproblem = FixedNumberOfShipsProblem(problem, seq_length) termination = MyTermination(f_tol_abs=0.1) algorithm = GA(pop_size=100, sampling=sampling, crossover=BinaryCrossover(), mutation=MyMutation(), eliminate_duplicates=True) res = minimize( subproblem, algorithm, termination, # ('n_gen', 20), seed=1, verbose=False) return res
def _do(self): pop_size, n_gen = self.pop_size, self.n_gen n_points, n_dim, = self.n_points, self.n_dim fun = self.fun class MyProblem(Problem): def __init__(self): self.n_points = n_points self.n_dim = n_dim self.n_partitions = get_partition_closest_to_points(n_points, n_dim) super().__init__(n_var=n_points * n_dim, n_obj=1, n_constr=0, xl=0.0, xu=1.0, elementwise_evaluation=True) def get_points(self, x): _x = x.reshape((self.n_points, self.n_dim)) ** 2 _x = _x / _x.sum(axis=1)[:, None] return _x def _evaluate(self, x, out, *args, **kwargs): out["F"] = fun(self.get_points(x)) problem = MyProblem() algorithm = GA(pop_size=pop_size, eliminate_duplicates=True) res = minimize(problem, algorithm, termination=('n_gen', n_gen), verbose=True) ref_dirs = problem.get_points(res.X) return ref_dirs
def run_singleJ(dict_t): # def run_multiJ(): mask = [ "real", "int", "real", "real", "int", "int", "int", "int", "int", "int", "int" ] sampling = MixedVariableSampling(mask, { "real": get_sampling("real_random"), "int": get_sampling("int_random") }) crossover = MixedVariableCrossover( mask, { "real": get_crossover("real_sbx", prob=0.2, eta=3.0), "int": get_crossover("int_sbx", prob=0.2, eta=3.0) }) mutation = MixedVariableMutation( mask, { "real": get_mutation("real_pm", eta=3.0, prob=0.02), "int": get_mutation("int_pm", eta=3.0, prob=0.02) }) #[V_gBurn,ng,Tdig,debt_level,V_cng_p,e_priceS,farm1,farm2,farm3,farm4,farm5,farm6,farm7] problem = BiogasSingleJ(dict_t) # problem = BiogasMultiJ() algorithm = GA( pop_size=dict_t['GA_pop'], sampling=sampling, crossover=crossover, n_offsprings=dict_t['GA_off'], mutation=mutation, eliminate_duplicates=True, ) res = minimize(problem, algorithm, ("n_gen", dict_t['GA_gen']), verbose=True, seed=1, save_history=True) return res
def optimize(self, initial_suggest: pd.DataFrame = None, fix_input: dict = None) -> pd.DataFrame: self.fix = fix_input lb = self.space.opt_lb.numpy() ub = self.space.opt_ub.numpy() prob = get_problem_from_func(self.pymoo_obj, xl=lb, xu=ub, n_var=len(lb)) init_pop = self.get_init_pop(initial_suggest) mutation = self.get_mutation() crossover = self.get_crossover() if self.num_obj > 1: algo = NSGA2(pop_size=self.pop, sampling=init_pop, mutation=mutation, crossover=crossover) else: algo = GA(pop_size=self.pop, sampling=init_pop, mutation=mutation, crossover=crossover) res = minimize(prob, algo, ('n_gen', self.iter), verbose=self.verbose) if res.X is None: # no feasible solution founc opt_x = np.array([ind.X for ind in res.pop]).astype(float) else: opt_x = res.X.reshape(-1, len(lb)).astype(float) opt_xcont = torch.from_numpy(opt_x[:, :self.space.num_numeric]) opt_xenum = torch.from_numpy(opt_x[:, self.space.num_numeric:]) df_opt = self.space.inverse_transform(opt_xcont, opt_xenum) if self.fix is not None: for k, v in self.fix.items(): df_opt[k] = v return df_opt
from pymoo.algorithms.so_genetic_algorithm import GA from pymoo.factory import get_problem, get_termination from pymoo.optimize import minimize problem = get_problem("rastrigin") algorithm = GA(pop_size=100) termination = get_termination("f_tol_s") res = minimize(problem, algorithm, termination, pf=problem.pareto_front(), seed=1, verbose=True) print(res.opt.get("F")) print(res.algorithm.n_gen)
X = pop.get("X") I = np.where(X == 0)[1] for k in range(len(X)): i = I[k] x = X[k] _x = np.concatenate([x[i:], x[:i]]) pop[k].set("X", _x) return pop algorithm = GA( pop_size=20, sampling=RandomPermutationSampling(), mutation=InversionMutation(), # crossover=EdgeRecombinationCrossover(), crossover=OrderCrossover(), repair=StartFromZeroRepair(), eliminate_duplicates=True) # if the algorithm did not improve the last 200 generations then it will terminate (and disable the max generations) termination = SingleObjectiveDefaultTermination(n_last=200, n_max_gen=np.inf) res = minimize(problem, algorithm, termination, seed=1, verbose=False) print(res.F) print(res.algorithm.evaluator.n_eval) visualize(problem, res.X)
from pymoo.algorithms.so_genetic_algorithm import GA from pymoo.operators.crossover.order_crossover import OrderCrossover from pymoo.operators.mutation.inversion_mutation import InversionMutation from pymoo.operators.sampling.random_permutation_sampling import RandomPermutationSampling from pymoo.optimize import minimize from pymoo.problems.single.flowshop_scheduling import visualize, create_random_flowshop_problem from pymoo.util.termination.default import SingleObjectiveDefaultTermination problem = create_random_flowshop_problem(n_machines=5, n_jobs=10, seed=1) algorithm = GA(pop_size=20, eliminate_duplicates=True, sampling=RandomPermutationSampling(), mutation=InversionMutation(), crossover=OrderCrossover()) # if the algorithm did not improve the last 200 generations then it will terminate termination = SingleObjectiveDefaultTermination(n_last=50, n_max_gen=10000) res = minimize(problem, algorithm, termination, seed=1, verbose=True) visualize(problem, res.X)
class MyMutation(Mutation): def _do(self, problem, X, **kwargs): for i in range(X.shape[0]): X[i, :] = X[i, :] is_false = np.where(np.logical_not(X[i, :]))[0] is_true = np.where(X[i, :])[0] X[i, np.random.choice(is_false)] = True X[i, np.random.choice(is_true)] = False return X from pymoo.algorithms.so_genetic_algorithm import GA from pymoo.optimize import minimize algorithm = GA(pop_size=100, sampling=MySampling(), crossover=BinaryCrossover(), mutation=MyMutation(), eliminate_duplicates=True) res = minimize(problem, algorithm, ('n_gen', 75), seed=1, verbose=True) print("Function value: %s" % res.F[0]) print("Subset:", np.where(res.X)[0]) opt = np.sort(np.argsort(L)[:n_max]) print("Optimal Subset:", opt) print("Optimal Function Value: %s" % L[opt].sum())
X = pop.get("X") I = np.where(X == 0)[1] for k in range(len(X)): i = I[k] x = X[k] _x = np.concatenate([x[i:], x[:i]]) pop[k].set("X", _x) return pop algorithm = GA( pop_size=20, sampling=PermutationRandomSampling(), mutation=InversionMutation(), # crossover=EdgeRecombinationCrossover(), crossover=OrderCrossover(), repair=StartFromZeroRepair(), eliminate_duplicates=True) # if the algorithm did not improve the last 200 generations then it will terminate (and disable the max generations) termination = SingleObjectiveDefaultTermination(n_last=200, n_max_gen=np.inf) res = minimize(problem, algorithm, termination, seed=1, verbose=False) print(res.F) print(res.algorithm.evaluator.n_eval) visualize(problem, res.X) #
def create_attack( initial_state, weight, model, scaler, encoder, n_gen, pop_size, n_offsprings, ): problem = VenusProblem(initial_state, weight, model, encoder, scaler) type_mask = [ "real", "int", "real", "real", "real", "real", "real", "real", "real", "real", "real", "int", "real", "real", "int", ] sampling = MixedVariableSampling( type_mask, { "real": get_sampling("real_random"), "int": get_sampling("int_random") }, ) # Default parameters for crossover (prob=0.9, eta=30) crossover = MixedVariableCrossover( type_mask, { "real": get_crossover("real_sbx", prob=0.9, eta=30), "int": get_crossover("int_sbx", prob=0.9, eta=30), }, ) # Default parameters for mutation (eta=20) mutation = MixedVariableMutation( type_mask, { "real": get_mutation("real_pm", eta=20), "int": get_mutation("int_pm", eta=20), }, ) algorithm = GA( pop_size=pop_size, n_offsprings=n_offsprings, sampling=sampling, crossover=crossover, mutation=mutation, eliminate_duplicates=True, return_least_infeasible=True, ) termination = get_termination("n_gen", n_gen) return problem, algorithm, termination
# bandwith) delta = [0.95]*670 # delta[0] = 5 ps = df['ps_score'].values incre_ps = (delta * ps) / (delta * ps + 1 - ps) policy_value = incre_ps.reshape(-1,1) cov_value = df[covariates].values # print(policy_value.shape, cov_value.shape) feature_value = np.concatenate([policy_value,cov_value], axis = 1) # print(policy_value) v_DR = problem.estimator_DR(df[treatment].values, df[outcome].values, df['ps_score'], incre_ps, feature_value, df['y_estimator'], bandwidth) print(v_DR) """Optimization""" algorithm = GA(pop_size=100, eliminate_duplicates=True) res = minimize(problem, algorithm, seed=1, verbose=False) print("Best solution found: \nX = %s\nF = %s" % (res.X, res.F))
i = I[k] x = X[k] _x = np.concatenate([x[i:], x[:i]]) pop[k].set("X", _x) return pop from pymoo.algorithms.so_genetic_algorithm import GA from pymoo.optimize import minimize from pymoo.factory import get_algorithm, get_crossover, get_mutation, get_sampling from pymoo.problems.single.traveling_salesman import create_random_tsp_problem from pymoo.util.termination.default import SingleObjectiveDefaultTermination algorithm = GA(pop_size=20, sampling=get_sampling("perm_random"), crossover=get_crossover("perm_erx"), mutation=get_mutation("perm_inv"), repair=StartFromZeroRepair(), eliminate_duplicates=True) # if the algorithm did not improve the last 200 generations then it will terminate (and disable the max generations) termination = SingleObjectiveDefaultTermination(n_last=200, n_max_gen=np.inf) # res = minimize( # problem, # algorithm, # termination, # seed=1, # ) # # print("Traveling Time:", np.round(res.F[0], 3))
import numpy as np from pymoo.algorithms.so_genetic_algorithm import GA from pymoo.factory import get_problem from pymoo.model.evaluator import Evaluator from pymoo.model.population import Population from pymoo.optimize import minimize problem = get_problem("sphere") X = np.random.random((500, problem.n_var)) pop = Population(len(X)) pop.set("X", X) Evaluator().eval(problem, pop) algorithm = GA(sampling=pop) res = minimize(problem, algorithm, seed=1, verbose=False) print("Best solution found: \nX = %s\nF = %s" % (res.X, res.F))
}), bounds=(problem.xl, problem.xu), labels=["$x_%s$" % k for k in range(problem.n_var)]) pcp.set_axis_style(color="grey", alpha=0.5) pcp.add(algorithm.pop.get("X"), color="black", alpha=0.8, linewidth=1.5) if algorithm.off is not None: pcp.add(algorithm.off.get("X"), color="blue", alpha=0.8, linewidth=0.5) pcp.add(algorithm.opt.get("X"), color="red", linewidth=4) pcp.do() self.video.record() problem = get_problem("rastrigin", n_var=10) algorithm = GA(pop_size=50, eliminate_duplicates=True, callback=MyCallback()) ret = minimize(problem, algorithm, termination=('n_gen', 50), seed=1, verbose=False)
off = super().do(problem, pop, n_offsprings, **kwargs) return off selections = [RandomSelection()] # define all the crossovers to be tried crossovers = [SimulatedBinaryCrossover(10.0), SimulatedBinaryCrossover(30.0), DifferentialEvolutionCrossover()] # COMMENT out this line to only use the SBX crossover with one eta value # crossovers = [SimulatedBinaryCrossover(30)] mutations = [NoMutation(), PolynomialMutation(10.0), PolynomialMutation(30.0)] repairs = [] ensemble = EnsembleMating(selections, crossovers, mutations, repairs) problem = Rastrigin(n_var=30) algorithm = GA( pop_size=100, mating=ensemble, eliminate_duplicates=True) res = minimize(problem, algorithm, seed=1, verbose=True) print("Best solution found: \nX = %s\nF = %s" % (res.X, res.F))
# the packing plan for i z = Z[i] # while the maximum capacity violation holds while weights[i] > Q: # randomly select an item currently picked item_to_remove = np.random.choice(np.where(z)[0]) # and remove it z[item_to_remove] = False # adjust the weight weights[i] -= problem.W[item_to_remove] # set the design variables for the population pop.set("X", Z) return pop problem = create_random_knapsack_problem(30) algorithm = GA(pop_size=200, sampling=get_sampling("bin_random"), crossover=get_crossover("bin_hux"), mutation=get_mutation("bin_bitflip"), repair=ConsiderMaximumWeightRepair(), elimate_duplicates=True) res = minimize(problem, algorithm, termination=('n_gen', 10), disp=True)
from pymoo.algorithms.nsga2 import NSGA2 from pymoo.algorithms.so_genetic_algorithm import GA from pymoo.factory import get_problem from pymoo.model.callback import Callback from pymoo.optimize import minimize import numpy as np import matplotlib.pyplot as plt class MyCallback(Callback): def __init__(self) -> None: super().__init__() self.data["best"] = [] def notify(self, algorithm): self.data["best"].append(algorithm.pop.get("F").min()) problem = get_problem("sphere") algorithm = GA(pop_size=100, callback=MyCallback()) res = minimize(problem, algorithm, ('n_gen', 20), seed=1, verbose=True) val = res.algorithm.callback.data["best"] plt.plot(np.arange(len(val)), val) plt.show()
from pymoo.algorithms.so_genetic_algorithm import GA from pymoo.optimize import minimize from pymoo.problems.single.mopta08 import MOPTA08 problem = MOPTA08("/Users/blankjul/Downloads/mopta_fortran_unix/exec") algorithm = GA(n_offsprings=20, return_least_infeasible=True) res = minimize(problem, algorithm, verbose=True) print(res.F, res.F)