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())
