def test_should_compute_density_estimator_work_properly_case3(self):
""" Case 3: The archive contains two solutions.
"""
archive = CrowdingDistanceArchive(4)
solution1 = Solution(2, 2)
solution1.objectives = [0.0, 3.0]
solution2 = Solution(2, 2)
solution2.objectives = [1.0, 2.0]
solution3 = Solution(2, 2)
solution3.objectives = [2.0, 1.5]
archive.add(solution1)
archive.add(solution2)
archive.add(solution3)
archive.compute_density_estimator()
self.assertEqual(3, archive.size())
self.assertEqual(float("inf"),
solution1.attributes["crowding_distance"])
self.assertEqual(float("inf"),
solution3.attributes["crowding_distance"])
self.assertTrue(
solution2.attributes["crowding_distance"] < float("inf"))
def test_should_add_work_properly_case6(self):
"""Case 6: add a non-dominated solution when the archive is full should not include
the solution if it has the highest distance crowding value.
"""
archive = CrowdingDistanceArchive(4)
solution1 = Solution(1, 2)
solution1.variables = [1.0]
solution1.objectives = [0.0, 3.0]
solution2 = Solution(1, 2)
solution2.variables = [2.0]
solution2.objectives = [1.0, 2.0]
solution3 = Solution(1, 2)
solution3.variables = [3.0]
solution3.objectives = [2.0, 1.5]
solution4 = Solution(1, 2)
solution4.variables = [4.0]
solution4.objectives = [3.0, 0.0]
new_solution = Solution(1, 2)
new_solution.variables = [5.0]
new_solution.objectives = [1.1, 1.9]
archive.add(solution1)
archive.add(solution2)
archive.add(solution3)
archive.add(solution4)
archive.add(new_solution)
self.assertEqual(4, archive.size())
self.assertTrue(new_solution not in archive.solution_list)
def test_should_add_work_properly_case7(self):
""" Case 7: add a non-dominated solution when the archive is full should remove all the dominated solutions.
"""
archive = CrowdingDistanceArchive(4)
solution1 = Solution(2, 2)
solution1.objectives = [0.0, 3.0]
solution2 = Solution(2, 2)
solution2.objectives = [1.0, 2.0]
solution3 = Solution(2, 2)
solution3.objectives = [2.0, 1.5]
solution4 = Solution(2, 2)
solution4.objectives = [3.0, 0.0]
new_solution = Solution(2, 2)
new_solution.objectives = [-1.0, -1.0]
archive.add(solution1)
archive.add(solution2)
archive.add(solution3)
archive.add(solution4)
archive.add(new_solution)
self.assertEqual(1, archive.size())
self.assertTrue(new_solution in archive.solution_list)
def test_SMPSO(self):
SMPSO(problem=self.problem,
swarm_size=self.population_size,
mutation=self.mutation,
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max_evaluations=1000)).run()
def configurar_SMPSO(self):
algorithm = SMPSO(
problem=self.problema,
swarm_size=self.maxima_poblacion,
mutation=PolynomialMutation(probability=self.probabilidad, distribution_index=20),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(max_evaluations=self.evaluaciones))
return algorithm
def my_binary_mopso(problem: TestSelection, swarm):
return BMOPSO(
problem=problem,
swarm_size=swarm,
epsilon=0.075,
mutation=BitFlipMutation(probability=0),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(max=2000),
)
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),
termination_criterion=StoppingByEvaluations(
max_evaluations=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_evaluations=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_evaluations=max_evaluations),
),
algorithm_tag="SMPSO",
problem_tag=problem_tag,
run=run,
))
return jobs
def configurar_OMOPSO(self):
algorithm = OMOPSO(
problem=self.problema,
swarm_size=self.maxima_poblacion,
epsilon=0.0075,
uniform_mutation=UniformMutation(probability=self.probabilidad, perturbation=0.5),
non_uniform_mutation=NonUniformMutation(probability=self.probabilidad, perturbation=0.5),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(max_evaluations=self.evaluaciones))
return algorithm
def test_should_compute_density_estimator_work_properly_case1(self):
"""Case 1: The archive contains one solution."""
archive = CrowdingDistanceArchive(4)
solution1 = Solution(2, 2)
solution1.objectives = [0.0, 3.0]
archive.add(solution1)
archive.compute_density_estimator()
self.assertEqual(1, archive.size())
self.assertEqual(float("inf"), solution1.attributes["crowding_distance"])
def test_should_SMPSO_work_when_solving_problem_ZDT1_with_standard_settings(self):
problem = ZDT1()
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_evaluations=25000),
)
algorithm.run()
front = algorithm.get_result()
hv = HyperVolume(reference_point=[1, 1])
value = hv.compute([front[i].objectives for i in range(len(front))])
self.assertTrue(value >= 0.655)
from jmetal.operator import PolynomialMutation
from jmetal.problem import DTLZ1
from jmetal.util.archive import CrowdingDistanceArchive
from jmetal.util.observer import ProgressBarObserver
from jmetal.util.solutions import print_function_values_to_file, print_variables_to_file
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == '__main__':
problem = DTLZ1(number_of_objectives=5)
max_evaluations = 25000
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.observable.register(observer=ProgressBarObserver(max=max_evaluations))
algorithm.run()
front = algorithm.get_result()
label = algorithm.get_name() + "." + problem.get_name()
# Plot front
plot_front = Plot(plot_title='Pareto front approximation', reference_front=problem.reference_front,
axis_labels=problem.obj_labels)
plot_front.plot(front, label=algorithm.label, filename=algorithm.get_name())
from jmetal.util.archive import CrowdingDistanceArchive
from jmetal.util.neighborhood import C9
from jmetal.util.observer import ProgressBarObserver
from jmetal.util.solutions import read_solutions
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == '__main__':
problem = ZDT1()
problem.reference_front = read_solutions(filename='resources/reference_front/ZDT4.pf')
max_evaluations = 25000
algorithm = MOCell(
problem=problem,
population_size=100,
neighborhood=C9(10, 10),
archive=CrowdingDistanceArchive(100),
mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(max=max_evaluations)
)
algorithm.observable.register(observer=ProgressBarObserver(max=max_evaluations))
algorithm.run()
front = algorithm.get_result()
# Plot front
plot_front = Plot(plot_title='Pareto front approximation', reference_front=problem.reference_front, axis_labels=problem.obj_labels)
plot_front.plot(front, label=algorithm.label )
print('Algorithm (continuous problem): ' + algorithm.get_name())
def configurar_algoritmo(self,
hora_show: datetime,
hora_minima: datetime = datetime.time(0, 0),
algoritmo: str = 'MOGA',
mutation_probability: float = 0.25,
max_evaluations: int = 500,
population: int = 100):
hora_minima, hora_show = self.restricciones_hora(
hora_minima, hora_show)
if (hora_minima == 0):
hora_minima = hora_show - 180
restricciones_baja = list([hora_minima, -100, -100, 0, 0])
restricciones_alta = list([hora_show, 0, 0, 100, 100])
self.problem = HVAC(lower_bound=restricciones_baja,
upper_bound=restricciones_alta,
number_of_configurations=3)
print("algoritmo: ", algoritmo)
if algoritmo == 'MOGA':
algorithm = MOGA(problem=self.problem,
population_size=population,
offspring_population_size=population,
mutation=IntegerPolynomialMutationD(
probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossoverD(
probability=mutation_probability,
distribution_index=20),
termination_criterion=StoppingByEvaluations(
max=max_evaluations),
dominance_comparator=DominanceComparator())
elif algoritmo == "NSGAII":
algorithm = NSGAII(problem=self.problem,
population_size=population,
offspring_population_size=population,
mutation=IntegerPolynomialMutationD(
probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossoverD(
probability=mutation_probability,
distribution_index=20),
termination_criterion=StoppingByEvaluations(
max=max_evaluations),
dominance_comparator=DominanceComparator())
elif algoritmo == 'OMOPSO':
algorithm = OMOPSO(problem=self.problem,
swarm_size=population,
epsilon=0.0075,
uniform_mutation=UniformMutation(
probability=mutation_probability,
perturbation=0.5),
non_uniform_mutation=NonUniformMutation(
probability=mutation_probability,
perturbation=0.5),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max=max_evaluations))
elif algoritmo == 'SMPSO':
algorithm = SMPSO(problem=self.problem,
swarm_size=population,
mutation=IntegerPolynomialMutation(
probability=mutation_probability,
distribution_index=20),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max=max_evaluations))
elif algoritmo == 'SPEA2':
algorithm = SPEA2(problem=self.problem,
population_size=population,
offspring_population_size=population,
mutation=IntegerPolynomialMutationD(
probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossoverD(
probability=mutation_probability,
distribution_index=20),
termination_criterion=StoppingByEvaluations(
max=max_evaluations),
dominance_comparator=DominanceComparator())
else:
print("Algoritmo no válido. Creando MOGA por defecto...")
algorithm = MOGA(problem=self.problem,
population_size=population,
offspring_population_size=population,
mutation=IntegerPolynomialMutationD(
probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossoverD(
probability=mutation_probability,
distribution_index=20),
termination_criterion=StoppingByEvaluations(
max=max_evaluations),
dominance_comparator=DominanceComparator())
self.algoritmo = algorithm
self.algoritmo.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
return algorithm
def get_algorithm_instance(algo_name):
algos = {
'smpso':
SMPSO(problem=objective_function,
swarm_size=swarm_size,
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
'omopso':
OMOPSO(problem=objective_function,
swarm_size=swarm_size,
epsilon=0.0075,
uniform_mutation=UniformMutation(
probability=mutation_probability, perturbation=0.5),
non_uniform_mutation=NonUniformMutation(
mutation_probability,
perturbation=0.5,
max_iterations=int(max_evaluations / swarm_size)),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
'nsgaii':
NSGAII(problem=objective_function,
population_size=30,
offspring_population_size=30,
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
'spea2':
SPEA2(problem=objective_function,
population_size=30,
offspring_population_size=30,
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
'moead':
MOEAD(
problem=objective_function,
population_size=30,
crossover=DifferentialEvolutionCrossover(CR=1.0, F=0.5, K=0.5),
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
aggregative_function=Tschebycheff(
dimension=objective_function.number_of_objectives),
neighbor_size=5,
neighbourhood_selection_probability=0.9,
max_number_of_replaced_solutions=2,
weight_files_path='resources/MOEAD_weights',
termination_criterion=StoppingByEvaluations(max_evaluations=700)),
'ibea':
IBEA(problem=objective_function,
kappa=1.0,
population_size=30,
offspring_population_size=30,
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(max_evaluations))
}
return algos[algo_name]
def configure_experiment(problems: dict, n_run: int):
jobs = []
for run in range(n_run):
for problem_tag, problem in problems.items():
jobs.append(
Job(
algorithm=NSGAII(
problem=problem,
population_size=POPULATION_SIZE,
offspring_population_size=POPULATION_SIZE,
mutation=IntegerPolynomialMutation(probability=0.05, distribution_index=20),
crossover=IntegerSBXCrossover(probability=0.3, distribution_index=20),
termination_criterion=StoppingByEvaluationsCustom(max_evaluations=max_evaluations, reference_point=REFERENCE_POINT,
AlgorithmName='NSGAII')
# termination_criterion=stopCriterion
),
algorithm_tag='NSGAII',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=NSGAIII(
problem=problem,
population_size=POPULATION_SIZE,
mutation=IntegerPolynomialMutation(probability=0.05, distribution_index=20),
crossover=IntegerSBXCrossover(probability=0.3, distribution_index=20),
reference_directions=UniformReferenceDirectionFactory(2, n_points=91),
termination_criterion=StoppingByEvaluationsCustom(max_evaluations=max_evaluations,
reference_point=REFERENCE_POINT,
AlgorithmName='NSGAIII')
# termination_criterion=stopCriterion
),
algorithm_tag='NSGAIII',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=SPEA2(
problem=problem,
population_size=POPULATION_SIZE,
offspring_population_size=POPULATION_SIZE,
mutation=IntegerPolynomialMutation(probability=0.05, distribution_index=20),
crossover=IntegerSBXCrossover(probability=0.3, distribution_index=20),
termination_criterion=StoppingByEvaluationsCustom(max_evaluations=max_evaluations, reference_point=REFERENCE_POINT,
AlgorithmName='SPEA2')
),
algorithm_tag='SPEA2',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=HYPE(
problem=problem,
reference_point=reference_point,
population_size=POPULATION_SIZE,
offspring_population_size=POPULATION_SIZE,
mutation=IntegerPolynomialMutation(probability=0.05, distribution_index=20),
crossover=IntegerSBXCrossover(probability=0.3, distribution_index=20),
termination_criterion=StoppingByEvaluationsCustom(max_evaluations=max_evaluations, reference_point=REFERENCE_POINT,
AlgorithmName='HYPE')
),
algorithm_tag='HYPE',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=MOCell(
problem=problem,
population_size=POPULATION_SIZE,
neighborhood=C9(4, 4),
archive=CrowdingDistanceArchive(100),
mutation=IntegerPolynomialMutation(probability=0.05, distribution_index=20),
crossover=IntegerSBXCrossover(probability=0.3, distribution_index=20),
termination_criterion=StoppingByEvaluationsCustom(max_evaluations=max_evaluations, reference_point=REFERENCE_POINT,
AlgorithmName='MOCell')
),
algorithm_tag='MOCELL',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=OMOPSO(
problem=problem,
swarm_size=swarm_size,
epsilon=0.0075,
uniform_mutation=UniformMutation(probability=0.05, perturbation=0.5),
non_uniform_mutation=NonUniformMutation(mutation_probability, perturbation=0.5,
max_iterations=int(max_evaluations / swarm_size)),
leaders=CrowdingDistanceArchive(10),
termination_criterion=StoppingByEvaluationsCustom(max_evaluations=max_evaluations,
reference_point=REFERENCE_POINT,
AlgorithmName='OMOPSO')
),
algorithm_tag='OMOPSO',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=SMPSO(
problem=problem,
swarm_size=POPULATION_SIZE,
mutation=PolynomialMutation(probability=0.05, distribution_index=20),
leaders=CrowdingDistanceArchive(20),
termination_criterion=StoppingByEvaluationsCustom(max_evaluations=max_evaluations,
reference_point=REFERENCE_POINT,
AlgorithmName='SMPSO')
),
algorithm_tag='SMPSO',
problem_tag=problem_tag,
run=run,
)
)
return jobs