Source code for jmetal.algorithm.singleobjective.evolution_strategy
from copy import copy
from typing import List, TypeVar
from jmetal.core.algorithm import EvolutionaryAlgorithm
from jmetal.core.operator import Mutation
from jmetal.core.problem import Problem
from jmetal.util.constraint_handling import overall_constraint_violation_degree
from jmetal.util.evaluator import Evaluator, SequentialEvaluator
from jmetal.util.generator import Generator, RandomGenerator
from jmetal.util.termination_criterion import TerminationCriterion
S = TypeVar("S")
R = TypeVar("R")
"""
.. module:: evolutionary_algorithm
:platform: Unix, Windows
:synopsis: Implementation of Evolutionary Algorithms.
.. moduleauthor:: Antonio J. Nebro <antonio@lcc.uma.es>, Antonio Benítez-Hidalgo <antonio.b@uma.es>
"""
[docs]
class EvolutionStrategy(EvolutionaryAlgorithm[S, R]):
def __init__(
self,
problem: Problem,
mu: int,
lambda_: int,
elitist: bool,
mutation: Mutation,
termination_criterion: TerminationCriterion,
population_generator: Generator = RandomGenerator(),
population_evaluator: Evaluator = SequentialEvaluator(),
):
super(EvolutionStrategy, self).__init__(problem=problem, population_size=mu, offspring_population_size=lambda_)
self.mu = mu
self.lambda_ = lambda_
self.elitist = elitist
self.mutation_operator = mutation
self.population_generator = population_generator
self.population_evaluator = population_evaluator
self.termination_criterion = termination_criterion
self.observable.register(termination_criterion)
[docs]
def create_initial_solutions(self) -> List[S]:
return [self.population_generator.new(self.problem) for _ in range(self.population_size)]
[docs]
def evaluate(self, solution_list: List[S]):
return self.population_evaluator.evaluate(solution_list, self.problem)
[docs]
def stopping_condition_is_met(self) -> bool:
return self.termination_criterion.is_met
[docs]
def selection(self, population: List[S]) -> List[S]:
return population
[docs]
def reproduction(self, population: List[S]) -> List[S]:
offspring_population = []
for solution in population:
for j in range(int(self.lambda_ / self.mu)):
new_solution = copy(solution)
offspring_population.append(self.mutation_operator.execute(new_solution))
return offspring_population
[docs]
def replacement(self, population: List[S], offspring_population: List[S]) -> List[S]:
population_pool = []
if self.elitist:
population_pool = population
population_pool.extend(offspring_population)
else:
population_pool.extend(offspring_population)
population_pool.sort(key=lambda s: (overall_constraint_violation_degree(s), s.objectives[0]))
new_population = []
for i in range(self.mu):
new_population.append(population_pool[i])
return new_population
[docs]
def result(self) -> R:
return self.solutions[0]
[docs]
def get_name(self) -> str:
return "Elitist evolution Strategy"