problem=problem, n_dir=pop_size_per_epoch) res = minimize(problem=problem, method='samoo', method_args={'seed': 53, 'method': 'samoo', 'framework_id': framework_id, 'ref_dirs': ref_dirs, 'metamodel_list': metamodel_list, 'acq_list': acq_list, 'framework_acq_dict': framework_acq_dict, 'aggregation': aggregation, 'lf_algorithm_list': lf_algorithm_list, 'init_pop_size': init_pop_size, 'pop_size_per_epoch': pop_size_per_epoch, 'pop_size_per_algorithm':pop_size_per_algorithm, 'pop_size_lf': pop_size_lf, 'n_gen_lf': 100, 'n_split': 2 }, termination=('n_eval', 800), pf=pf, save_history=False, disp=True ) plotting.plot(pf, res.F, labels=["Pareto-front", "F"]) # filename = '/results/'+problem_name # np.savetxt(filename+".F", res.pop.get("F")) # np.savetxt(filename+".X", res.pop.get("X"))
from pymoo.util.plotting import plot_problem_surface problem = get_problem("zakharov", n_var=2) plot_problem_surface(problem, 100, plot_type="wireframe+contour") # END zakharov # -------------------------------------------------------------------------------------------- # Multi # -------------------------------------------------------------------------------------------- # START zdt1 from pymoo.factory import get_problem from pymoo.util.plotting import plot problem = get_problem("zdt1") plot(problem.pareto_front(), no_fill=True) # END zdt1 # START zdt2 from pymoo.factory import get_problem from pymoo.util.plotting import plot problem = get_problem("zdt2") plot(problem.pareto_front(), no_fill=True) # END zdt2 # START zdt3 from pymoo.factory import get_problem from pymoo.util.plotting import plot problem = get_problem("zdt3")
problem = get_problem("zdt1", n_var=30) pf = problem.pareto_front() # create the reference directions to be used for the optimization ref_points = np.array([[0.5, 0.2], [0.1, 0.6]]) res = minimize( problem, method='rnsga2', method_args={ 'pop_size': 40, 'ref_points': ref_points, 'epsilon': 0.02, 'normalization': 'no', 'survival_type': "closest", 'extreme_points_as_reference_points': True # 'weights': np.array([0.9, 0.1]) }, save_history=True, termination=('n_gen', 500), seed=1, pf=pf, disp=True) print(res.pop.get("dist_to_closest")) plotting.plot(pf, res.pop.get("F"), ref_points, show=True, labels=['pf', 'F', 'ref_points'])
from pymoo.optimize import minimize from pymoo.util import plotting from pymoo.util.reference_direction import UniformReferenceDirectionFactory from pymop.factory import get_problem problem = get_problem("dtlz1", n_var=7, n_obj=3) # create the reference directions to be used for the optimization ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do() # create the pareto front for the given reference lines pf = problem.pareto_front(ref_dirs) res = minimize(problem, method='nsga3', method_args={ 'pop_size': 92, 'ref_dirs': ref_dirs }, termination=('n_gen', 400), pf=pf, seed=1, disp=True) plotting.plot(res.F)
from pymoo.optimize import minimize from pymoo.util import plotting from pymoo.util.reference_direction import UniformReferenceDirectionFactory from pymop.factory import get_problem problem = get_problem("dtlz1") # create the reference directions to be used for the optimization ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do() # create the pareto front for the given reference lines pf = problem.pareto_front(ref_dirs) res = minimize(problem, method='nsga3', method_args={ 'pop_size': 92, 'ref_dirs': ref_dirs }, termination=('n_gen', 600), pf=pf, seed=4, disp=True) # if desired we can filter out the solutions that are not close to ref_dirs closest_to_ref_dir = res.opt.get("closest") plotting.plot(res.F[closest_to_ref_dir, :], show=True)
'mutation': IntegerBitflipMutation(prob_mut=0.1), 'eliminate_duplicates': is_duplicate, 'func_repair': repair }, termination=('n_gen', 100), # callback=my_callback, disp=True) results = { 'times': problem.times, 'best_valids': problem.best_valids, 'best_tests': problem.best_tests, 'hash_archive': problem.hash_archive, 'Function value': res.opt.get('F'), 'Variable value': res.opt.get('X'), } # with open('nsga2.dat', 'wb') as handle: # pickle.dump(results, handle) plot = True if plot: plotting.plot(pf, res.opt.get('F'), labels=["Pareto-front", "F"]) # print("Time elapsed: {}".format(time.time() - start)) # print("Function value: %s" % res.F) # print("Total time spent = {} hours, best valid acc = {}, best test acc = {}" # .format(problem.times[-1]/3600, problem.best_valids[-1], problem.best_tests[-1])) # print("{}% of the model sampled are unique".format(len(list(set(problem.hash_archive))) / # len(problem.hash_archive)*100))
def _evaluate(self, x, out, *args, **kwargs): super()._evaluate(x, out, *args, **kwargs) out["F"] = out["F"] * np.array([1.0, 10.0]) - 500 problem = ScaledZDT1() ref_dirs = UniformReferenceDirectionFactory(2, n_points=100).do() pf = problem.pareto_front() res = minimize( problem, method='nsga3', method_args={ 'pop_size': 100, 'ref_dirs': ref_dirs, #'survival': ReferenceDirectionSurvivalTrue(ref_dirs, np.array([[1.0, 0], [0, 1.0]])) }, termination=('n_gen', 400), pf=pf, seed=1, disp=True) plotting.plot(pf, res.F, labels=["Pareto-front", "NSGA-III - No Normalization"], show=False) plt.legend() plt.savefig("no_normalization.pdf")
def _evaluate(self, x, out, *args, **kwargs): X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:] g = self.g1(X_M) super()._evaluate(x, out, *args, **kwargs) out["F"] = 0.5 * (1 + g[:, None]) - out["F"] #problem = get_problem("dtlz1", None, 3, k=5) problem = InvertedDTLZ1(n_obj=3) ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do() pf = problem.pareto_front(ref_dirs) res = minimize(problem, method='nsga3', method_args={ 'pop_size': 100, 'ref_dirs': ref_dirs, }, termination=('n_gen', 500), #pf=pf, seed=1, disp=True) closest_to_ref_dir = res.opt.get("closest") plotting.plot(res.F[closest_to_ref_dir,:], labels=["NSGA-III"], show=False) #plotting.plot(pf, res.F, labels=["Pareto-front", "NSGA-III"], show=False) plt.legend() plt.show()
problem = get_problem("carside") #problem = ConvexProblem(DTLZ2(n_var=12, n_obj=3)) n_gen = 400 pop_size = 91 ref_dirs = UniformReferenceDirectionFactory(3, n_partitions=12, scaling=1.0).do() # create the pareto front for the given reference lines pf = problem.pareto_front( UniformReferenceDirectionFactory(3, n_partitions=70, scaling=1.0).do()) res = minimize( problem, method='nsga3', method_args={ 'pop_size': 91, 'ref_dirs': ref_dirs, 'survival': DSSSurvival() }, termination=('n_gen', n_gen), # pf=pf, save_history=True, seed=31, disp=True) #plotting.plot(pf, res.F, labels=["Pareto-front", "F"]) plotting.plot(res.F, labels=["F"])
# create the reference directions to be used for the optimization ref_points = np.array([[0.3, 0.4], [0.8, 0.5]]) res = minimize(problem, method='rnsga3', method_args={ 'ref_points': ref_points, 'pop_per_ref_point': 50, 'mu': 0.1 }, termination=('n_gen', 400), pf=pf, disp=True) plotting.plot(pf, res.F, ref_points, show=True, labels=['pf', 'F', 'ref_points']) problem = get_problem("dtlz4", n_var=12, n_obj=3) ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do() pf = problem.pareto_front(ref_dirs) # create the reference directions to be used for the optimization ref_points = np.array([[1.0, 0.5, 0.2], [0.3, 0.2, 0.6]]) res = minimize(problem, method='rnsga3', method_args={ 'ref_points': ref_points, 'pop_per_ref_point': 91,
from pymoo.optimize import minimize from pymoo.algorithms.nsga2 import nsga2 from pymoo.util import plotting import numpy as np from pymop.factory import get_problem # create the algorithm object method = nsga2(pop_size=100, elimate_duplicates=True) # execute the optimization res = minimize(get_problem("zdt1"), method, termination=('n_gen', 200)) print("Best solution found: %s" % res.X) print("Function value: %s" % res.F) print("Constraint violation: %s" % res.CV) plotting.plot(res.F, no_fill=True)