def run_iteration(self, task, population, population_fitness, best_x,
best_fitness, **params):
r"""Core function of FlowerPollinationAlgorithm algorithm.
Args:
task (Task): Optimization task.
population (numpy.ndarray): Current population.
population_fitness (numpy.ndarray): Current population fitness/function values.
best_x (numpy.ndarray): Global best solution.
best_fitness (float): Global best solution function/fitness value.
**params (Dict[str, Any]): Additional arguments.
Returns:
Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]:
1. New population.
2. New populations fitness/function values.
3. New global best solution.
4. New global best solution fitness/objective value.
5. Additional arguments.
"""
solutions = params.pop('solutions')
for i in range(self.population_size):
if self.random() > self.p:
step_size = levy_flight(beta=self.beta,
size=task.dimension,
rng=self.rng)
solutions[i] += step_size * (population[i] - best_x)
else:
j, k = self.rng.choice(self.population_size,
size=2,
replace=False)
solutions[i] += self.random() * (population[j] - population[k])
solutions[i] = task.repair(solutions[i], rng=self.rng)
f_i = task.eval(solutions[i])
if f_i <= population_fitness[i]:
population[i], population_fitness[i] = solutions[i], f_i
if f_i <= best_fitness:
best_x, best_fitness = solutions[i].copy(), f_i
return population, population_fitness, best_x, best_fitness, {
'solutions': solutions
}
def run_iteration(self, task, population, population_fitness, best_x,
best_fitness, **params):
r"""Core function of CuckooSearch algorithm.
Args:
task (Task): Optimization task.
population (numpy.ndarray): Current population.
population_fitness (numpy.ndarray): Current populations fitness/function values.
best_x (numpy.ndarray): Global best individual.
best_fitness (float): Global best individual function/fitness values.
**params (Dict[str, Any]): Additional arguments.
Returns:
Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]:
1. Initialized population.
2. Initialized populations fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.
5. Additional arguments.
"""
i = self.integers(self.population_size)
new_nests = task.repair(
population[i] +
levy_flight(alpha=self.alpha, size=task.dimension, rng=self.rng),
rng=self.rng)
new_nests_fitness = task.eval(new_nests)
j = self.integers(self.population_size)
while i == j:
j = self.integers(self.population_size)
if new_nests_fitness <= population_fitness[j]:
population[j] = new_nests
population_fitness[j] = new_nests_fitness
population, population_fitness = self.abandon_nests(
population, population_fitness, task)
best_x, best_fitness = self.get_best(population, population_fitness,
best_x, best_fitness)
return population, population_fitness, best_x, best_fitness, {}
def get_cuckoos(self, population, best_x, task):
step_size = levy_flight(self.rng,
size=population.shape) * (population - best_x)
new_population = population + step_size * self.standard_normal(
population.shape)
return task.repair(new_population, rng=self.rng)
def run_iteration(self, task, population, population_fitness, best_x, best_fitness, **params):
r"""Core function of Harris Hawks Optimization.
Args:
task (Task): Optimization task.
population (numpy.ndarray): Current population
population_fitness (numpy.ndarray[float]): Current population fitness/function values
best_x (numpy.ndarray): Current best individual
best_fitness (float): Current best individual function/fitness value
params (Dict[str, Any]): Additional algorithm arguments
Returns:
Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]:
1. New population
2. New population fitness/function values
3. New global best solution
4. New global best fitness/objective value
"""
# Decreasing energy factor
decreasing_energy_factor = 2 * (1 - (task.iters + 1) / task.max_iters)
mean_sol = np.mean(population)
# Update population
for i in range(self.population_size):
jumping_energy = self.rng.uniform(0, 2)
decreasing_energy_random = self.rng.uniform(-1, 1)
escaping_energy = decreasing_energy_factor * decreasing_energy_random
escaping_energy_abs = np.abs(escaping_energy)
random_number = self.rng.random()
if escaping_energy >= 1 and random_number >= 0.5:
# 0. Exploration: Random tall tree
rhi = self.rng.integers(self.population_size)
random_agent = population[rhi]
population[i] = random_agent - self.rng.random() * np.abs(random_agent - 2 * self.rng.random() * population[i])
elif escaping_energy_abs >= 1 and random_number < 0.5:
# 1. Exploration: Family members mean
population[i] = (best_x - mean_sol) - self.rng.random() * self.rng.uniform(task.lower, task.upper)
elif escaping_energy_abs >= 0.5 and random_number >= 0.5:
# 2. Exploitation: Soft besiege
population[i] = \
(best_x - population[i]) - \
escaping_energy * \
np.abs(jumping_energy * best_x - population[i])
elif escaping_energy_abs < 0.5 <= random_number:
# 3. Exploitation: Hard besiege
population[i] = \
best_x - \
escaping_energy * \
np.abs(best_x - population[i])
elif escaping_energy_abs >= 0.5 > random_number:
# 4. Exploitation: Soft besiege with progressive rapid dives
cand1 = task.repair(best_x - escaping_energy * np.abs(jumping_energy * best_x - population[i]), rng=self.rng)
random_vector = self.rng.random(task.dimension)
cand2 = task.repair(cand1 + random_vector * levy_flight(alpha=self.levy, size=task.dimension, rng=self.rng),
rng=self.rng)
if task.eval(cand1) < population_fitness[i]:
population[i] = cand1
elif task.eval(cand2) < population_fitness[i]:
population[i] = cand2
elif escaping_energy_abs < 0.5 and random_number < 0.5:
# 5. Exploitation: Hard besiege with progressive rapid dives
cand1 = task.repair(best_x - escaping_energy * np.abs(jumping_energy * best_x - mean_sol), rng=self.rng)
random_vector = self.rng.random(task.dimension)
cand2 = task.repair(cand1 + random_vector * levy_flight(alpha=self.levy, size=task.dimension, rng=self.rng),
rng=self.rng)
if task.eval(cand1) < population_fitness[i]:
population[i] = cand1
elif task.eval(cand2) < population_fitness[i]:
population[i] = cand2
# Repair agent (from population) values
population[i] = task.repair(population[i], rng=self.rng)
# Eval population
population_fitness[i] = task.eval(population[i])
# Get best of population
best_index = np.argmin(population_fitness)
xb_cand = population[best_index].copy()
fxb_cand = population_fitness[best_index].copy()
if fxb_cand < best_fitness:
best_fitness = fxb_cand
best_x = xb_cand.copy()
return population, population_fitness, best_x, best_fitness, {}