class Islands: islands = {} interval = 10 islands_len = 2 max_evaluations = 10000 problem = Rastrigin(50) def __init__(self, islands_len, iterval, migration_rate, random_groups, random_destination, max_evaluations, problem): self.islands_len = islands_len self.iterval = iterval self.max_evaluations = max_evaluations self.problem = problem self.migration = Migration( migration_rate, random_groups, random_destination) for i in range(islands_len): # possible to override problem later self.problem self.islands[str(i)] = GeneticAlgorithm( problem=self.problem, population_size=100, offspring_population_size=100, mutation=UniformMutation(0.006, 20.0), crossover=SBXCrossover(0.3, 19.0), selection=BinaryTournamentSelection(), termination_criterion=StoppingByEvaluations( max_evaluations=iterval) ) print(self.islands) def get_name(self) -> str: return 'Islands' def run(self): x = 0 new_populations = {} while x < self.max_evaluations: for key, algo in self.islands.items(): if str(key) in new_populations: algo.problem = Rastrigin(len(new_populations[key])) algo.solutions = new_populations[key] algo.run() self.migration.collect_inhabitants( key, algo.get_result().variables) x = x+self.interval # print("Computed populations ", new_populations) new_populations = self.migration.allocate_migrants() # print("Migrated populations ", new_populations) for key, algo in self.islands.items(): result = algo.get_result()
def run(self): x = 0 new_populations = {} while x < self.max_evaluations: for key, algo in self.islands.items(): if str(key) in new_populations: algo.problem = Rastrigin(len(new_populations[key])) algo.solutions = new_populations[key] algo.run() self.migration.collect_inhabitants( key, algo.get_result().variables) x = x+self.interval # print("Computed populations ", new_populations) new_populations = self.migration.allocate_migrants() # print("Migrated populations ", new_populations) for key, algo in self.islands.items(): result = algo.get_result()
from jmetal.algorithm.singleobjective.local_search import LocalSearch from jmetal.operator import PolynomialMutation from jmetal.problem.singleobjective.unconstrained import Rastrigin from jmetal.util.solution import print_function_values_to_file, print_variables_to_file from jmetal.util.termination_criterion import StoppingByEvaluations if __name__ == "__main__": problem = Rastrigin(10) max_evaluations = 100000 algorithm = LocalSearch( problem=problem, mutation=PolynomialMutation(1.0 / problem.number_of_variables, 20.0), termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations), ) algorithm.run() result = algorithm.get_result() # Save results to file print_function_values_to_file(result, "FUN." + algorithm.get_name() + "." + problem.get_name()) print_variables_to_file(result, "VAR." + algorithm.get_name() + "." + problem.get_name()) print("Algorithm: " + algorithm.get_name()) print("Problem: " + problem.get_name()) print("Solution: " + str(result.variables)) print("Fitness: " + str(result.objectives[0])) print("Computing time: " + str(algorithm.total_computing_time))
from jmetal.algorithm.multiobjective.nsgaii import NSGAII from jmetal.operator import SBXCrossover, PolynomialMutation from jmetal.problem.singleobjective.unconstrained import Rastrigin from jmetal.util.observer import PrintObjectivesObserver from jmetal.util.solutions import print_function_values_to_file, print_variables_to_file from jmetal.util.solutions.comparator import DominanceComparator from jmetal.util.termination_criterion import StoppingByEvaluations if __name__ == '__main__': problem = Rastrigin(10) max_evaluations = 50000 algorithm = NSGAII( problem=problem, population_size=100, offspring_population_size=100, mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20.0), crossover=SBXCrossover(probability=0.9, distribution_index=20.0), termination_criterion=StoppingByEvaluations(max=max_evaluations), dominance_comparator=DominanceComparator()) algorithm.observable.register(observer=PrintObjectivesObserver(1000)) algorithm.run() front = algorithm.get_result() # Save results to file print_function_values_to_file( front, 'FUN.' + algorithm.get_name() + "-" + problem.get_name())
from jmetal.algorithm.singleobjective.local_search import LocalSearch from jmetal.operator import PolynomialMutation from jmetal.problem.singleobjective.unconstrained import Rastrigin from jmetal.util.observer import PrintObjectivesObserver from jmetal.util.solution_list import print_function_values_to_file, print_variables_to_file from jmetal.util.termination_criterion import StoppingByEvaluations if __name__ == '__main__': problem = Rastrigin(10) max_evaluations = 100000 algorithm = LocalSearch( problem=problem, mutation=PolynomialMutation(1.0 / problem.number_of_variables, 20.0), termination_criterion=StoppingByEvaluations(max=max_evaluations) ) objectives_observer = PrintObjectivesObserver(frequency=1000) algorithm.observable.register(observer=objectives_observer) algorithm.run() result = algorithm.get_result() # Save results to file print_function_values_to_file(result, 'FUN.'+ algorithm.get_name() + "." + problem.get_name()) print_variables_to_file(result, 'VAR.' + algorithm.get_name() + "." + problem.get_name()) print('Algorithm: ' + algorithm.get_name()) print('Problem: ' + problem.get_name()) print('Solution: ' + str(result.variables)) print('Fitness: ' + str(result.objectives[0]))
from jmetal.algorithm.singleobjective.simulated_annealing import SimulatedAnnealing from jmetal.operator import PolynomialMutation from jmetal.problem.singleobjective.unconstrained import Rastrigin from jmetal.util.observer import PrintObjectivesObserver from jmetal.util.solutions_utils import print_function_values_to_file, print_variables_to_file from jmetal.util.termination_criterion import StoppingByEvaluations if __name__ == '__main__': problem = Rastrigin(10) max_evaluations = 250000 algorithm = SimulatedAnnealing( problem=problem, mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20.0), termination_criterion=StoppingByEvaluations(max=max_evaluations)) objectives_observer = PrintObjectivesObserver(frequency=1000) algorithm.observable.register(observer=objectives_observer) algorithm.run() result = algorithm.get_result() # Save results to file print_function_values_to_file( result, 'FUN.' + algorithm.get_name() + "." + problem.get_name()) print_variables_to_file( result, 'VAR.' + algorithm.get_name() + "." + problem.get_name())
from jmetal.operator import PolynomialMutation, SBXCrossover from jmetal.problem.singleobjective.unconstrained import Rastrigin from jmetal.util.termination_criterion import StoppingByEvaluations from main import Emas if __name__ == '__main__': problem = Rastrigin(10) algorithm = Emas( number_of_islands=10, init_island_population_size=20, problem=problem, mutation=PolynomialMutation(1.0 / problem.number_of_variables, 0.2), crossover=SBXCrossover(0.9, 20.0), termination_criterion=StoppingByEvaluations(max_evaluations=20000)) algorithm.run() result = algorithm.get_result() print('Algorithm: {}'.format(algorithm.get_name())) print('Problem: {}'.format(problem.get_name())) for x in result: for z in x: print('Solution: {}'.format(z.solution.variables)) print('Fitness: {}'.format(z.solution.objectives[0])) print('Energy: {}'.format(z.energy)) print('Computing time: {}'.format(algorithm.total_computing_time)) print(len(result)) print("Best fitness: " + str(min([z.fitness() for x in result for z in x])))
from jmetal.algorithm.multiobjective.nsgaii import NSGAII from jmetal.operator import PolynomialMutation, SBXCrossover from jmetal.problem.singleobjective.unconstrained import Rastrigin from jmetal.util.comparator import DominanceComparator from jmetal.util.solution import print_function_values_to_file, print_variables_to_file from jmetal.util.termination_criterion import StoppingByEvaluations if __name__ == "__main__": problem = Rastrigin(10) max_evaluations = 50000 algorithm = NSGAII( problem=problem, population_size=100, offspring_population_size=100, mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20.0), crossover=SBXCrossover(probability=0.9, distribution_index=20.0), termination_criterion=StoppingByEvaluations( max_evaluations=max_evaluations), dominance_comparator=DominanceComparator(), ) algorithm.run() front = algorithm.get_result() # Save results to file print_function_values_to_file( front, "FUN." + algorithm.get_name() + "-" + problem.get_name()) print_variables_to_file(
def run() -> None: target_path = os.path.join(RESULTS_DIR, "testDE_rastrigin.json") rastrigin_problem = Rastrigin(number_of_variables=100) variable_species_size_execution_unit = ExecutionUnit( algorithm_cls=DifferentialEvolution, problem_name="Rastrigin_100dim_variable_species_size" ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 1, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 20, "cr": 0.9, "f": 0.8, "max_iter": 500 }, ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 50, "cr": 0.9, "f": 0.8, "max_iter": 500 }, ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 100, "cr": 0.9, "f": 0.8, "max_iter": 500 }, ) variable_number_of_species_execution_unit = ExecutionUnit( algorithm_cls=DifferentialEvolution, problem_name="Rastrigin_100dim_variable_number_of_species" ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "no_species": 1, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "no_species": 10, # default "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "no_species": 20, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "no_species": 50, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "no_species": 100, "cr": 0.9, "f": 0.8, "max_iter": 500 } ) variable_number_of_partners_execution_unit = ExecutionUnit( algorithm_cls=DifferentialEvolution, problem_name="Rastrigin_100dim_variable_number_of_partners" ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "number_of_partners": 3, # default "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "number_of_partners": 5, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "number_of_partners": 10, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "number_of_partners": 15, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 10, "number_of_partners": 20, "cr": 0.9, "f": 0.8, "max_iter": 500 } ) variable_iterations_execution_unit = ExecutionUnit( algorithm_cls=DifferentialEvolution, problem_name="Rastrigin_100dim_variable_max_iter" ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 20, "no_species": 50, "cr": 0.9, "f": 0.8, "max_iter": 250 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 20, "no_species": 50, "cr": 0.9, "f": 0.8, "max_iter": 500 } ).register_run( parameters={ "problem": rastrigin_problem, "each_species_size": 20, "no_species": 50, "cr": 0.9, "f": 0.8, "max_iter": 1000 } ) runner = MultiAlgorithmRunner( execution_units=[ variable_species_size_execution_unit, variable_number_of_species_execution_unit, variable_number_of_partners_execution_unit, variable_iterations_execution_unit ] ) print("Runner starts evaluation.") results = runner.run_all() print("Results") for run_result in results.run_results: print({ "problem_name": run_result.problem_name, "algorithm": run_result.algorithm_name, "fitness": run_result.fitness }) save_execution_history(execution_history=results, path=target_path)
from model import Islands from jmetal.problem.singleobjective.unconstrained import Rastrigin problem = Rastrigin(50) x = Islands(3, 10, 0.2, True, True, 1000, problem) # porownac wyspy - porownac do algorytmu bazowego - jednej wyspy - podobna liczba osobnikow np. 50 i 5*10 # w sensownej liczbie wymiarow # startegie emigracji/imigracji x.run() # You can access result of each island result = x.islands[str(0)].get_result() print('Algorithm: {}'.format(x.islands[str(0)].get_name())) print('Solution: {}'.format(result.variables)) print('Fitness: {}'.format(result.objectives[0]))
from evolution_strategies.species import StrategyParams, SocioCognitiveEvolutionStrategy from jmetal.util.termination_criterion import StoppingByEvaluations from evolution_strategies.plot import draw_comparision_plot from evolution_strategies.evolution_strategy import EvolutionStrategyWithHistory from jmetal.operator import PolynomialMutation from jmetal.problem.singleobjective.unconstrained import Rastrigin if __name__ == '__main__': problem = Rastrigin(number_of_variables=50) mu = 20 lambda_ = 140 elitist = True max_evaluations = 25000 strategies_params = [ StrategyParams(mu=mu, lambda_=lambda_, elitist=elitist, look_at_others_probability=0.2) # StrategyParams(mu=1, lambda_=5, elitist=True, look_at_others_probability=0.2) ] algorithm = SocioCognitiveEvolutionStrategy( problem=problem, strategies_params=strategies_params, termination_criterion=StoppingByEvaluations( max_evaluations=max_evaluations)) algorithm_normal = EvolutionStrategyWithHistory(
save_file='griewank_3_partners.json', no_iters=1000, no_repeats=10, no_partners=3) run(problem=griewank_problem, save_file='griewank_5_partners.json', no_iters=1000, no_repeats=10, no_partners=5) run(problem=griewank_problem, save_file='griewank_10_partners.json', no_iters=1000, no_repeats=10, no_partners=10) rastrigin_problem = Rastrigin(number_of_variables=10) run(problem=rastrigin_problem, save_file='rastrigin_3_partners.json', no_iters=1000, no_repeats=10, no_partners=3) run(problem=rastrigin_problem, save_file='rastrigin_5_partners.json', no_iters=1000, no_repeats=10, no_partners=5) run(problem=rastrigin_problem, save_file='rastrigin_10_partners.json', no_iters=1000, no_repeats=10, no_partners=10)
# phi_g: float - the weight for speed change influenced by global best. Defaulrs is 1.0. # learning_rate: float - how much speed influences the position change. Default is 1.0. # phi_n: float - the weight for speed change influenced by neighborhood. Default is 0.3. # # n_neighbors: int - neighborhood size. Default is 30. # # hops: int - How is neighborhood determined (if neighbors' neighobrs should be also taken into account etc.) # I would not change the number of hops from the default value 1, because it becomes computationally to expensive # due to inefficient implementation. # # use_global: bool - whether to use global best while determining speed change. Default is False and it should not be # changed because it gives poor results, but is left to be compliant with the specification given during lab exercises. # algorithm = WithNeighborsPSO( problem=Rastrigin(100), swarm_size=100, leaders=CrowdingDistanceArchive(100), termination_criterion=StoppingByEvaluations( 100 ) # To get better results increase the number of iterations, I tested for 10 000-50 000. ) algorithm.run() solutions = algorithm.get_result() objectives = solutions[0].objectives variables = solutions[0].variables print("PSO with neighbors") print("Fitness: {}".format(objectives))
from jmetal.algorithm.singleobjective.simulated_annealing import SimulatedAnnealing from jmetal.operator import PolynomialMutation from jmetal.problem.singleobjective.unconstrained import Rastrigin from jmetal.util.solution import print_function_values_to_file, print_variables_to_file from jmetal.util.termination_criterion import StoppingByEvaluations if __name__ == "__main__": problem = Rastrigin(10) max_evaluations = 100000 algorithm = SimulatedAnnealing( problem=problem, mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20.0), termination_criterion=StoppingByEvaluations( max_evaluations=max_evaluations), ) algorithm.run() result = algorithm.get_result() # Save results to file print_function_values_to_file( result, "FUN." + algorithm.get_name() + "." + problem.get_name()) print_variables_to_file( result, "VAR." + algorithm.get_name() + "." + problem.get_name()) print("Algorithm: " + algorithm.get_name()) print("Problem: " + problem.get_name())