def __init__(self,
problem: Problem,
initial_population_size: int,
initial_inidividual_energy: float,
reproduction_threshold: float,
energy_exchange_operator: EnergyExchange,
death_operator: Death,
termination_criterion: TerminationCriterion,
neighbours_operator: Neighbours,
reproduction_operator: Reproduction,
population_generator: Generator = RandomGenerator(),
population_evaluator: Evaluator = SequentialEvaluator()):
super(Emas, self).__init__()
self.reproduction_operator = reproduction_operator
self.reproduction_threshold = reproduction_threshold
self.initial_inidividual_energy = initial_inidividual_energy
self.neighbours_operator = neighbours_operator
self.problem = problem
self.initial_population_size = initial_population_size
self.population_generator = population_generator
self.population_evaluator = population_evaluator
self.termination_criterion = termination_criterion
self.observable.register(termination_criterion)
self.death_operator = death_operator
self.energy_exchange_operator = energy_exchange_operator
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)
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(EvolutionStrategyWithHistory,
self).__init__(problem=problem,
mu=mu,
lambda_=lambda_,
elitist=elitist,
mutation=mutation,
termination_criterion=termination_criterion,
population_generator=population_generator,
population_evaluator=population_evaluator)
self.history = []
def load_initial_solutions(self, warm_startup_info: Mapping,
problem: Problem) -> None:
self.warm_startup_info = warm_startup_info
if warm_startup_info and 'paths' in self.warm_startup_info.keys(
) and len(self.warm_startup_info['paths']) > 0:
from jmetal.util.generator import InjectorGenerator
one_sol_variables = self.warm_startup_info['paths'][0]
solution = PermutationSolution(
number_of_variables=problem.number_of_variables,
number_of_objectives=problem.number_of_objectives)
solution.variables = one_sol_variables
self._initial_solutions.append(problem.evaluate(solution))
for one_sol_variables in self.warm_startup_info['paths'][1:]:
solution = copy(solution)
solution.variables = one_sol_variables
self._initial_solutions.append(problem.evaluate(solution))
generator = InjectorGenerator(solutions=self._initial_solutions)
else:
from jmetal.util.generator import RandomGenerator
generator = RandomGenerator()
self._solution_generator = generator
def __init__(self,
problem: Problem,
population_size: int,
offspring_population_size: int,
mutation: Mutation,
cloning_param: float,
termination_criterion: TerminationCriterion,
population_generator: Generator = RandomGenerator(),
population_evaluator: Evaluator = SequentialEvaluator()):
super(CloneAlg, self).__init__(
problem=problem,
population_size=population_size,
offspring_population_size=offspring_population_size)
self.population_size = population_size
self.offspring_population_size = offspring_population_size
self.mutation_operator = mutation
self.cloning_param = cloning_param
self.population_generator = population_generator
self.population_evaluator = population_evaluator
self.termination_criterion = termination_criterion
self.observable.register(termination_criterion)
def __init__(self,
problem: Problem,
strategies_params: List[StrategyParams],
termination_criterion: TerminationCriterion,
population_generator: Generator = RandomGenerator(),
population_evaluator: Evaluator = SequentialEvaluator()):
super(SocioCognitiveEvolutionStrategy, self).__init__()
self.strategies = [EvolutionStrategy(problem=problem,
mu=params.mu,
lambda_=params.lambda_,
elitist=params.elitist,
mutation=CognitivePolynomialMutation(probability=1.0 / problem.number_of_variables, look_at_others_probability=params.look_at_others_probability),
termination_criterion=termination_criterion) for params in strategies_params]
self.problem = problem
self.termination_criterion = termination_criterion
self.observable.register(termination_criterion)
self.population_generator = population_generator
self.population_evaluator = population_evaluator
self.history = []
def default_generator(self):
return RandomGenerator()