def test_should_the_solution_change_if_the_probability_is_one(self):
operator = UniformMutation(1.0, 3.0)
solution = FloatSolution([-5, -5, -5], [5, 5, 5], 1)
solution.variables = [1.0, 2.0, 3.0]
mutated_solution = operator.execute(solution)
self.assertNotEqual([1.0, 2.0, 3.0], mutated_solution.variables)
def test_should_the_solution_remain_unchanged_if_the_probability_is_zero(
self):
operator = UniformMutation(0.0, 3.0)
solution = FloatSolution(3, 1, [-5, -5, -5], [5, 5, 5])
solution.variables = [1.0, 2.0, 3.0]
mutated_solution = operator.execute(solution)
self.assertEqual([1.0, 2.0, 3.0], mutated_solution.variables)
def test_should_the_solution_change_between_max_and_min_value(self):
operator = UniformMutation(1.0, 5)
solution = FloatSolution([-1, 12, -3, -5], [1, 17, 3, -2], 1)
solution.variables = [-7.0, 3.0, 12.0, 13.4]
mutated_solution = operator.execute(solution)
for i in range(solution.number_of_variables):
self.assertGreaterEqual(mutated_solution.variables[i],
solution.lower_bound[i])
self.assertLessEqual(mutated_solution.variables[i],
solution.upper_bound[i])
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 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 test_should_constructor_raise_an_exception_if_the_probability_is_lower_than_zero(
self):
with self.assertRaises(Exception):
UniformMutation(-12)
def test_should_constructor_raise_an_exception_if_the_probability_is_greater_than_one(
self):
with self.assertRaises(Exception):
UniformMutation(2)
def test_should_constructor_create_a_valid_operator(self):
operator = UniformMutation(0.5, 20)
self.assertEqual(0.5, operator.probability)
self.assertEqual(20, operator.perturbation)
def test_should_constructor_create_a_non_null_object(self):
operator = UniformMutation(0.3)
operator2 = UniformMutation(0.3, 0.7)
self.assertIsNotNone(operator)
self.assertIsNotNone(operator2)
def test_should_constructor_raises_an_exception_is_probability_is_higher_than_one(
self) -> None:
with self.assertRaises(Exception):
UniformMutation(1.01)
def test_should_constructor_raises_an_exception_is_probability_is_negative(
self) -> None:
with self.assertRaises(Exception):
UniformMutation(-1)