def __init__(
self,
problem: Problem,
population_size: int,
mutation: Mutation,
crossover: Crossover,
number_of_cores: int,
client: 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,
max_population_size: int,
reference_point: S,
dominance_comparator: Comparator = DominanceComparator()):
super(RankingAndFitnessSelection, self).__init__()
self.max_population_size = max_population_size
self.dominance_comparator = dominance_comparator
self.reference_point = reference_point
def __init__(self,
problem: FloatProblem,
swarm_size: int,
uniform_mutation: UniformMutation,
non_uniform_mutation: NonUniformMutation,
leaders: Optional[BoundedArchive],
epsilon: float,
termination_criterion: TerminationCriterion,
swarm_generator: Generator = store.default_generator,
swarm_evaluator: Evaluator = store.default_evaluator):
""" This class implements the OMOPSO algorithm as described in
todo Update this reference
* SMPSO: A new PSO-based metaheuristic for multi-objective optimization
The implementation of OMOPSO provided in jMetalPy follows the algorithm template described in the algorithm
templates section of the documentation.
:param problem: The problem to solve.
:param swarm_size: Size of the swarm.
:param leaders: Archive for leaders.
"""
super(OMOPSO, self).__init__(problem=problem, swarm_size=swarm_size)
self.swarm_generator = swarm_generator
self.swarm_evaluator = swarm_evaluator
self.termination_criterion = termination_criterion
self.observable.register(termination_criterion)
self.uniform_mutation = uniform_mutation
self.non_uniform_mutation = non_uniform_mutation
self.leaders = leaders
self.epsilon = epsilon
self.epsilon_archive = NonDominatedSolutionListArchive(
EpsilonDominanceComparator(epsilon))
self.c1_min = 1.5
self.c1_max = 2.0
self.c2_min = 1.5
self.c2_max = 2.0
self.r1_min = 0.0
self.r1_max = 1.0
self.r2_min = 0.0
self.r2_max = 1.0
self.weight_min = 0.1
self.weight_max = 0.5
self.change_velocity1 = -1
self.change_velocity2 = -1
self.dominance_comparator = DominanceComparator()
self.speed = numpy.zeros(
(self.swarm_size, self.problem.number_of_variables), dtype=float)
def execute(self, front: List[S]) -> S:
if front is None:
raise Exception('The front is null')
elif len(front) == 0:
raise Exception('The front is empty')
result = front[0]
for solution in front[1:]:
if DominanceComparator().compare(solution, result) < 0:
result = solution
return result
def __init__(self,
problem: FloatProblem,
swarm_size: int,
mutation: Mutation,
leaders: Optional[BoundedArchive],
termination_criterion: TerminationCriterion = store.
default_termination_criteria,
swarm_generator: Generator = store.default_generator,
swarm_evaluator: Evaluator = store.default_evaluator):
""" This class implements the SMPSO algorithm as described in
* SMPSO: A new PSO-based metaheuristic for multi-objective optimization
* MCDM 2009. DOI: `<http://dx.doi.org/10.1109/MCDM.2009.4938830/>`_.
The implementation of SMPSO provided in jMetalPy follows the algorithm template described in the algorithm
templates section of the documentation.
:param problem: The problem to solve.
:param swarm_size: Size of the swarm.
:param max_evaluations: Maximum number of evaluations/iterations.
:param mutation: Mutation operator (see :py:mod:`jmetal.operator.mutation`).
:param leaders: Archive for leaders.
"""
super(SMPSO, self).__init__(problem=problem, swarm_size=swarm_size)
self.swarm_generator = swarm_generator
self.swarm_evaluator = swarm_evaluator
self.termination_criterion = termination_criterion
self.observable.register(termination_criterion)
self.mutation_operator = mutation
self.leaders = leaders
self.c1_min = 1.5
self.c1_max = 2.5
self.c2_min = 1.5
self.c2_max = 2.5
self.r1_min = 0.0
self.r1_max = 1.0
self.r2_min = 0.0
self.r2_max = 1.0
self.min_weight = 0.1
self.max_weight = 0.1
self.change_velocity1 = -1
self.change_velocity2 = -1
self.dominance_comparator = DominanceComparator()
self.speed = numpy.zeros(
(self.swarm_size, self.problem.number_of_variables), dtype=float)
self.delta_max, self.delta_min = numpy.empty(problem.number_of_variables), \
numpy.empty(problem.number_of_variables)
def __init__(self,
problem: DynamicProblem,
population_size: int,
cr: float,
f: float,
termination_criterion: TerminationCriterion,
k: float = 0.5,
population_generator: Generator = store.default_generator,
population_evaluator: Evaluator = store.default_evaluator,
dominance_comparator: Comparator = DominanceComparator()):
super(DynamicGDE3,
self).__init__(problem, population_size, cr, f,
termination_criterion, k, population_generator,
population_evaluator, dominance_comparator)
self.completed_iterations = 0
def default_comparator(self):
return DominanceComparator()
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 __init__(self, comparator: Comparator = DominanceComparator()):
super(FastNonDominatedRanking, self).__init__(comparator)
def __init__(self, comparator: Comparator = DominanceComparator()):
super(StrengthRanking, self).__init__(comparator)
def __init__(self, comparator: Comparator = DominanceComparator()):
super(Ranking, self).__init__()
self.number_of_comparisons = 0
self.ranked_sublists = []
self.comparator = comparator
def __init__(self, comparator: Comparator = DominanceComparator()):
super(BinaryTournamentSelection, self).__init__()
self.comparator = comparator
def __init__(self,
max_population_size: int,
dominance_comparator: Comparator = DominanceComparator()):
super(RankingAndCrowdingDistanceSelection, self).__init__()
self.max_population_size = max_population_size
self.dominance_comparator = dominance_comparator
def __init__(self, dominance_comparator=DominanceComparator()):
super(NonDominatedSolutionListArchive, self).__init__()
self.comparator = dominance_comparator
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())
print_variables_to_file(
front, 'VAR.' + algorithm.get_name() + "-" + problem.get_name())
print('Algorithm (continuous problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
def setUp(self):
self.comparator = DominanceComparator()