def __init__(
self,
problem: Problem,
population_size: int,
mutation: Mutation,
crossover: Crossover,
number_of_cores: int,
client,
selection: Selection = BinaryTournamentSelection(
MultiComparator([
FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()
])),
termination_criterion: TerminationCriterion = store.
default_termination_criteria,
dominance_comparator: DominanceComparator = DominanceComparator()):
super(DistributedNSGAII, self).__init__()
self.problem = problem
self.population_size = population_size
self.mutation_operator = mutation
self.crossover_operator = crossover
self.selection_operator = selection
self.dominance_comparator = dominance_comparator
self.termination_criterion = termination_criterion
self.observable.register(termination_criterion)
self.number_of_cores = number_of_cores
self.client = client
def __init__(
self,
problem: DynamicProblem[S],
population_size: int,
offspring_population_size: int,
mutation: Mutation,
crossover: Crossover,
selection: Selection = BinaryTournamentSelection(
MultiComparator([
FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()
])),
termination_criterion: TerminationCriterion = store.
default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: DominanceComparator = DominanceComparator()):
super(DynamicNSGAII, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=offspring_population_size,
mutation=mutation,
crossover=crossover,
selection=selection,
population_evaluator=population_evaluator,
population_generator=population_generator,
termination_criterion=termination_criterion,
dominance_comparator=dominance_comparator)
self.completed_iterations = 0
self.start_computing_time = 0
self.total_computing_time = 0
def __init__(
self,
problem: Problem,
population_size: int,
offspring_population_size: int,
mutation: Mutation,
crossover: Crossover,
termination_criterion: TerminationCriterion = store.default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: Comparator = store.default_comparator,
):
"""
:param problem: The problem to solve.
:param population_size: Size of the population.
:param mutation: Mutation operator (see :py:mod:`jmetal.operator.mutation`).
:param crossover: Crossover operator (see :py:mod:`jmetal.operator.crossover`).
"""
multi_comparator = MultiComparator(
[StrengthRanking.get_comparator(), KNearestNeighborDensityEstimator.get_comparator()]
)
selection = BinaryTournamentSelection(comparator=multi_comparator)
super(SPEA2, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=offspring_population_size,
mutation=mutation,
crossover=crossover,
selection=selection,
termination_criterion=termination_criterion,
population_evaluator=population_evaluator,
population_generator=population_generator,
)
self.dominance_comparator = dominance_comparator
def __init__(self,
reference_directions,
problem: Problem,
mutation: Mutation,
crossover: Crossover,
population_size: int = None,
selection: Selection = BinaryTournamentSelection(
MultiComparator([FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()])),
termination_criterion: TerminationCriterion = store.default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: Comparator = store.default_comparator):
self.reference_directions = reference_directions.compute()
if not population_size:
population_size = len(self.reference_directions)
if self.reference_directions.shape[1] != problem.number_of_objectives:
raise Exception('Dimensionality of reference points must be equal to the number of objectives')
super(NSGAIII, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=population_size,
mutation=mutation,
crossover=crossover,
selection=selection,
termination_criterion=termination_criterion,
population_evaluator=population_evaluator,
population_generator=population_generator,
dominance_comparator=dominance_comparator
)
self.extreme_points = None
self.ideal_point = np.full(self.problem.number_of_objectives, np.inf)
self.worst_point = np.full(self.problem.number_of_objectives, -np.inf)
def _run_so(self):
""" Runs a single objective EA optimization ()
"""
self.ea_problem.reset_initial_population_counter()
if self.algorithm_name == 'SA':
print("Running SA")
self.mutation.probability = 1.0
algorithm = SimulatedAnnealing(
problem=self.ea_problem,
mutation=self.mutation.probability,
termination_criterion=StoppingByEvaluations(max_evaluations=self.max_evaluations)
)
else:
print("Running GA")
algorithm = GeneticAlgorithm(
problem=self.ea_problem,
population_size=self.population_size,
offspring_population_size=self.population_size,
mutation=self.mutation,
crossover=self.crossover,
selection=BinaryTournamentSelection(),
termination_criterion=StoppingByEvaluations(
max_evaluations=self.max_evaluations)
)
algorithm.observable.register(observer=PrintObjectivesStatObserver())
algorithm.run()
result = algorithm.solutions
return result
def __init__(self,
problem: Problem,
population_size: int,
offspring_population_size: int,
mutation: Mutation,
crossover: Crossover,
selection: Selection = BinaryTournamentSelection(
MultiComparator([
FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()
])),
termination_criterion: TerminationCriterion = store.
default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: Comparator = store.default_comparator,
target_value_threshold: List[float] = None,
target_pattern: List[int] = None):
"""
NSGA-II implementation as described in
* K. Deb, A. Pratap, S. Agarwal and T. Meyarivan, "A fast and elitist
multiobjective genetic algorithm: NSGA-II," in IEEE Transactions on Evolutionary Computation,
vol. 6, no. 2, pp. 182-197, Apr 2002. doi: 10.1109/4235.996017
NSGA-II is a genetic algorithm (GA), i.e. it belongs to the evolutionary algorithms (EAs)
family. The implementation of NSGA-II provided in jMetalPy follows the evolutionary
algorithm template described in the algorithm module (:py:mod:`jmetal.core.algorithm`).
.. note:: A steady-state version of this algorithm can be run by setting the offspring size to 1.
:param problem: The problem to solve.
:param population_size: Size of the population.
:param mutation: Mutation operator (see :py:mod:`jmetal.operator.mutation`).
:param crossover: Crossover operator (see :py:mod:`jmetal.operator.crossover`).
:param selection: Selection operator (see :py:mod:`jmetal.operator.selection`).
"""
super(NSGAII, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=offspring_population_size,
mutation=mutation,
crossover=crossover,
selection=selection,
termination_criterion=termination_criterion,
population_evaluator=population_evaluator,
population_generator=population_generator)
self.dominance_comparator = dominance_comparator
self.generation = 0
self.target_pattern = target_pattern
self.problem_solved = False
self.target_value_threshold = target_value_threshold
self.file_pareto_front = os.getcwd() + '/' + str(
time.strftime("%Y_%m_%d")) + '_PARETO_'
if not os.path.exists(self.file_pareto_front):
os.mkdir(self.file_pareto_front)
def test_NSGAII(self):
NSGAII(
problem=self.problem,
population_size=self.population_size,
offspring_population_size=self.offspring_size,
mutation=self.mutation,
crossover=self.crossover,
selection=BinaryTournamentSelection(comparator=RankingAndCrowdingDistanceComparator()),
termination_criterion=StoppingByEvaluations(max=1000)
).run()
def configure_experiment(problems: dict, n_run: int):
jobs = []
max_evaluations = 25000
for run in range(n_run):
for problem_tag, problem in problems.items():
jobs.append(
Job(
algorithm=NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PolynomialMutation(
probability=1.0 / problem.number_of_variables,
distribution_index=20),
crossover=SBXCrossover(probability=1.0,
distribution_index=20),
selection=BinaryTournamentSelection(
comparator=RankingAndCrowdingDistanceComparator()),
termination_criterion=StoppingByEvaluations(
max=max_evaluations)),
algorithm_tag='NSGAII',
problem_tag=problem_tag,
run=run,
))
jobs.append(
Job(
algorithm=GDE3(problem=problem,
population_size=100,
cr=0.5,
f=0.5,
termination_criterion=StoppingByEvaluations(
max=max_evaluations)),
algorithm_tag='GDE3',
problem_tag=problem_tag,
run=run,
))
jobs.append(
Job(
algorithm=SMPSO(
problem=problem,
swarm_size=100,
mutation=PolynomialMutation(
probability=1.0 / problem.number_of_variables,
distribution_index=20),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max=max_evaluations)),
algorithm_tag='SMPSO',
problem_tag=problem_tag,
run=run,
))
return jobs
def __init__(
self,
problem: Problem,
reference_point: Solution,
population_size: int,
offspring_population_size: int,
mutation: Mutation,
crossover: Crossover,
termination_criterion: TerminationCriterion = store.
default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: Comparator = store.default_comparator,
):
"""This is an implementation of the Hypervolume Estimation Algorithm for Multi-objective Optimization
proposed in:
* J. Bader and E. Zitzler. HypE: An Algorithm for Fast Hypervolume-Based Many-Objective
Optimization. TIK Report 286, Computer Engineering and Networks Laboratory (TIK), ETH
Zurich, November 2008.
It uses the Exact Hypervolume-based indicator formulation, which once computed, guides both
the environmental selection and the binary tournament selection operator
Please note that as per the publication above, the evaluator and replacement should not be changed
anyhow. It also requires that Problem() has a reference_point with objective values defined, e.g.
problem = ZDT1()
reference_point = FloatSolution(problem.number_of_variables,problem.number_of_objectives, [0], [1])
reference_point.objectives = [1., 1.]
"""
selection = BinaryTournamentSelection(
comparator=SolutionAttributeComparator(key="fitness",
lowest_is_best=False))
self.ranking_fitness = RankingAndFitnessSelection(
population_size,
dominance_comparator=dominance_comparator,
reference_point=reference_point)
self.reference_point = reference_point
self.dominance_comparator = dominance_comparator
super(HYPE, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=offspring_population_size,
mutation=mutation,
crossover=crossover,
selection=selection,
termination_criterion=termination_criterion,
population_evaluator=population_evaluator,
population_generator=population_generator,
)
def __init__(
self,
problem: Problem,
population_size: int,
neighborhood: Neighborhood,
archive: BoundedArchive,
mutation: Mutation,
crossover: Crossover,
selection: Selection = BinaryTournamentSelection(
MultiComparator([
FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()
])),
termination_criterion: TerminationCriterion = store.
default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: Comparator = store.default_comparator,
):
"""
MOCEll implementation as described in:
:param problem: The problem to solve.
:param population_size: Size of the population.
:param mutation: Mutation operator (see :py:mod:`jmetal.operator.mutation`).
:param crossover: Crossover operator (see :py:mod:`jmetal.operator.crossover`).
:param selection: Selection operator (see :py:mod:`jmetal.operator.selection`).
"""
super(MOCell, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=1,
mutation=mutation,
crossover=crossover,
selection=selection,
termination_criterion=termination_criterion,
population_evaluator=population_evaluator,
population_generator=population_generator,
)
self.dominance_comparator = dominance_comparator
self.neighborhood = neighborhood
self.archive = archive
self.current_individual = 0
self.current_neighbors = []
self.comparator = MultiComparator([
FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()
])
def __init__(
self,
problem: Problem,
population_size: int,
offspring_population_size: int,
mutation: Mutation,
crossover: Crossover,
kappa: float,
termination_criterion: TerminationCriterion = store.default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
):
"""Epsilon IBEA implementation as described in
* Zitzler, Eckart, and Simon Künzli. "Indicator-based selection in multiobjective search."
In International Conference on Parallel Problem Solving from Nature, pp. 832-842. Springer,
Berlin, Heidelberg, 2004.
https://link.springer.com/chapter/10.1007/978-3-540-30217-9_84
IBEA is a genetic algorithm (GA), i.e. it belongs to the evolutionary algorithms (EAs)
family. The multi-objective search in IBEA is guided by a fitness associated to every solution,
which is in turn controlled by a binary quality indicator. This implementation uses the so-called
additive epsilon indicator, along with a binary tournament mating selector.
:param problem: The problem to solve.
:param population_size: Size of the population.
:param mutation: Mutation operator (see :py:mod:`jmetal.operator.mutation`).
:param crossover: Crossover operator (see :py:mod:`jmetal.operator.crossover`).
:param kappa: Weight in the fitness computation.
"""
selection = BinaryTournamentSelection(
comparator=SolutionAttributeComparator(key="fitness", lowest_is_best=False)
)
self.kappa = kappa
super(IBEA, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=offspring_population_size,
mutation=mutation,
crossover=crossover,
selection=selection,
termination_criterion=termination_criterion,
population_evaluator=population_evaluator,
population_generator=population_generator,
)
def __init__(self,
problem: MultiTransfer.MultiTransferProblem,
population_size: int,
offspring_population_size: int,
mutation: Mutation,
crossover: Crossover,
selection: Selection = BinaryTournamentSelection(
MultiComparator([FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()])),
termination_criterion: TerminationCriterion = store.default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: Comparator = store.default_comparator):
"""
NSGA-II implementation as described in
* K. Deb, A. Pratap, S. Agarwal and T. Meyarivan, "A fast and elitist
multiobjective genetic algorithm: NSGA-II," in IEEE Transactions on Evolutionary Computation,
vol. 6, no. 2, pp. 182-197, Apr 2002. doi: 10.1109/4235.996017
NSGA-II is a genetic algorithm (GA), i.e. it belongs to the evolutionary algorithms (EAs)
family. The implementation of NSGA-II provided in jMetalPy follows the evolutionary
algorithm template described in the algorithm module (:py:mod:`jmetal.core.algorithm`).
.. note:: A steady-state version of this algorithm can be run by setting the offspring size to 1.
:param problem: The problem to solve.
:param population_size: Size of the population.
:param mutation: Mutation operator (see :py:mod:`jmetal.operator.mutation`).
:param crossover: Crossover operator (see :py:mod:`jmetal.operator.crossover`).
:param selection: Selection operator (see :py:mod:`jmetal.operator.selection`).
"""
super(NSGAII_MEDA, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=offspring_population_size,
mutation=mutation,
crossover=crossover,
selection=selection,
termination_criterion=termination_criterion,
population_evaluator=population_evaluator,
population_generator=population_generator
)
self.dominance_comparator = dominance_comparator
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 evaluate(crosssover_algo, problem):
alldata = []
series = []
for x in range(10):
algorithm = GeneticAlgorithm(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PolynomialMutation(1.0 / problem.number_of_variables, 20.0),
crossover=crosssover_algo,
selection=BinaryTournamentSelection(),
termination_criterion=StoppingByEvaluations(max_evaluations=500000)
)
data = []
dataobserver = DataObserver(1.0, data)
algorithm.observable.register(observer=dataobserver)
algorithm.run()
result = algorithm.get_result().objectives[0]
series.append(result)
alldata.append(data)
numpy_array = np.array(alldata)
transpose = numpy_array.T
transpose_list = transpose.tolist()
fig = plt.figure(figsize =(60, 42))
ax = fig.add_axes([0, 0, 1, 1])
bp = ax.boxplot(transpose_list)
plt.show()
print(stats.kruskal(transpose_list[0],transpose_list[1],transpose_list[-1]))
series = [series]
print(np.average(series))
sp.posthoc_dunn([transpose_list[0],transpose_list[1],transpose_list[-1]], p_adjust = 'holm')
def __init__(self,
problem: Problem,
population_size: int,
offspring_population_size: int,
mutation: Mutation,
crossover: Crossover,
selection: Selection = BinaryTournamentSelection(MultiComparator([SolutionAttributeComparator(key = "fitness")])),
termination_criterion: TerminationCriterion = store.default_termination_criteria,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: Comparator = store.default_comparator):
super(MOGA, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=offspring_population_size,
mutation=mutation,
crossover=crossover,
selection=selection,
termination_criterion=termination_criterion,
population_evaluator=population_evaluator,
population_generator=population_generator
)
self.dominance_comparator = dominance_comparator
def run(self) -> List[S]:
pool_1_size = self.population_size
pool_2_size = self.population_size
selection_operator_1 = BinaryTournamentSelection()
crossover_operator_1 = IntegerSBXCrossover(1.0, 20.0)
mutation_operator_1 = IntegerPolynomialMutation(
1.0 / self.problem.number_of_variables, 20.0)
selection_operator_2 = DifferentialEvolutionSelection()
crossover_operator_2 = DifferentialEvolutionCrossover(0.2, 0.5, 0.5)
dominance = DominanceComparator()
max_iterations = self.max_iterations
iterations = 0
parent_1: List[IntegerSolution] = [None, None]
generational_hv: List[float] = []
current_gen = 0
"""Create the initial subpopulation pools and evaluate them"""
pool_1: List[IntegerSolution] = []
for i in range(pool_1_size):
pool_1.append(self.problem.create_solution())
pool_1[i] = self.problem.evaluate(pool_1[i])
pool_2: List[IntegerSolution] = []
for i in range(pool_2_size):
pool_2.append(self.problem.create_solution())
pool_2[i] = self.problem.evaluate(pool_2[i])
evaluations = pool_1_size + pool_2_size
mix = self.mix_interval
problem = self.problem
h = HyperVolume(reference_point=[1] *
self.problem.number_of_objectives)
initial_population = True
"""The main evolutionary cycle"""
while iterations < max_iterations:
combi: List[IntegerSolution] = []
if not initial_population:
offspring_pop_1: List[IntegerSolution] = []
offspring_pop_2: List[IntegerSolution] = []
"""Evolve pool 1"""
for i in range(pool_1_size):
parent_1[0] = selection_operator_1.execute(pool_1)
parent_1[1] = selection_operator_1.execute(pool_1)
child_1: IntegerSolution = crossover_operator_1.execute(
parent_1)[0]
child_1 = mutation_operator_1.execute(child_1)
child_1 = problem.evaluate(child_1)
evaluations += 1
offspring_pop_1.append(child_1)
"""Evolve pool 2"""
for i in range(pool_2_size):
parent_2: List[
IntegerSolution] = selection_operator_2.execute(pool_2)
crossover_operator_2.current_individual = pool_2[i]
child_2 = crossover_operator_2.execute(parent_2)
child_2 = problem.evaluate(child_2[0])
evaluations += 1
result = dominance.compare(pool_2[i], child_2)
if result == -1:
offspring_pop_2.append(pool_2[i])
elif result == 1:
offspring_pop_2.append(child_2)
else:
offspring_pop_2.append(child_2)
offspring_pop_2.append(pool_2[i])
ind_1 = pool_1[random.randint(0, pool_1_size - 1)]
ind_2 = pool_2[random.randint(0, pool_2_size - 1)]
offspring_pop_1.append(ind_1)
offspring_pop_2.append(ind_2)
offspring_pop_1.extend(pool_1)
pool_1 = self.r.replace(offspring_pop_1[:pool_1_size],
offspring_pop_1[pool_1_size:])
pool_2 = self.r.replace(offspring_pop_2[:pool_2_size],
offspring_pop_2[pool_2_size:])
mix -= 1
if mix == 0:
"""Time to perform fitness sharing"""
mix = self.mix_interval
combi = combi + pool_1 + pool_2
# print("Combi size: ", len(combi))
"""pool1size/10"""
combi = self.r.replace(
combi[:int(pool_1_size / 10)],
combi[int(pool_1_size / 10):len(combi)],
)
"""
print(
"Sizes: ",
len(pool_1) + len(combi),
len(pool_2) + len(combi),
"\n",
)
"""
pool_1 = self.r.replace(pool_1, combi)
pool_2 = self.r.replace(pool_2, combi)
if initial_population:
initial_population = False
iterations += 1
print("Iterations: ", str(iterations))
"""
hval_1 = h.compute([s.objectives for s in pool_1])
hval_2 = h.compute([s.objectives for s in pool_2])
print("hval_1: ", str(hval_1))
print("hval_2: ", str(hval_2), "\n")
"""
new_gen = int(evaluations / self.report_interval)
if new_gen > current_gen:
combi = combi + pool_1 + pool_2
combi = self.r.replace(combi[:(2 * pool_1_size)],
combi[(2 * pool_1_size):])
hval = h.compute([s.objectives for s in combi])
for i in range(current_gen, new_gen, 1):
generational_hv.append(hval)
current_gen = new_gen
"""#Write runtime generational HV to file"""
"""Return the first non dominated front"""
combi_ini: List[IntegerSolution] = []
combi_ini.extend(pool_1)
combi_ini.extend(pool_2)
combi_ini = self.r.replace(
combi_ini[:pool_1_size + pool_2_size],
combi_ini[pool_1_size + pool_2_size:],
)
return combi_ini
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == '__main__':
problem = TSP(instance='../../resources/TSP_instances/kroA100.tsp')
print('Cities: ', problem.number_of_variables)
algorithm = GeneticAlgorithm(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PermutationSwapMutation(1.0 / problem.number_of_variables),
crossover=PMXCrossover(0.8),
selection=BinaryTournamentSelection(
MultiComparator([
FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()
])),
termination_criterion=StoppingByEvaluations(max=2500000))
algorithm.observable.register(observer=PrintObjectivesObserver(1000))
algorithm.run()
result = algorithm.get_result()
print('Algorithm: {}'.format(algorithm.get_name()))
print('Problem: {}'.format(problem.get_name()))
print('Solution: {}'.format(result.variables))
print('Fitness: {}'.format(result.objectives[0]))
print('Computing time: {}'.format(algorithm.total_computing_time))
1323, 1146, 5192, 6547, 343, 7584, 3765, 8660, 9318,
5098, 5185, 9253, 4495, 892, 5080, 5297, 9275, 7515,
9729, 6200, 2138, 5480, 860, 8295, 8327, 9629, 4212,
3087, 5276, 9250, 1835, 9241, 1790, 1947, 8146, 8328,
973, 1255, 9733, 4314, 6912, 8007, 8911, 6802, 5102,
5451, 1026, 8029, 6628, 8121, 5509, 3603, 6094, 4447,
683, 6996, 3304, 3130, 2314, 7788, 8689, 3253, 5920,
3660, 2489, 8153, 2822, 6132, 7684, 3032, 9949, 59,
6669, 6334]
problem = SubsetSum(C, W)
algorithm = GeneticAlgorithm(
problem=problem,
population_size=100,
offspring_population_size=1,
mutation=BitFlipMutation(probability=0.1),
crossover=SPXCrossover(probability=0.8),
selection=BinaryTournamentSelection(),
termination_criterion=StoppingByEvaluations(max_evaluations=25000)
)
algorithm.run()
subset = algorithm.get_result()
print('Algorithm: {}'.format(algorithm.get_name()))
print('Problem: {}'.format(problem.get_name()))
print('Solution: {}'.format(subset.variables))
print('Fitness: {}'.format(subset.objectives[0]))
print('Computing time: {}'.format(algorithm.total_computing_time))
def run() -> None:
problem = Ackley(number_of_variables=150)
# problem = Griewank(number_of_variables=150)
# problem = Schwefel(number_of_variables=150)
# problem = SchafferF7(number_of_variables=150)
mutation = PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20)
local_search = MemeticLocalSearch(problem, mutation, StoppingByEvaluations(250))
local_search2 = MemeticLocalSearch(problem, mutation, StoppingByEvaluations(500))
max_evaluations = 1000000
drawing_class = DrawingClass(registered_runs=6)
target_path = os.path.join(RESULTS_DIR, f"test_{datetime.now().isoformat()}.json")
first_execution_unit = ExecutionUnit(
algorithm_cls=MemeticCognitiveAlgorithm,
problem_name="Ackley",
drawing_fun=drawing_class.draw_avg_function,
drawing_series_labels=["RUN1", "RUN1"]
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 1000,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"species1": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"species2": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"local_search": local_search,
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 1000,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"species1": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"species2": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"local_search": local_search,
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
)
second_execution_unit = ExecutionUnit(
algorithm_cls=MemeticCognitiveAlgorithm,
problem_name="Ackley",
drawing_fun=drawing_class.draw_avg_function,
drawing_series_labels=["RUN2", "RUN2"]
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 2500,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"species1": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"species2": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search2,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"local_search": local_search,
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 2500,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"species1": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"species2": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search2,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"local_search": local_search,
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
)
# modify genetic to get history (see MemeticCognitiveAlgorithm)
third_execution_unit = ExecutionUnit(
algorithm_cls=GeneticAlgorithm,
problem_name="Ackley",
drawing_fun=drawing_class.draw_avg_function,
drawing_series_labels=["GENETIC", "GENETIC"]
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 1000,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 1000,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
)
runner = MultiAlgorithmRunner(
execution_units=[
first_execution_unit, second_execution_unit, third_execution_unit
],
drawing_properties=
DrawingProperties(title='Memetic1', target_location=os.path.join(RESULTS_DIR, "photo.png"))
)
print("Runner starts evaluation.")
results = runner.run_all()
print("Results")
for run_result in results.run_results:
print(run_result)
save_execution_history(execution_history=results, path=target_path)
problem.reference_front = read_solutions(
filename='../../../resources/reference_front/{}.pf'.format(
problem.get_name()))
reference_point = [0.8, 0.5]
max_evaluations = 25000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PolynomialMutation(probability=1.0 /
problem.number_of_variables,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(
comparator=RankingAndCrowdingDistanceComparator()),
dominance_comparator=GDominanceComparator(reference_point),
termination_criterion=StoppingByEvaluations(max=max_evaluations))
algorithm.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
algorithm.observable.register(
observer=VisualizerObserver(reference_front=problem.reference_front,
reference_point=(reference_point)))
algorithm.run()
front = algorithm.get_result()
# Plot front
plot_front = Plot(plot_title='Pareto front approximation',
axis_labels=problem.obj_labels,
def run(self) -> List[S]:
# selection operator 1
selection_operator_1 = BinaryTournamentSelection()
# selection operator 2
selection_operator_2 = DifferentialEvolutionSelection()
# crossover operator 1
crossover_operator_1 = SBXCrossover(1.0, 20.0)
# crossover operator 2
crossover_operator_2 = DifferentialEvolutionCrossover(0.2, 0.5, 0.5)
# crossover operator 3
crossover_operator_3 = DifferentialEvolutionCrossover(1.0, 0.5, 0.5)
# mutation operator 1
mutation_operator_1 = PolynomialMutation(
1.0 / self.problem.number_of_variables, 20.0)
# dominance comparator
dominance = DominanceComparator()
# array that stores the "generational" HV quality
generational_hv: List[float] = []
parent_1: List[FloatSolution] = [None, None]
parent_2: List[FloatSolution] = []
parent_3: List[FloatSolution] = []
# initialize some local and global variables
pool_1: List[FloatSolution] = []
pool_2: List[FloatSolution] = []
# size of elite subset used for fitness sharing between subpopulations
nrOfDirectionalSolutionsToEvolve = int(self.population_size / 5)
# subpopulation 1
pool_1_size = int(self.population_size -
(nrOfDirectionalSolutionsToEvolve / 2))
# subpopulation 2
pool_2_size = int(self.population_size -
(nrOfDirectionalSolutionsToEvolve / 2))
print(
str(pool_1_size) + " - " + str(nrOfDirectionalSolutionsToEvolve) +
" - " + str(self.mix_interval))
evaluations = 0
current_gen = 0
directionalArchiveSize = 2 * self.population_size
weights = self.__create_uniform_weights(
directionalArchiveSize, self.problem.number_of_objectives)
directionalArchive = self.__create_directional_archive(weights)
neighbourhoods = self.__create_neighbourhoods(directionalArchive,
self.population_size)
nrOfReplacements = 1
iniID = 0
# Create the initial pools
# pool1
pool_1: List[FloatSolution] = []
for _ in range(pool_1_size):
new_solution = self.problem.create_solution()
new_solution = self.problem.evaluate(new_solution)
evaluations += 1
pool_1.append(new_solution)
self.__update_extreme_values(new_solution)
dr = directionalArchive[iniID]
dr.curr_sol = new_solution
iniID += 1
# pool2
pool_2: List[FloatSolution] = []
for _ in range(pool_2_size):
new_solution = self.problem.create_solution()
new_solution = self.problem.evaluate(new_solution)
evaluations += 1
pool_2.append(new_solution)
self.__update_extreme_values(new_solution)
dr = directionalArchive[iniID]
dr.curr_sol = new_solution
iniID += 1
# directional archive initialization
pool_A: List[FloatSolution] = []
while iniID < directionalArchiveSize:
new_solution = self.problem.create_solution()
new_solution = self.problem.evaluate(new_solution)
evaluations += 1
pool_A.append(new_solution)
self.__update_extreme_values(new_solution)
dr = directionalArchive[iniID]
dr.curr_sol = new_solution
iniID += 1
mix = self.mix_interval
h = HyperVolume(reference_point=[1] *
self.problem.number_of_objectives)
insertionRate: List[float] = [0, 0, 0]
bonusEvals: List[int] = [0, 0, nrOfDirectionalSolutionsToEvolve]
testRun = True
# record the generational HV of the initial population
combiAll: List[FloatSolution] = []
cGen = int(evaluations / self.report_interval)
if cGen > 0:
combiAll = pool_1 + pool_2 + pool_A
combiAll = self.r.replace(
combiAll[:pool_1_size + pool_2_size],
combiAll[pool_1_size + pool_2_size:],
)
hval = h.compute([s.objectives for s in combiAll])
for _ in range(cGen):
generational_hv.append(hval)
current_gen = cGen
# the main loop of the algorithm
while evaluations < self.max_evaluations:
offspringPop1: List[FloatSolution] = []
offspringPop2: List[FloatSolution] = []
offspringPop3: List[FloatSolution] = []
dirInsertPool1: List[FloatSolution] = []
dirInsertPool2: List[FloatSolution] = []
dirInsertPool3: List[FloatSolution] = []
# evolve pool1 - using SPEA2 evolutionary model
nfe: int = 0
while nfe < (pool_1_size + bonusEvals[0]):
parent_1[0] = selection_operator_1.execute(pool_1)
parent_1[1] = selection_operator_1.execute(pool_1)
child1a: FloatSolution = crossover_operator_1.execute(
parent_1)[0]
child1a = mutation_operator_1.execute(child1a)
child1a = self.problem.evaluate(child1a)
evaluations += 1
nfe += 1
offspringPop1.append(child1a)
dirInsertPool1.append(child1a)
# evolve pool2 - using DEMO SP evolutionary model
i: int = 0
unselectedIDs: List[int] = []
for ID in range(len(pool_2)):
unselectedIDs.append(ID)
nfe = 0
while nfe < (pool_2_size + bonusEvals[1]):
index = random.randint(0, len(unselectedIDs) - 1)
i = unselectedIDs[index]
unselectedIDs.pop(index)
parent_2 = selection_operator_2.execute(pool_2)
crossover_operator_2.current_individual = pool_2[i]
child2 = crossover_operator_2.execute(parent_2)
child2 = self.problem.evaluate(child2[0])
evaluations += 1
nfe += 1
result = dominance.compare(pool_2[i], child2)
if result == -1: # solution i dominates child
offspringPop2.append(pool_2[i])
elif result == 1: # child dominates
offspringPop2.append(child2)
else: # the two solutions are non-dominated
offspringPop2.append(child2)
offspringPop2.append(pool_2[i])
dirInsertPool2.append(child2)
if len(unselectedIDs) == 0:
for ID in range(len(pool_2)):
unselectedIDs.append(random.randint(
0,
len(pool_2) - 1))
# evolve pool3 - Directional Decomposition DE/rand/1/bin
IDs = self.__compute_neighbourhood_Nfe_since_last_update(
neighbourhoods, directionalArchive,
nrOfDirectionalSolutionsToEvolve)
nfe = 0
for j in range(len(IDs)):
if nfe < bonusEvals[2]:
nfe += 1
else:
break
cID = IDs[j]
chosenSol: FloatSolution = None
if directionalArchive[cID].curr_sol != None:
chosenSol = directionalArchive[cID].curr_sol
else:
chosenSol = pool_1[0]
print("error!")
parent_3: List[FloatSolution] = [None, None, None]
r1 = random.randint(0, len(neighbourhoods[cID]) - 1)
r2 = random.randint(0, len(neighbourhoods[cID]) - 1)
r3 = random.randint(0, len(neighbourhoods[cID]) - 1)
while r2 == r1:
r2 = random.randint(0, len(neighbourhoods[cID]) - 1)
while r3 == r1 or r3 == r2:
r3 = random.randint(0, len(neighbourhoods[cID]) - 1)
parent_3[0] = directionalArchive[r1].curr_sol
parent_3[1] = directionalArchive[r2].curr_sol
parent_3[2] = directionalArchive[r3].curr_sol
crossover_operator_3.current_individual = chosenSol
child3 = crossover_operator_3.execute(parent_3)[0]
child3 = mutation_operator_1.execute(child3)
child3 = self.problem.evaluate(child3)
evaluations += 1
dirInsertPool3.append(child3)
# compute directional improvements
# pool1
improvements = 0
for j in range(len(dirInsertPool1)):
testSol = dirInsertPool1[j]
self.__update_extreme_values(testSol)
improvements += self.__update_neighbourhoods(
directionalArchive, testSol, nrOfReplacements)
insertionRate[0] += (1.0 * improvements) / len(dirInsertPool1)
# pool2
improvements = 0
for j in range(len(dirInsertPool2)):
testSol = dirInsertPool2[j]
self.__update_extreme_values(testSol)
improvements += self.__update_neighbourhoods(
directionalArchive, testSol, nrOfReplacements)
insertionRate[1] += (1.0 * improvements) / len(dirInsertPool2)
# pool3
improvements = 0
for j in range(len(dirInsertPool3)):
testSol = dirInsertPool3[j]
self.__update_extreme_values(testSol)
improvements += self.__update_neighbourhoods(
directionalArchive, testSol, nrOfReplacements)
# on java, dividing a floating number by 0, returns NaN
# on python, dividing a floating number by 0, returns an exception
if len(dirInsertPool3) == 0:
insertionRate[2] = None
else:
insertionRate[2] += (1.0 * improvements) / len(dirInsertPool3)
for dr in directionalArchive:
offspringPop3.append(dr.curr_sol)
offspringPop1 = offspringPop1 + pool_1
pool_1 = self.r.replace(offspringPop1[:pool_1_size],
offspringPop1[pool_1_size:])
pool_2 = self.r.replace(offspringPop2[:pool_2_size],
offspringPop2[pool_2_size:])
combi: List[FloatSolution] = []
mix -= 1
if mix == 0:
mix = self.mix_interval
combi = combi + pool_1 + pool_2 + offspringPop3
print("Combi size: " + str(len(combi)))
combi = self.r.replace(
combi[:nrOfDirectionalSolutionsToEvolve],
combi[nrOfDirectionalSolutionsToEvolve:],
)
insertionRate[0] /= self.mix_interval
insertionRate[1] /= self.mix_interval
if insertionRate[2] != None:
insertionRate[2] /= self.mix_interval
"""
print(
"Insertion rates: "
+ str(insertionRate[0])
+ " - "
+ str(insertionRate[1])
+ " - "
+ str(insertionRate[2])
+ " - Test run:"
+ str(testRun)
)
"""
if testRun:
if (insertionRate[0] > insertionRate[1]) and (
insertionRate[0] > insertionRate[2]):
print("SPEA2 win - bonus run!")
bonusEvals[0] = nrOfDirectionalSolutionsToEvolve
bonusEvals[1] = 0
bonusEvals[2] = 0
if (insertionRate[1] > insertionRate[0]) and (
insertionRate[1] > insertionRate[2]):
print("DE win - bonus run!")
bonusEvals[0] = 0
bonusEvals[1] = nrOfDirectionalSolutionsToEvolve
bonusEvals[2] = 0
if (insertionRate[2] > insertionRate[0]) and (
insertionRate[2] > insertionRate[1]):
print("Directional win - no bonus!")
bonusEvals[0] = 0
bonusEvals[1] = 0
bonusEvals[2] = nrOfDirectionalSolutionsToEvolve
else:
print("Test run - no bonus!")
bonusEvals[0] = 0
bonusEvals[1] = 0
bonusEvals[2] = nrOfDirectionalSolutionsToEvolve
testRun = not testRun
insertionRate[0] = 0.0
insertionRate[1] = 0.0
insertionRate[2] = 0.0
pool_1 = pool_1 + combi
pool_2 = pool_2 + combi
print("Sizes: " + str(len(pool_1)) + " " + str(len(pool_2)))
pool_1 = self.r.replace(pool_1[:pool_1_size],
pool_1[pool_1_size:])
pool_2 = self.r.replace(pool_2[:pool_2_size],
pool_2[pool_2_size:])
self.__clear_Nfe_history(directionalArchive)
hVal1 = h.compute([s.objectives for s in pool_1])
hVal2 = h.compute([s.objectives for s in pool_2])
hVal3 = h.compute([s.objectives for s in offspringPop3])
newGen = int(evaluations / self.report_interval)
if newGen > current_gen:
print("Hypervolume: " + str(newGen) + " - " + str(hVal1) +
" - " + str(hVal2) + " - " + str(hVal3))
combi = combi + pool_1 + pool_2 + offspringPop3
combi = self.r.replace(combi[:self.population_size * 2],
combi[self.population_size * 2:])
hval = h.compute([s.objectives for s in combi])
for j in range(current_gen, newGen):
generational_hv.append(hval)
current_gen = newGen
# return the final combined non-dominated set of maximum size = (populationSize * 2)
combiAll: List[FloatSolution] = []
combiAll = combiAll + pool_1 + pool_2 + pool_A
combiAll = self.r.replace(combiAll[:self.population_size * 2],
combiAll[self.population_size * 2:])
return combiAll
