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