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, {}